Merge pull request #615 from fastfetch-cli/dev

Release v2.2.2

.github/FUNDING.yml

@@ -1 +1 @@
-github: LinusDierheimer
+github: [LinusDierheimer, CarterLi]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,27 +7,31 @@ 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 -->
+
 # General description of bug:
 
+* What happened:
+* What should happen:
+* 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/)?
 
-# Often helpful questions:
-* Does the issue occur across multiple terminal emulators? [Y/N]
-* Does the issue occur across multiple shells? (bash, zsh, fish, etc) [Y/N]
+# Often helpful information:
 
-Output of `fastfetch --version`:
+The content of the configuration file you use (if any)
 ```
 //paste here
 ```
 
-Output of `fastfetch --load-config devinfo`:
-```
-//paste here
-```
-
-Output of `fastfetch --load-config devinfo-verbose`:
+Output of `env NO_CONFIG=1 fastfetch --load-config all --show-errors --stat --multithreading false --disable-linewrap false --hide-cursor false`:
 <!--
 Note that this output will contain you public IP. If it is not relevant for the issue, feel free to remove it before uploading.
+
+If you get the following error: `Error: couldn't find config: [...]`, copy the files in [presets](../../presets/) to `/usr/share/fastfetch/presets/` or `~/.local/share/fastfetch/presets/`.
+If this isn't possible (or too much work) for you, post the output of `env NO_CONFIG=1 fastfetch --show-errors --stat --multithreading false --disable-linewrap false --hide-cursor false && fastfetch --version`. 
 -->
+
 ```
 //paste here
 ```
@@ -37,7 +41,39 @@ Output of `fastfetch --list-features`:
 //paste here
 ```
 
-<!--
-If you get the following error: `Error: couldn't find config: [...]`, copy the files in [presets](../../presets/) to `/usr/share/fastfetch/presets/` or `~/.local/share/fastfetch/presets/`.
-If this isn't possible (or too much work) for you, post the output of `fastfetch --show-errors --multithreading false --disable-linewrap false`. 
--->
+## If fastfatch crashed
+
+Paste the stacktrace here. You may get it with:
+
+```
+$ gdb /path/to/fastfetch
+$ run
+$ bt
+```
+
+If you are able to identify which module crashed, the strace can be helpful too
+
+```
+$ strace /path/to/fastfetch --multithreading false --structure {MODULE} --pipe
+```
+
+If you cannot do the instructions above, please upload the core dump file:
+
+## If my image logo didn't show / work
+
+<!-- Please make sure the terminal does support the image protocol you used. Note 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
+
+<!-- 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`): 
+* Does `sleep 1` before running `fastfetch` work? 

.github/workflows/ci.yml

@@ -0,0 +1,374 @@
+name: CI
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  linux-buildtest:
+    name: Linux build test
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, ubuntu-20.04]
+        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: ${{ matrix.os }}
+    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 libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev directx-headers-dev
+
+      - name: configure project
+        env:
+          CC: ${{ matrix.compiler.cc }}
+          CXX: ${{ matrix.compiler.cxx }}
+        run: cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DENABLE_LIBPCI=${{ matrix.enableFeatures }} -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 }} .
+
+      - name: build project
+        run: cmake --build .
+
+      - name: run tests
+        run: ctest
+
+      - name: run fastfetch --list-features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+  linux:
+    name: Linux
+    runs-on: ubuntu-20.04 # 22.04 ships a newer version of glibc than debian stable, allow those people to use the debian package
+    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 libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-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@v2
+        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
+
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v2
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest
+
+      - name: get fastfetch version
+        id: ffversion
+        run: echo "ffversion=$(./fastfetch --version-raw)" >> $GITHUB_OUTPUT
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-linux
+          path: ./fastfetch-*.*
+
+  macos:
+    name: MacOS
+    runs-on: macos-latest
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: uname -a
+        run: uname -a
+
+      - name: install required packages
+        run: |
+          brew update
+          brew install vulkan-loader vulkan-headers molten-vk imagemagick chafa
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: c
+
+      - name: configure project
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_OSX_ARCHITECTURES='arm64;x86_64' .
+
+      - name: build project
+        run: cmake --build . --target package --verbose
+
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v2
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: otool -L fastfetch
+
+      - name: run tests
+        run: ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-macos
+          path: ./fastfetch-*.*
+
+  freebsd:
+    name: FreeBSD
+    runs-on: macos-12
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: run VM
+        uses: cross-platform-actions/action@v0.21.1
+        with:
+          operating_system: freebsd
+          version: '13.2'
+          run: |
+            uname -a
+            sudo pkg update
+            sudo pkg install -y cmake git pkgconf binutils pciutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 glib dconf dbus sqlite3-tcl xfce4-conf ImageMagick6 ImageMagick7 chafa egl libosmesa opencl ocl-icd pulseaudio
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+            cmake --build . --target package --verbose
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci
+            time ./fastfetch -c presets/ci --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-freebsd
+          path: ./fastfetch-*.*
+
+  win64:
+    name: Win64
+    runs-on: windows-latest
+    permissions:
+      security-events: write
+      contents: read
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: setup-msys2
+        uses: msys2/setup-msys2@v2
+        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
+
+      - name: print msys version
+        run: uname -a
+
+      - name: configure project
+        run: env PKG_CONFIG_PATH=/clang64/lib/pkgconfig/:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . --verbose
+
+      - name: copy necessary dlls
+        run: cp /clang64/bin/{OpenCL,vulkan-1}.dll .
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest
+
+      - name: create zip archive
+        run: 7z a -tzip -mx9 -bd -y fastfetch-$(./fastfetch --version-raw)-Win64.zip *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: create 7z archive
+        run: 7z a -t7z -mx9 -bd -y fastfetch-$(./fastfetch --version-raw)-Win64.7z *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-win64
+          path: ./fastfetch-*-Win64.*
+
+  win32:
+    name: Win32
+    runs-on: windows-latest
+    permissions:
+      security-events: write
+      contents: read
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: setup-msys2
+        uses: msys2/setup-msys2@v2
+        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
+
+      - name: print msys version
+        run: uname -a
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: c, cpp
+
+      - name: configure project
+        run: env PKG_CONFIG_PATH=/clang32/lib/pkgconfig/:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . --verbose
+
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v2
+
+      - name: copy necessary dlls
+        run: cp /clang32/bin/{OpenCL,vulkan-1}.dll .
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest
+
+      - name: create zip archive
+        run: 7z a -tzip -mx9 -bd -y fastfetch-$(./fastfetch --version-raw)-Win32.zip *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: create 7z archive
+        run: 7z a -t7z -mx9 -bd -y fastfetch-$(./fastfetch --version-raw)-Win32.7z *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-win32
+          path: ./fastfetch-*-Win32.*
+
+  release:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master' && github.repository == 'fastfetch-cli/fastfetch'
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - linux
+      - macos
+      - freebsd
+      - win64
+      - win32
+    permissions:
+      contents: write
+    steps:
+      - name: download artifacts
+        uses: actions/download-artifact@v3
+
+      - name: get latest release version
+        id: get_version_release
+        uses: pozetroninc/github-action-get-latest-release@master
+        with:
+          repository: ${{ github.repository }}
+
+      - name: create release
+        if: needs.linux.outputs.ffversion != steps.get_version_release.outputs.release
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ needs.linux.outputs.ffversion }}
+          commit: ${{ github.sha }}
+          artifactErrorsFailBuild: true
+          artifacts: fastfetch-linux/*,fastfetch-macos/*,fastfetch-freebsd/*,fastfetch-win64/*,fastfetch-win32/*

.github/workflows/push.yml

@@ -1,238 +0,0 @@
-name: manage pushes
-
-on:
-  - push
-  - pull_request
-
-jobs:
-  linux:
-    name: Linux
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-      contents: read
-    outputs:
-      ffversion: ${{ steps.ffversion.outputs.ffversion }}
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v3
-
-      - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libcjson-dev libnm-dev
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-        with:
-          languages: c
-
-      - name: configure project
-        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
-
-      - name: build project
-        run: cmake --build . --target package
-
-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v2
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: run tests
-        run: ctest
-
-      - name: get fastfetch version
-        id: ffversion
-        run: echo "ffversion=$(./fastfetch --version-raw)" >> $GITHUB_OUTPUT
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: fastfetch-linux
-          path: ./fastfetch-*.*
-
-  macos:
-    name: MacOS
-    runs-on: macos-latest
-    permissions:
-      security-events: write
-      contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v3
-
-      - name: install required packages
-        run: brew install vulkan-loader molten-vk imagemagick chafa
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-        with:
-          languages: c
-
-      - name: configure project
-        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
-
-      - name: build project
-        run: cmake --build . --target package
-
-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v2
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: run tests
-        run: ctest
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: fastfetch-macos
-          path: ./fastfetch-*.*
-
-  freebsd:
-    name: FreeBSD
-    runs-on: macos-12
-    permissions:
-      security-events: write
-      contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v3
-
-      - name: run VM
-        uses: vmactions/freebsd-vm@v0
-        with:
-          prepare: |
-            pkg install -y cmake git pkgconf pciutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 glib dconf dbus sqlite3-tcl xfce4-conf ImageMagick6 ImageMagick7 chafa egl libosmesa opencl ocl-icd
-          run: |
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
-            cmake --build . --target package
-            ./fastfetch --list-features
-            time ./fastfetch --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
-            time ./flashfetch
-            ctest
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: fastfetch-freebsd
-          path: ./fastfetch-*.*
-
-  windows:
-    name: Windows
-    runs-on: windows-latest
-    permissions:
-      security-events: write
-      contents: read
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v3
-
-      - name: setup-msys2
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: CLANG64
-          update: true
-          install: git zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-cjson mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-opencl-icd
-
-      - name: print msys version
-        run: uname -a
-
-      # https://github.com/msys2/MINGW-packages/issues/13524#event-7555720785
-      - name: create OpenCL.pc
-        run: |
-          cat > /clang64/lib/pkgconfig/OpenCL.pc << EOF
-          prefix=/clang64
-          exec_prefix=${prefix}
-          libdir=${exec_prefix}/lib
-          includedir=${prefix}/include
-
-          Name: OpenCL
-          Description: Open Computing Language generic Installable Client Driver Loader
-          Version: 2022.09.30-1
-          Libs: -L${libdir} -lOpenCL.dll
-          Cflags: -I${includedir}
-          EOF
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-        with:
-          languages: c, cpp
-
-      - name: configure project
-        run: env PKG_CONFIG_PATH=/clang64/lib/pkgconfig/:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
-
-      - name: build project
-        run: cmake --build .
-
-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v2
-
-      - name: copy necessary dlls
-        run: cp /clang64/bin/{libcjson,libOpenCL,vulkan-1}.dll .
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-      - name: run tests
-        run: ctest
-
-      - name: create zip archive
-        run: zip fastfetch-$(./fastfetch --version-raw)-Windows.zip *.dll fastfetch.exe flashfetch.exe
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: fastfetch-windows
-          path: ./fastfetch-*-Windows.zip
-
-  release:
-    if: github.event_name == 'push' && github.ref == 'refs/heads/master' && github.repository == 'LinusDierheimer/fastfetch'
-    name: Release
-    runs-on: ubuntu-latest
-    needs:
-      - linux
-      - macos
-      - freebsd
-      - windows
-    permissions:
-      contents: write
-    steps:
-      - name: download artifacts
-        uses: actions/download-artifact@v3
-
-      - name: get latest release version
-        id: get_version_release
-        uses: pozetroninc/github-action-get-latest-release@master
-        with:
-          repository: ${{ github.repository }}
-
-      - name: create release
-        if: needs.linux.outputs.ffversion != steps.get_version_release.outputs.release
-        uses: ncipollo/release-action@v1
-        with:
-          tag: ${{ needs.linux.outputs.ffversion }}
-          commit: ${{ github.sha }}
-          artifactErrorsFailBuild: true
-          artifacts: fastfetch-linux/*,fastfetch-macos/*,fastfetch-freebsd/*,fastfetch-windows/*

CHANGELOG.md

@@ -1,3 +1,462 @@
+# 2.2.2
+
+Changes:
+* `--percent-type` now defaults to 9 (colored percentage numbers)
+* `fastfetch` now prints LocalIp module by default
+
+Features:
+* LocalIP module now prints netmask in CIDR format for IPv4 (LocalIP)
+* Bios module now detects system firmware type (Bios)
+* Improve detection of `Battery`
+    * Detect cycle count on supported platforms
+    * Detect temperature on Linux when supported
+    * Status detection on macOS has been adjusted to be consistant with other platforms
+* Linux binaries are built with imagemagick7 support
+
+Bugfixes:
+* Fix unitialized variables (#609)
+* Fix spelling of `--preserve-aspect-ratio` (#614)
+
+Logos:
+
+* Update NixOS_small
+
+# 2.2.1
+
+Hotfix release for #606
+
+Bugfixes:
+* Fix broken presets due to the breaking changes introduced in 2.2.0
+
+Features:
+* Pretty print `fastfetch --help`
+
+# 2.2.0
+
+This release introduces a new option `--migrate-config`, which migrates old flag based config file to new JSONC format
+
+Changes:
+* `--pipe` and `--stat` are moved from `general` options to `display` options. This affects cjson configuration.
+* Display keys `percent*` and `size*` in JSON config are restructured. e.g. `{ "sizeNdigits": 1 }` is now `{ "size": { "ndigits": 1 } }`
+* With the introduction of `--migrate-config`, the old flag based config file is deprecated, and will be removed in 3.0.0 (next major version)
+* Support of `--gen-config conf` is deprecated accordingly, and will be removed in 2.3.0 (next minor version)
+* The global flag `--allow-slow-operations` is splitted into some explicit flags in differnet modules
+    * `--packages-winget`: control whether `winget` packages count should be detected. Note it's a very slow operation, please enable it with caution.
+    * `--chassis-use-wmi`: control whether `WMI` query should be used to detect chassis type, which detects more information, but slower. This flag only affects `--chassis-format` and `--format json`.
+    * `--battery-use-setup-api`: control whether `SetupAPI` should be used on Windows to detect battery info, which supports multi batteries, but slower.
+    * `--wm-detect-plugin`: control whether WM plugins should be detected. Note it's implemented with global processes enumeration and can report false results.
+    * `--de-slow-version-detection`: control DE version should be detected with slow operations. It's usually not necessary and only provided as a backup.
+* `--localip-default-route-only` and `--netio-default-route-only` defaults to true to avoid large number of results
+
+Features:
+* Quirks for MIPS platforms (CPU, Linux)
+* Use devicetree path for OBP hosts (Host, Linux)
+* Detect `tmux: server` as tmux (Terminal, Linux)
+* Support urxvt version detection (Terminal, Linux)
+* Support st version detection (Terminal, Linux)
+* Support st terminal font detection (TerminalFont, Linux)
+* Support xfce4-terminal 1.1.0+ terminal font detection (TerminalFont, Linux)
+* Add option `--migrate-config <?target-file-path>`
+* Support Nvidia GPU temp and cuda core count detection via nvml. Use `--gpu-use-nvml` to enable it (GPU)
+* Try supporting Wifi authentication type detection in macOS Sonoma. Please file a feature request if you get `to be supported (num)` with result of `/System/Library/PrivateFrameworks/Apple80211.framework/Resources/airport -I | grep auth` (Wifi, macOS)
+
+Bugfixes:
+* Better GPU memory and type detection (GPU, Windows)
+* Don't print display type twice (Display)
+* Detect BSSID instead of Wifi MAC address to align with other platforms (Wifi, macOS)
+* Remove support of used GPU memory detection, which is not reliable and only supported with `--gpu-force-vulkan`. (GPU)
+* Fix flag `--brightness-ddcci-sleep` (Brightness, Linux)
+* Fix hanging if a child process prints to both stdout and stderr (Linux)
+
+Logos:
+* Add Black Mesa
+* Add cycledream
+* Add Evolinx
+* Add azos
+* Add Interix
+
+# 2.1.2
+
+Bugfixes:
+* Fix icon detection on Windows. It shows enabled system icons in desktop (`This PC`, `Recycle Bin`, etc) (Icon, Windows)
+* Fix compatibility with ddcutil 2.0 (Brightness, Linux)
+* Fix a compile warning (CPUUsage, FreeBSD)
+
+# 2.1.1
+
+Features:
+* Support opkg (Packages, Linux)
+* Support GNOME Console terminal version and font detection (Terminal, Linux)
+* Add `--cpu-freq-ndigits` to set number of digits for CPU frequency (CPU)
+* New module to detect physical disk I/O usage (DiskIO)
+* Add `--cpuusage-separate` to display CPU usage per CPU logical core
+* Add `--brightness-ddcci-sleep` to set the sleep times (in ms) when sending DDC/CI requests (Brightness, #580)
+
+Bugfixes:
+* Fix possible crashes on Windows 7 (Disk, Windows)
+* Fix possible crashes caused by uninitialized strings (Users, Windows)
+* Improve support of `--help *-format` and several bugs are found and fixed
+* Don't incorrectly print `No active sound devices found` when using a non-controllable sound device (Sound, macOS)
+* Fix implementation processes counting (Processes, Linux)
+* Work around a issue that SSID cannot be detected on macOS Sonoma (Wifi, macOS)
+
+Logo:
+* Add Chimera Linux
+* Add EndeavourSmall
+* Add Xenia
+* Add MainsailOS
+* Fix phyOS
+
+# 2.1.0
+
+This release introduces a new output format: JSON result
+
+Changes:
+* Users module detects and prints user login time by default. Specifying `--users-compact` to disable it
+* Fastfetch now requires yyjson 0.8.0 or later, which is embeded in fastfetch source tree. If you build fastfetch with `-DENABLE_SYSTEM_YYJSON` cmake option, you must upgrade your yyjson package
+* Reduced information supported by `--terminal-format`, `--shell-format`
+* Some config presets (`devinfo` and `verbose`) are obseleted and removed. They are barely maintained and can be replaced with `--format json` now.
+* Custom strings in `--module-key` and `--module-format` are no longer trimmed.
+* `/boot` is hidden by default (FreeBSD, Disk)
+
+Features:
+* Add `--format json`, which prints system information as JSON format
+* Add fast path for xfce4 version detection (DE, FreeBSD)
+* Support contour terminal version and font detection (Terminal / TerminalFont)
+* Support `kitty-direct` / `iterm` without specifying logo width / height. Note: in this case, the entre screen will be cleared.
+* Support new flag `--logo-separate`. If true, print modules at bottom of the logo
+* Support Apple Silicon CPU frequency detection (CPU, macOS)
+* Support user login time detection (Users)
+* Support winget package manager detection, guarded behind `--allow-slow-operations` (Packages, Windows)
+* Print monitor type (built-in or external) (Display)
+* Support full GPU detection in WSL (Linux, GPU)
+* Add `--module-key " "` as a special case for hiding keys
+* Support `--title-format`. See `fastfetch --help title-format` for detail
+* Support `--colors-key` (Colors)
+* Add `-c` as a shortcut of `--load-config`. Note it was used as the shortcut of `--color` before 2.0.5
+* Support Windows Service Pack version detection (Kernel, Windows)
+* Support Debian point releases detection (OS, Linux)
+* Add new module `NetIO` which prints network throughput (usage) of specified interface. Note this module costs about 1 second to finish.
+* Use `lscpu` to detect CPU name for ARM CPUs (CPU, Linux)
+
+Bugfixes:
+* Fix fastfetch hanging in specific environment (#561)
+* Fix short read when reading from stdin (Logo)
+* Fix `poll() timeout or failed` error when image is very large (Logo)
+* Fix Termux Monet terminal version detection (Terminal)
+* Fix zpool volumes detection (Disk, Linux)
+* Fix external volumes detection (Disk, Linux)
+* Fix snap package number detection on systems other than Ubuntu (Packages, Linux)
+* Fix dpkg / apt package number detection (Packages, Linux)
+* Fix bluetooth mac address detection (Bluetooth, Windows)
+
+Logo:
+* Add Afterglow
+* Add Elbrus
+* Update EvolutionOS
+* Update AOSC OS
+* Update Ubuntu_old
+* Update Windows 11_small
+* Add Amazon Linux
+* Add LainOS
+* Fix colors of Slackware
+
+# 2.0.5
+
+Bugfixes:
+* Fix segfault when using libxrandr (#544, Display, Linux)
+* Don't print 0px (#544, Cursor)
+
+Features:
+* Add option `--disk-use-available` (#543)
+* Add option `--disk-show-readonly`
+
+# 2.0.4
+
+Bugfixes:
+* Fix building on 32-bit FreeBSD (Memory, FreeBSD)
+* Fix `--file-raw` doesn't work (Logo)
+
+Features:
+* Trait `-` as an alias for `/dev/stdin`. Available for `--file`, `--file-raw` and `--raw` (Logo)
+
+# 2.0.3
+
+Bugfixes:
+* Fix typo in config parsing for --color-title (#534)
+* Fix percent formatting for `--*-format` (#535)
+* Fix loading presets for homebrew (macOS)
+
+Features:
+* Add option `--percent-ndigits`
+* Add command flag `--config` as an alias of `--load-config`
+* Windows packages now include presets (Windows)
+
+# 2.0.2
+
+Bugfixes:
+* Workarund [a compiler bug of GCC](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85282) (Windows)
+* Fix presets not detected by file name (#529)
+
+Logo:
+* Add Tuxedo OS
+
+# 2.0.1
+
+First stable release of Fastfetch V2
+
+Changes:
+* Unescape strings only when parsing `.conf` files
+    * Previously: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\: *`. Note the backslashs are unescaped twice (once by shell and once by fastfetch).
+    * Now: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\\: *`
+* Remove option shortcut `-c` (alias of `--color`), which is more commonly used as alias of `--config`
+* Rename `--recache` to `--logo-recache` (which is used for regenerate image logo cache). Remove option shortcut `-r` (alias of `--recache`).
+* Detecting brightness of external displays with DDC/CI is no longer guarded behind `--allow-slow-operations` (Brightness)
+
+Features:
+* Add `--key-width` for aligning the left edge of values, supported both for global `--key-width` and specific module `--module-key-width`
+* Add `--bar-char-elapsed`, `--bar-char-total`, `--bar-width` and `--bar-border` options
+* Add CMake option `ENABLE_SYSTEM_YYJSON`, which allow building fastfetch with system-provided yyjson (for package managers)
+* Add new module `Version`, which prints fastfetch version (like `fastfetch --version`)
+
+Bugfixes:
+* Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux)
+* Fix some module options were not inited
+* Fix terminal version and font detection on NixOS (Terminal, Linux)
+
+# 2.0.0-beta
+
+Fastfetch v2 introduces a new configuration file format: JSON config. Please refer to <https://github.com/fastfetch-cli/fastfetch/wiki/Configuration> for details.
+
+Changes:
+* Drop the dependency of cJSON. We now use [yyjson](https://ibireme.github.io/yyjson/doc/doxygen/html/index.html) to parse JSON documents.
+* Remove `--shell-version` and `--terminal-version`. They are always enabled (Terminal / Shell)
+* Remove `--*-error-format`, which seems to be useless
+* Remove `--display-detect-name`. Display name is always detected, and will be printed if multiple displays are detected
+* Deprecate `--set` and `--set-keyless`; they may be removed in future releases. Use JSON config with Custom module instead
+* Remove the special handling of Command module (it can be set once in the triditional `config.conf`). Use JSON config with Command module instead
+* Change `--wm-theme-*` to `--wmtheme-*`. Affect `key` and `format` (WMTheme)
+* Change `--terminal-font-*` to `--terminalfont-*`. Affect `key` and `format` (TerminalFont)
+* Module `Command` uses `/bin/sh` as the default shell on systems other than Windows (Command)
+* Fix M2 CPU temperature detection (CPU, macOS)
+* Detect monitor name when available, instead of using DRM connector name (Display / Brightness, Linux)
+
+Features:
+* FreeBSD support is improved greatly, and actually tested in a physical machine
+* Add `--no-buffer` option for easier debugging. CMake option `ENABLE_BUFFER` is removed and always enabled.
+* Support `--*-key-color` option to change the key color of specified module
+* Support `--colors-symbol` and `--colors-padding-left` (Colors)
+* Add LM (Login Manager) module. Currently requires systemd installed (thus Linux only)
+* Add `--wmi-timeout` option (Windows)
+* Add `--logo-type small` to search for small logos
+* Support detecting brightness of external displays with DDC/CI (guard behind `--allow-slow-operations`) (Brightness)
+* Add option `--size-ndigits` and `--size-max-prefix` (#494)
+* Add option `--processing-timeout` to the timeout when waiting for child processes.
+* Public IP module prints the IP location if `--publicip-url` is not set (PublicIP)
+* Add option `--localip-default-route-only` (LocalIP)
+* Add option `--weather-location` (Weather)
+* Support iTerm non-ascii font detection (Terminal, macOS)
+* Add option `--title-color-user`, `--title-color-at` and `--title-color-host` (Title)
+* Add Exherbo logo and package manager count (Packages, Linux, #503)
+* Add module `Terminal Size` which prints the number of terminal width and height in characters and pixels
+* Add new option `--temperature-unit`
+* Better CPU and Host detection for Android (Android)
+* Support yakuake terminal version & font detection (Terminal, Linux)
+* Add new option `--bright-color` which can be used to disable the default bright color of keys, title and ASCII logo.
+* Add module `Monitor` which prints physical parameters (native resolutions and demensions) of connected monitors
+* Support path with environment variables for `--logo-source` and `--load-config`.
+
+Bugfixes:
+* Fix possible hanging (TerminalFont, #493)
+* Fix heap-buffer-overflow reading (DisplayServer, Linux)
+* Fix false errors when built without libnm support (Wifi, Linux)
+* Properly detect CPU on POWER (CPU, Linux)
+* Fix compatibility with Fig (Terminal, macOS)
+* Fix option `--title-fqdn` doesn't work (Title)
+* Fix used spaces calculation (Disk, Linux / BSD / macOS, #508)
+* Fix `--brightness-format` (Brightness)
+* Fix specifying `--set-keyless` with the same key second time won't override the value set before (#517)
+* Fix specifying `--color` second time won't clear the value set before (#517)
+
+Logo:
+* Change the special handling of `kitty` protocol with `.png` image file to a new image protocol `kitty-direct`. This is the fastest image protocol because fastfetch doesn't need to pre-encode the image to base64 or something and the image content doesn't need to be transmitted via tty. Note:
+    1. Although konsole was said to support `kitty` image protocol, it doesn't support `kitty-direct`
+    2. wezterm support more image formats other than `.png` (tested with `.jpg` and `.webp`)
+* Port all logos supported by neo(wo)fetch. Fastfetch now has 350 builtin logos in total.
+
+# 1.12.2
+
+Features:
+* Support terminator terminal version detection (Linux, Terminal)
+* Support `pkgtool` package manager detection (Linux, Packages)
+* Support `Far` shell version detection (Windows, Shell)
+
+Bugfixes:
+* Fix ConEmu terminal detection in some special cases (Windows, Terminal, #488)
+* Fix incorrect Host on M2 Mac Studio with M2 Max CPU (macOS, Host, #490)
+
+# 1.12.1
+
+Bugfixes:
+* Fix compiling error on Apple Slicon (Bios, macOS)
+
+# 1.12.0
+
+This release backports some changes from dev branch, and fixes 2 crashing issues
+
+Features:
+* 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
+* Detect new macs released on WWDC 2023 (macOS, Host)
+* Count cached memory as free memory (FreeBSD, Memory)
+* Support sound detection (FreeBSD, Sound)
+
+Bugfixes:
+* Fix DE detection on Windows 8.1 (Windows, DE)
+* Fix `--logo-padding-left` doesn't work when `--logo-padding-top` is set (Logo)
+* Fix KDE version detection on Fedora (DE)
+* Include limits.h when needed (Linux, #472)
+* 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 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)
+
+Logo:
+* Add bsd, freebsd_small, ghostbsd
+* Make Windows 11 logo colorable
+
+# 1.11.3
+
+Bugfixes:
+* Fix a segfault bug, regression of `1.11.1` (Linux, wmtheme, #467)
+
+# 1.11.2
+
+This release should be the last version of fastfetch 1.x (if no serious bugs found, hopefully)
+
+Features:
+* Support display name, type, rotation detection on Wayland (Linux, Display)
+* Print more useful display name instead of intel_backlight (Linux, Brightness)
+* Icons module supports Windows (Windows, Icons)
+* Add Wallpaper module which shows the current wallpaper image path
+* Add mac address detection `--localip-show-mac` (LocalIP, #451)
+
+Bugfixes:
+* Fix Gnome version detection on Fedora (DE)
+* Fix Windows drives detection in WSL (Disk)
+
+Changes:
+* In order to make Icons module consistant 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`
+* `--localip-v6first` is no longer supported.
+
+# 1.11.1
+
+Features:
+* Support xonsh detection (TerminalShell)
+* Support Tabby version / terminal font detection (TerminalFont)
+
+Bugfixes:
+* Fix name of Pro Controller (Gamepad, Windows)
+* Fix compile error with imagemagick enabled (Windows)
+* Fix copy-and-paste errors (Gamepad)
+* Flatpak: Fix user package count
+* Flatpak: Count runtime packages too (#441)
+* Fix flatpak package count (#441)
+* Don't print white color blocks with `--pipe` (#450)
+* Fix iTerm being detected as iTermServer-* sometimes
+* Fix sound device volume being incorrectly detected as muted sometimes (Sound)
+* Fix memleaks reported by LeakSanitizer (Linux)
+* Fix potential memory curruption bug in unicode.c (Windows)
+
+Logo:
+* Update Windows 11 ASCII logo to look more visually consistent (#445)
+* Add another font color index to arch icon (#446)
+* Add SteamOS
+* Add macOS small / small2
+
+# 1.11.0
+
+Features:
+* Support linuxbrew (Packages, Linux)
+* Support foot terminal (#431, Linux)
+* Support cursor size detection on Windows (Cursor, Windows)
+* Support cursor detection on macOS (Cursor, macOS)
+* Support display name, display type and decimal refresh rate detection (Display, macOS / Windows)
+* Support `--display-compact-type` to display multiple resolutions in one line (Display)
+* Support flatpak-user (Packages, Linux, #436)
+* Support `--gpu-force-vulkan` to force using vulkan to detect GPUs, which support video memory usage detection with `--allow-slow-operations` (GPU)
+
+Bugfixes:
+* Fix date time format
+* Fix compiling with musl (Wifi, Linux, #429)
+* Don't exit if libpci is failed to init (GPU, Linux, #433)
+* Names of most well-known gamepads are correctly printed instead of `Wireless Controller` on Windows
+
+Logo:
+* Small update for nobara logo (#435, @regulargvy13)
+
+# 1.10.3
+
+Bugfixes:
+* Fix uninitialized variables (GPU, Windows)
+* Fix compiling errors (Windows)
+
+Improvements:
+* Improve preformance (WmTheme amd Font, Windows and macOS)
+* Enable nonblocking public-ip / weather detection (Android)
+
+# 1.10.2
+
+Bugfixes:
+* Handle `kAudioObjectPropertyElementMain` for macOS **SDK** < 12 (#425, @nandahkrishna)
+* Add missing `NULL` for `ffProcessAppendStdOut` (#421)
+
+# 1.10.1
+
+New release for debugging #421
+
+# 1.10.0
+
+Notable Changes:
+
+* With the support of Win32 platform, original Windows 64bit artifact file is renamed to Win64 to avoid possible confusion
+
+Features:
+* Bluetooth module
+* Sound module
+* Gamepad module
+* Support colored percentage numbers output (#409)
+* Support `--localip-compact-type` option (#408)
+* Terminator terminal font detection (@Zerogiven, #415)
+* Windows 32bit compatibility
+* Support global configuration in MSYS2 environment (Windows)
+* Support GPU driver version detection on Windows 11
+* Support scaled resolution detection for wayland (Linux)
+
+Bugfixes:
+
+* Fix build with older libnm versions
+* Fix a rare case that fails to detect terminal
+* Fix Muffin detection (@Zerogiven, #411)
+* Fix IPv6 detection (Windows)
+* Fix scoop package count detection when scoop is installed in non-default path (Windows, #417)
+* Fix UB reported by clang
+* Honor $SCOOP when detecting scoop packages (#417)
+
+Other:
+
+* Simplified wmtheme output format (Windows)
+* Improved GPU detection performance on Windows 11
+* Lastest Mac model identifier support (macOS)
+
 # 1.9.1
 
 Bugfixes:

CMakeLists.txt

@@ -1,10 +1,10 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url
 
 project(fastfetch
-    VERSION 1.9.1
+    VERSION 2.2.2
     LANGUAGES C
-    DESCRIPTION "Fast system information tool"
-    HOMEPAGE_URL "https://github.com/LinusDierheimer/fastfetch"
+    DESCRIPTION "Fast neofetch-like system information tool"
+    HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
 )
 
 set(PROJECT_LICENSE "MIT license")
@@ -22,10 +22,6 @@ elseif(NOT APPLE AND NOT WIN32)
     message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}")
 endif()
 
-if(WIN32)
-    enable_language(CXX)
-endif()
-
 #############################
 # Compile time dependencies #
 #############################
@@ -57,7 +53,7 @@ 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" OFF)
+cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR BSD OR APPLE" 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)
@@ -67,14 +63,16 @@ 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_LIBCJSON "Enable libcjson" ON "LINUX OR WIN32" OFF)
 cmake_dependent_option(ENABLE_LIBNM "Enable libnm" ON "LINUX" OFF)
 cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)
-cmake_dependent_option(ENABLE_THREADS "Enable multithreading" ON "Threads_FOUND AND NOT ANDROID" OFF)
-cmake_dependent_option(ENABLE_BUFFER "Enable stdout buffer" ON "LINUX OR APPLE OR BSD OR WIN32 OR ANDROID" OFF)
-cmake_dependent_option(USE_WIN_NTAPI "Allow using internal NTAPI" ON "WIN32" OFF)
-cmake_dependent_option(USE_WIN_GPU_DXGI "Use DXGI to detect GPUs instead of WMI. Faster, but may ignore GPUs that only support DX9" ON "WIN32" OFF)
+cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR BSD" 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_THREADS "Enable multithreading" ON "Threads_FOUND" OFF)
+cmake_dependent_option(ENABLE_PCI_MEMORY "Enable detecting GPU memory size with libpci" OFF "LINUX OR BSD" OFF)
 
+option(ENABLE_SYSTEM_YYJSON "Use system provided (instead of fastfetch embeded) yyjson library" OFF)
+option(ENABLE_ASAN "Build fastfetch with ASAN (address sanitizer)" OFF)
 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
 
@@ -83,7 +81,7 @@ option(SET_TWEAK "Add tweak to project version" ON) # This is set to off by gith
 ####################
 
 if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release)
+    set(CMAKE_BUILD_TYPE RelWithDebInfo)
 endif()
 
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
@@ -97,12 +95,18 @@ else()
     message(STATUS "Threads type: disabled")
 endif()
 
+set(WARNING_FLAGS "-Wall -Wextra -Wconversion -Werror=uninitialized -Werror=return-type")
+
 set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wconversion")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} -Werror=incompatible-pointer-types -Werror=implicit-function-declaration -Werror=int-conversion")
+
+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")
+endif()
 
 if(WIN32)
-    set(CMAKE_CXX_STANDARD 11)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wconversion -fno-exceptions -fno-rtti")
     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")
 endif()
 
@@ -113,13 +117,18 @@ if(APPLE AND DEFINED ENV{HOMEBREW_PREFIX})
 endif()
 
 set(FASTFETCH_FLAGS_DEBUG "-fno-omit-frame-pointer")
-if(NOT WIN32)
-    set(FASTFETCH_FLAGS_DEBUG "${FASTFETCH_FLAGS_DEBUG} -fsanitize=address -fsanitize=undefined")
+if(ENABLE_ASAN)
+    message(STATUS "Address sanitizer enabled (DEBUG only)")
+    set(FASTFETCH_FLAGS_DEBUG "${FASTFETCH_FLAGS_DEBUG} -fsanitize=address")
 endif()
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${FASTFETCH_FLAGS_DEBUG}")
-set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} ${FASTFETCH_FLAGS_DEBUG} -rdynamic")
+set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${FASTFETCH_FLAGS_DEBUG}")
+if(NOT WIN32)
+    set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -rdynamic")
+endif()
 
 if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(STATUS "Enabling LTO")
     include(CheckIPOSupported)
     check_ipo_supported(RESULT IPO_SUPPORTED)
     if(IPO_SUPPORTED)
@@ -161,6 +170,8 @@ if(NOT TARGET_DIR_ETC)
     set(TARGET_DIR_ETC "${TARGET_DIR_ROOT}/etc")
 endif()
 
+message(STATUS "Target dirs: ROOT=\"${TARGET_DIR_ROOT}\" USR=\"${TARGET_DIR_USR}\" HOME=\"${TARGET_DIR_HOME}\" ETC=\"${TARGET_DIR_ETC}\"")
+
 #https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.html
 if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
     set(CMAKE_INSTALL_PREFIX "${TARGET_DIR_USR}" CACHE PATH "..." FORCE)
@@ -205,17 +216,41 @@ endfunction(fastfetch_load_text)
 fastfetch_load_text(src/data/structure.txt DATATEXT_STRUCTURE)
 fastfetch_load_text(src/data/config_system.txt DATATEXT_CONFIG_SYSTEM)
 fastfetch_load_text(src/data/config_user.txt DATATEXT_CONFIG_USER)
-fastfetch_load_text(src/data/modules.txt DATATEXT_MODULES)
+fastfetch_load_text(src/data/config_user.jsonc DATATEXT_CONFIG_USER_JSONC)
 fastfetch_load_text(src/data/help.txt DATATEXT_HELP)
 fastfetch_load_text(src/data/help_color.txt DATATEXT_HELP_COLOR)
 fastfetch_load_text(src/data/help_format.txt DATATEXT_HELP_FORMAT)
 fastfetch_load_text(src/data/help_config.txt DATATEXT_HELP_CONFIG)
 
-######################
-# Configure config.h #
-######################
+configure_file(src/fastfetch_config.h.in fastfetch_config.h @ONLY)
+configure_file(src/fastfetch_datatext.h.in fastfetch_datatext.h @ONLY)
+if(APPLE)
+    configure_file(src/util/apple/Info.plist.in Info.plist @ONLY)
+endif()
 
-configure_file(src/fastfetch_config.h.in fastfetch_config.h)
+####################
+# Ascii image data #
+####################
+
+function(fastfetch_load_raw_text FILENAME OUTVAR)
+    file(READ "${FILENAME}" TEMP)
+    string(REGEX REPLACE "\n$" "" TEMP "${TEMP}") # Remove trailing newline
+    string(REPLACE "\\" "\\\\" TEMP "${TEMP}")    # Escape backslashes
+    string(REPLACE "\n" "\\n" TEMP "${TEMP}")     # Replace newlines with \n
+    string(REPLACE "\"" "\\\"" TEMP "${TEMP}")    # Replace quotes with \"
+    set(${OUTVAR} "\"${TEMP}\"" PARENT_SCOPE)
+endfunction(fastfetch_load_raw_text)
+
+file(GLOB LOGO_FILES "src/logo/ascii/*.txt")
+set(LOGO_BUILTIN_H "#pragma once\n\n")
+foreach(file ${LOGO_FILES})
+    fastfetch_load_raw_text("${file}" content)
+    get_filename_component(file "${file}" NAME_WLE)
+    string(TOUPPER "${file}" file)
+    string(REGEX REPLACE "\\$\\{c([0-9]+)\\}" "$\\1" content "${content}")
+    set(LOGO_BUILTIN_H "${LOGO_BUILTIN_H}#define FASTFETCH_DATATEXT_LOGO_${file} ${content}\n")
+endforeach()
+file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}")
 
 #######################
 # libfastfetch target #
@@ -223,91 +258,119 @@ configure_file(src/fastfetch_config.h.in fastfetch_config.h)
 
 set(LIBFASTFETCH_SRC
     src/common/bar.c
+    src/common/commandoption.c
     src/common/font.c
     src/common/format.c
     src/common/init.c
-    src/common/io.c
+    src/common/jsonconfig.c
     src/common/library.c
+    src/common/modules.c
+    src/common/netif/netif.c
+    src/common/option.c
     src/common/parsing.c
     src/common/printing.c
     src/common/properties.c
     src/common/settings.c
+    src/detection/chassis/chassis.c
     src/detection/cpu/cpu.c
-    src/detection/cpuUsage/cpuUsage.c
-    src/detection/datetime.c
+    src/detection/cpuusage/cpuusage.c
     src/detection/disk/disk.c
+    src/detection/diskio/diskio.c
     src/detection/displayserver/displayserver.c
     src/detection/font/font.c
     src/detection/gpu/gpu.c
-    src/detection/host/host.c
     src/detection/locale/locale.c
     src/detection/media/media.c
+    src/detection/netio/netio.c
+    src/detection/opencl/opencl.c
     src/detection/os/os.c
     src/detection/packages/packages.c
+    src/detection/publicip/publicip.c
     src/detection/terminalfont/terminalfont.c
     src/detection/terminalshell/terminalshell.c
-    src/detection/vulkan.c
+    src/detection/version/version.c
+    src/detection/vulkan/vulkan.c
+    src/detection/weather/weather.c
     src/logo/builtin.c
     src/logo/image/im6.c
     src/logo/image/im7.c
     src/logo/image/image.c
     src/logo/logo.c
-    src/modules/battery.c
-    src/modules/bios.c
-    src/modules/board.c
-    src/modules/brightness.c
-    src/modules/break.c
-    src/modules/chassis.c
-    src/modules/colors.c
-    src/modules/cpu.c
-    src/modules/cpuUsage.c
-    src/modules/cursor.c
-    src/modules/custom.c
-    src/modules/command.c
-    src/modules/date.c
-    src/modules/datetime.c
-    src/modules/de.c
-    src/modules/disk.c
-    src/modules/font.c
-    src/modules/gpu.c
-    src/modules/host.c
-    src/modules/icons.c
-    src/modules/kernel.c
-    src/modules/locale.c
-    src/modules/localip.c
-    src/modules/memory.c
-    src/modules/opencl.c
-    src/modules/opengl.c
-    src/modules/os.c
-    src/modules/packages.c
-    src/modules/player.c
-    src/modules/poweradapter.c
-    src/modules/processes.c
-    src/modules/publicip.c
-    src/modules/display.c
-    src/modules/separator.c
-    src/modules/shell.c
-    src/modules/media.c
-    src/modules/terminal.c
-    src/modules/terminalfont.c
-    src/modules/theme.c
-    src/modules/time.c
-    src/modules/title.c
-    src/modules/uptime.c
-    src/modules/users.c
-    src/modules/vulkan.c
-    src/modules/weather.c
-    src/modules/wifi.c
-    src/modules/wm.c
-    src/modules/wmtheme.c
+    src/modules/battery/battery.c
+    src/modules/bios/bios.c
+    src/modules/bluetooth/bluetooth.c
+    src/modules/board/board.c
+    src/modules/brightness/brightness.c
+    src/modules/break/break.c
+    src/modules/chassis/chassis.c
+    src/modules/colors/colors.c
+    src/modules/cpu/cpu.c
+    src/modules/cpuusage/cpuusage.c
+    src/modules/cursor/cursor.c
+    src/modules/custom/custom.c
+    src/modules/command/command.c
+    src/modules/datetime/datetime.c
+    src/modules/de/de.c
+    src/modules/disk/disk.c
+    src/modules/diskio/diskio.c
+    src/modules/font/font.c
+    src/modules/gpu/gpu.c
+    src/modules/host/host.c
+    src/modules/icons/icons.c
+    src/modules/gamepad/gamepad.c
+    src/modules/kernel/kernel.c
+    src/modules/lm/lm.c
+    src/modules/locale/locale.c
+    src/modules/localip/localip.c
+    src/modules/memory/memory.c
+    src/modules/monitor/monitor.c
+    src/modules/netio/netio.c
+    src/modules/opencl/opencl.c
+    src/modules/opengl/opengl.c
+    src/modules/os/os.c
+    src/modules/packages/packages.c
+    src/modules/processes/processes.c
+    src/modules/player/player.c
+    src/modules/poweradapter/poweradapter.c
+    src/modules/publicip/publicip.c
+    src/modules/display/display.c
+    src/modules/separator/separator.c
+    src/modules/shell/shell.c
+    src/modules/sound/sound.c
+    src/modules/swap/swap.c
+    src/modules/media/media.c
+    src/modules/terminal/terminal.c
+    src/modules/terminalfont/terminalfont.c
+    src/modules/terminalsize/terminalsize.c
+    src/modules/theme/theme.c
+    src/modules/title/title.c
+    src/modules/uptime/uptime.c
+    src/modules/users/users.c
+    src/modules/version/version.c
+    src/modules/vulkan/vulkan.c
+    src/modules/wallpaper/wallpaper.c
+    src/modules/weather/weather.c
+    src/modules/wifi/wifi.c
+    src/modules/wm/wm.c
+    src/modules/wmtheme/wmtheme.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/FFlist.c
     src/util/FFstrbuf.c
-    src/util/FFvaluestore.c
     src/util/platform/FFPlatform.c
+    src/util/stringUtils.c
+    src/util/smbiosHelper.c
 )
 
 if(LINUX)
     list(APPEND LIBFASTFETCH_SRC
+        src/common/dbus.c
+        src/common/io/io_unix.c
+        src/common/netif/netif_linux.c
         src/common/networking_linux.c
         src/common/processing_linux.c
         src/detection/battery/battery_linux.c
@@ -316,9 +379,11 @@ if(LINUX)
         src/detection/brightness/brightness_linux.c
         src/detection/chassis/chassis_linux.c
         src/detection/cpu/cpu_linux.c
-        src/detection/cpuUsage/cpuUsage_linux.c
+        src/detection/cpuusage/cpuusage_linux.c
         src/detection/cursor/cursor_linux.c
+        src/detection/bluetooth/bluetooth_linux.c
         src/detection/disk/disk_linux.c
+        src/detection/diskio/diskio_linux.c
         src/detection/displayserver/linux/displayserver_linux.c
         src/detection/displayserver/linux/wayland.c
         src/detection/displayserver/linux/wmde.c
@@ -326,76 +391,110 @@ if(LINUX)
         src/detection/displayserver/linux/xlib.c
         src/detection/font/font_linux.c
         src/detection/gpu/gpu_linux.c
-        src/detection/gtk.c
+        src/detection/gpu/gpu_nvidia.c
+        src/detection/gtk_qt/gtk.c
         src/detection/host/host_linux.c
+        src/detection/icons/icons_linux.c
+        src/detection/libc/libc_linux.c
+        src/detection/lm/lm_linux.c
         src/detection/localip/localip_linux.c
+        src/detection/gamepad/gamepad_linux.c
         src/detection/media/media_linux.c
         src/detection/memory/memory_linux.c
+        src/detection/monitor/monitor_linux.c
+        src/detection/netio/netio_linux.c
         src/detection/opengl/opengl_linux.c
         src/detection/os/os_linux.c
         src/detection/packages/packages_linux.c
         src/detection/poweradapter/poweradapter_nosupport.c
         src/detection/processes/processes_linux.c
-        src/detection/qt.c
+        src/detection/gtk_qt/qt.c
+        src/detection/sound/sound_linux.c
         src/detection/swap/swap_linux.c
         src/detection/temps/temps_linux.c
         src/detection/terminalfont/terminalfont_linux.c
         src/detection/terminalshell/terminalshell_linux.c
+        src/detection/terminalsize/terminalsize_linux.c
+        src/detection/theme/theme_linux.c
         src/detection/uptime/uptime_linux.c
         src/detection/users/users_linux.c
+        src/detection/wallpaper/wallpaper_linux.c
         src/detection/wifi/wifi_linux.c
+        src/detection/wm/wm_nosupport.c
+        src/detection/de/de_linux.c
         src/detection/wmtheme/wmtheme_linux.c
         src/util/platform/FFPlatform_unix.c
     )
 elseif(ANDROID)
     list(APPEND LIBFASTFETCH_SRC
+        src/common/io/io_unix.c
+        src/common/netif/netif_linux.c
         src/common/networking_linux.c
         src/common/processing_linux.c
         src/detection/battery/battery_android.c
-        src/detection/bios/bios_nosupport.c
-        src/detection/board/board_nosupport.c
+        src/detection/bios/bios_android.c
+        src/detection/bluetooth/bluetooth_nosupport.c
+        src/detection/board/board_android.c
         src/detection/brightness/brightness_nosupport.c
         src/detection/chassis/chassis_nosupport.c
         src/detection/cpu/cpu_linux.c
         src/detection/cursor/cursor_nosupport.c
-        src/detection/cpuUsage/cpuUsage_linux.c
+        src/detection/cpuusage/cpuusage_linux.c
         src/detection/disk/disk_linux.c
-        src/detection/displayserver/displayserver_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/libc/libc_android.c
+        src/detection/lm/lm_nosupport.c
         src/detection/localip/localip_linux.c
+        src/detection/gamepad/gamepad_nosupport.c
         src/detection/media/media_nosupport.c
         src/detection/memory/memory_linux.c
+        src/detection/monitor/monitor_nosupport.c
+        src/detection/netio/netio_linux.c
         src/detection/opengl/opengl_linux.c
         src/detection/os/os_android.c
         src/detection/packages/packages_linux.c
         src/detection/poweradapter/poweradapter_nosupport.c
         src/detection/processes/processes_linux.c
+        src/detection/sound/sound_nosupport.c
         src/detection/swap/swap_linux.c
         src/detection/temps/temps_linux.c
         src/detection/terminalfont/terminalfont_android.c
         src/detection/terminalshell/terminalshell_linux.c
+        src/detection/terminalsize/terminalsize_linux.c
+        src/detection/theme/theme_nosupport.c
         src/detection/uptime/uptime_linux.c
         src/detection/users/users_linux.c
+        src/detection/wallpaper/wallpaper_nosupport.c
         src/detection/wifi/wifi_android.c
+        src/detection/wm/wm_nosupport.c
+        src/detection/de/de_nosupport.c
         src/detection/wmtheme/wmtheme_nosupport.c
         src/util/platform/FFPlatform_unix.c
     )
 elseif(BSD)
     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/common/sysctl.c
         src/detection/battery/battery_bsd.c
         src/detection/bios/bios_bsd.c
-        src/detection/board/board_nosupport.c
-        src/detection/brightness/brightness_nosupport.c
-        src/detection/chassis/chassis_nosupport.c
+        src/detection/bluetooth/bluetooth_linux.c
+        src/detection/board/board_bsd.c
+        src/detection/brightness/brightness_bsd.c
+        src/detection/chassis/chassis_bsd.c
         src/detection/cpu/cpu_bsd.c
-        src/detection/cpuUsage/cpuUsage_bsd.c
+        src/detection/cpuusage/cpuusage_bsd.c
         src/detection/cursor/cursor_linux.c
         src/detection/disk/disk_bsd.c
+        src/detection/diskio/diskio_bsd.c
         src/detection/displayserver/linux/displayserver_linux.c
         src/detection/displayserver/linux/wayland.c
         src/detection/displayserver/linux/wmde.c
@@ -403,61 +502,89 @@ elseif(BSD)
         src/detection/displayserver/linux/xlib.c
         src/detection/font/font_linux.c
         src/detection/gpu/gpu_linux.c
-        src/detection/gtk.c
+        src/detection/gpu/gpu_nvidia.c
+        src/detection/gtk_qt/gtk.c
         src/detection/host/host_bsd.c
+        src/detection/lm/lm_linux.c
+        src/detection/icons/icons_linux.c
+        src/detection/libc/libc_bsd.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/netio/netio_bsd.c
         src/detection/opengl/opengl_linux.c
         src/detection/os/os_linux.c
         src/detection/packages/packages_linux.c
         src/detection/poweradapter/poweradapter_nosupport.c
         src/detection/processes/processes_bsd.c
-        src/detection/qt.c
+        src/detection/gtk_qt/qt.c
+        src/detection/sound/sound_linux.c
         src/detection/swap/swap_bsd.c
-        src/detection/temps/temps_linux.c
+        src/detection/temps/temps_bsd.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_bsd.c
         src/detection/users/users_linux.c
-        src/detection/wifi/wifi_nosupport.c
+        src/detection/wallpaper/wallpaper_linux.c
+        src/detection/wifi/wifi_bsd.c
+        src/detection/wm/wm_nosupport.c
+        src/detection/de/de_linux.c
         src/detection/wmtheme/wmtheme_linux.c
         src/util/platform/FFPlatform_unix.c
     )
 elseif(APPLE)
     list(APPEND LIBFASTFETCH_SRC
+        src/common/io/io_unix.c
+        src/common/netif/netif_bsd.c
         src/common/networking_linux.c
         src/common/processing_linux.c
         src/common/sysctl.c
         src/detection/battery/battery_apple.c
         src/detection/bios/bios_apple.c
+        src/detection/bluetooth/bluetooth_apple.m
         src/detection/board/board_nosupport.c
         src/detection/brightness/brightness_apple.c
         src/detection/chassis/chassis_nosupport.c
         src/detection/cpu/cpu_apple.c
-        src/detection/cpuUsage/cpuUsage_apple.c
-        src/detection/cursor/cursor_nosupport.c
-        src/detection/disk/disk_apple.m
+        src/detection/cpuusage/cpuusage_apple.c
+        src/detection/cursor/cursor_apple.m
         src/detection/disk/disk_bsd.c
+        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/host/host_apple.c
+        src/detection/lm/lm_nosupport.c
+        src/detection/icons/icons_nosupport.c
+        src/detection/libc/libc_apple.c
         src/detection/localip/localip_linux.c
+        src/detection/gamepad/gamepad_apple.c
         src/detection/media/media_apple.m
         src/detection/memory/memory_apple.c
+        src/detection/monitor/monitor_apple.m
+        src/detection/netio/netio_bsd.c
         src/detection/opengl/opengl_apple.c
         src/detection/os/os_apple.m
         src/detection/packages/packages_apple.c
         src/detection/poweradapter/poweradapter_apple.c
         src/detection/processes/processes_bsd.c
+        src/detection/sound/sound_apple.c
         src/detection/swap/swap_apple.c
         src/detection/temps/temps_apple.c
         src/detection/terminalfont/terminalfont_apple.m
         src/detection/terminalshell/terminalshell_linux.c
+        src/detection/terminalsize/terminalsize_linux.c
+        src/detection/theme/theme_nosupport.c
         src/detection/uptime/uptime_bsd.c
         src/detection/users/users_linux.c
+        src/detection/wallpaper/wallpaper_apple.c
         src/detection/wifi/wifi_apple.m
+        src/detection/wm/wm_apple.c
+        src/detection/de/de_nosupport.c
         src/detection/wmtheme/wmtheme_apple.m
         src/util/apple/cf_helpers.c
         src/util/apple/osascript.m
@@ -465,37 +592,56 @@ elseif(APPLE)
     )
 elseif(WIN32)
     list(APPEND LIBFASTFETCH_SRC
+        src/common/io/io_windows.c
+        src/common/netif/netif_windows.c
         src/common/networking_windows.c
         src/common/processing_windows.c
         src/detection/battery/battery_windows.c
         src/detection/bios/bios_windows.c
+        src/detection/bluetooth/bluetooth_windows.c
         src/detection/board/board_windows.c
         src/detection/brightness/brightness_windows.cpp
-        src/detection/chassis/chassis_nosupport.c
+        src/detection/chassis/chassis_windows.cpp
         src/detection/cpu/cpu_windows.c
-        src/detection/cpuUsage/cpuUsage_windows.c
+        src/detection/cpuusage/cpuusage_windows.c
         src/detection/cursor/cursor_windows.c
         src/detection/disk/disk_windows.c
+        src/detection/diskio/diskio_windows.c
         src/detection/displayserver/displayserver_windows.c
         src/detection/font/font_windows.c
-        src/detection/gpu/gpu_windows.cpp
+        src/detection/gpu/gpu_windows.c
+        src/detection/gpu/gpu_nvidia.c
         src/detection/host/host_windows.c
+        src/detection/icons/icons_windows.c
+        src/detection/libc/libc_windows.cpp
+        src/detection/lm/lm_nosupport.c
         src/detection/localip/localip_windows.c
+        src/detection/gamepad/gamepad_windows.c
         src/detection/media/media_nosupport.c
         src/detection/memory/memory_windows.c
+        src/detection/monitor/monitor_windows.c
+        src/detection/netio/netio_windows.c
         src/detection/opengl/opengl_windows.c
         src/detection/os/os_windows.cpp
         src/detection/packages/packages_windows.c
         src/detection/poweradapter/poweradapter_nosupport.c
-        src/detection/processes/processes_windows.cpp
-        src/detection/swap/swap_windows.cpp
+        src/detection/processes/processes_windows.c
+        src/detection/sound/sound_windows.cpp
+        src/detection/swap/swap_windows.c
         src/detection/terminalfont/terminalfont_windows.c
-        src/detection/terminalshell/terminalshell_windows.cpp
+        src/detection/terminalshell/terminalshell_windows.c
+        src/detection/terminalsize/terminalsize_windows.c
+        src/detection/temps/temps_windows.cpp
+        src/detection/theme/theme_nosupport.c
         src/detection/uptime/uptime_windows.c
         src/detection/users/users_windows.c
+        src/detection/wallpaper/wallpaper_windows.c
         src/detection/wifi/wifi_windows.c
+        src/detection/wm/wm_windows.cpp
+        src/detection/de/de_nosupport.c
         src/detection/wmtheme/wmtheme_windows.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
@@ -503,15 +649,70 @@ elseif(WIN32)
     )
 endif()
 
+if(ENABLE_DIRECTX_HEADERS)
+    message(STATUS "Enabling DirectX headers for WSL")
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_wsl.cpp)
+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(ENABLE_SYSTEM_YYJSON)
+    find_package(yyjson)
+    if(yyjson_FOUND)
+        message(STATUS "System provided yyjson is used")
+    else()
+        message(FATAL_ERROR "ENABLE_SYSTEM_YYJSON is set but system provided yyjson is not found")
+    endif()
+else()
+    list(APPEND LIBFASTFETCH_SRC
+        src/3rdparty/yyjson/yyjson.c
+    )
+endif()
+
 add_library(libfastfetch OBJECT
     ${LIBFASTFETCH_SRC}
 )
 
-target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE)
+if(yyjson_FOUND)
+    target_compile_definitions(libfastfetch PRIVATE FF_USE_SYSTEM_YYJSON)
+    target_link_libraries(libfastfetch PRIVATE yyjson)
+endif()
 
-CHECK_INCLUDE_FILE("utmpx.h" HAVE_UTMPX_H)
-if(HAVE_UTMPX_H)
-    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_UTMPX_H)
+if(LINUX AND EXISTS "/lib/ld-musl-${CMAKE_HOST_SYSTEM_PROCESSOR}.so.1")
+    execute_process(COMMAND "/lib/ld-musl-${CMAKE_HOST_SYSTEM_PROCESSOR}.so.1"
+                    ERROR_VARIABLE LD_MUSL_RESULT)
+    if("${LD_MUSL_RESULT}" MATCHES "Version ([0-9]+\\.[0-9]+\\.[0-9]+)")
+        target_compile_definitions(libfastfetch PUBLIC FF_MUSL_VERSION="${CMAKE_MATCH_1}")
+    endif()
+endif()
+if(APPLE AND EXISTS "/usr/bin/otool")
+    execute_process(COMMAND /usr/bin/otool -L /usr/bin/otool
+                    OUTPUT_VARIABLE OTOOL_OTOOL_RESULT)
+    if("${OTOOL_OTOOL_RESULT}" MATCHES "libSystem\\.B\\.dylib \\(.*current version ([0-9]+\\.[0-9]+\\.[0-9]+)\\)")
+        target_compile_definitions(libfastfetch PUBLIC FF_LIBSYSTEM_VERSION="${CMAKE_MATCH_1}")
+    endif()
+endif()
+if(BSD 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]+)")
+        target_compile_definitions(libfastfetch PUBLIC FF_FBSD_VERSION="${CMAKE_MATCH_1}")
+    endif()
+endif()
+
+target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE _XOPEN_SOURCE __STDC_WANT_LIB_EXT1__=1)
+if(WIN32)
+    target_compile_definitions(libfastfetch PUBLIC WIN32_LEAN_AND_MEAN=1)
+elseif(APPLE)
+    target_compile_definitions(libfastfetch PUBLIC _DARWIN_C_SOURCE)
+endif()
+
+if(HAVE_WCWIDTH)
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WCWIDTH)
 endif()
 
 function(ff_lib_enable VARNAME PKGCONFIG_NAMES CMAKE_NAME)
@@ -634,10 +835,6 @@ ff_lib_enable(OPENCL
     "OpenCL"
     "OpenCL"
 )
-ff_lib_enable(LIBCJSON
-    "libcjson"
-    "CJson"
-)
 ff_lib_enable(LIBNM
     "libnm"
     "libnm"
@@ -646,6 +843,18 @@ ff_lib_enable(FREETYPE
     "freetype2"
     "FreeType2"
 )
+ff_lib_enable(PULSE
+    "libpulse"
+    "Pulse"
+)
+ff_lib_enable(DDCUTIL
+    "ddcutil"
+    "Ddcutil"
+)
+ff_lib_enable(DIRECTX_HEADERS
+    "DirectX-Headers"
+    "DirectX-Headers"
+)
 
 if(ENABLE_THREADS)
     target_compile_definitions(libfastfetch PRIVATE FF_HAVE_THREADS)
@@ -654,45 +863,70 @@ if(ENABLE_THREADS)
     endif()
 endif()
 
-if(ENABLE_BUFFER)
-    target_compile_definitions(libfastfetch PRIVATE FF_ENABLE_BUFFER)
+if(ENABLE_PCI_MEMORY)
+    target_compile_definitions(libfastfetch PRIVATE FF_USE_PCI_MEMORY)
 endif()
 
-if(APPLE)
+if(LINUX)
     target_link_libraries(libfastfetch
+        PRIVATE "m"
+    )
+elseif(APPLE)
+    target_link_libraries(libfastfetch
+        PRIVATE "-framework Cocoa"
         PRIVATE "-framework CoreFoundation"
+        PRIVATE "-framework CoreAudio"
+        PRIVATE "-framework CoreVideo"
+        PRIVATE "-framework CoreWLAN"
+        PRIVATE "-framework IOBluetooth"
         PRIVATE "-framework IOKit"
         PRIVATE "-framework OpenGL"
         PRIVATE "-framework OpenCL"
-        PRIVATE "-framework Cocoa"
-        PRIVATE "-framework CoreWLAN"
-        PRIVATE "-framework CoreVideo"
-        PRIVATE "-weak_framework MediaRemote -F /System/Library/PrivateFrameworks"
-        PRIVATE "-weak_framework DisplayServices -F /System/Library/PrivateFrameworks"
+        PRIVATE "-framework SystemConfiguration"
+        PRIVATE "-weak_framework CoreDisplay"
+
+        PRIVATE "-F /System/Library/PrivateFrameworks"
+        PRIVATE "-weak_framework DisplayServices"
+        PRIVATE "-weak_framework MediaRemote"
+        PRIVATE "-weak_framework Apple80211"
     )
 elseif(WIN32)
     target_compile_definitions(libfastfetch PRIVATE -D_WIN32_WINNT=0x0601)
     target_link_libraries(libfastfetch
+        PRIVATE "bthprops"
         PRIVATE "dwmapi"
         PRIVATE "gdi32"
         PRIVATE "iphlpapi"
         PRIVATE "ole32"
         PRIVATE "oleaut32"
         PRIVATE "opengl32"
-        PRIVATE "wbemuuid"
         PRIVATE "ws2_32"
         PRIVATE "ntdll"
         PRIVATE "version"
         PRIVATE "setupapi"
-        PRIVATE "dxgi"
+        PRIVATE "hid"
         PRIVATE "wtsapi32"
-        PRIVATE "powrprof"
+        PRIVATE "dxva2"
     )
-    if(USE_WIN_NTAPI)
-        target_compile_definitions(libfastfetch PRIVATE FF_USE_WIN_NTAPI)
-    endif()
-    if(USE_WIN_GPU_DXGI)
-        target_compile_definitions(libfastfetch PRIVATE FF_USE_WIN_GPU_DXGI)
+elseif(BSD)
+    target_link_libraries(libfastfetch
+        PRIVATE "m"
+        PRIVATE "usbhid"
+        PRIVATE "devstat"
+    )
+elseif(ANDROID)
+    CHECK_LIBRARY_EXISTS(-l:libandroid-wordexp.a wordexp "" HAVE_LIBANDROID_WORDEXP_STATIC)
+    if(HAVE_LIBANDROID_WORDEXP_STATIC)
+        target_link_libraries(libfastfetch
+            PRIVATE -l:libandroid-wordexp.a
+        )
+    else()
+        CHECK_LIBRARY_EXISTS(android-wordexp wordexp "" HAVE_LIBANDROID_WORDEXP)
+        if(HAVE_LIBANDROID_WORDEXP)
+            target_link_libraries(libfastfetch
+                PRIVATE android-wordexp
+            )
+        endif()
     endif()
 endif()
 
@@ -729,10 +963,11 @@ target_link_libraries(flashfetch
     PRIVATE libfastfetch
 )
 
-if(ENABLE_BUFFER) # FF_ENABLE_BUFFER is used in fastfetch.c
-    target_compile_definitions(fastfetch PRIVATE FF_ENABLE_BUFFER)
-    target_compile_definitions(flashfetch PRIVATE FF_ENABLE_BUFFER)
-endif()
+# Prevent fastfetch from linking to libstdc++
+set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")
+set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "")
+set_target_properties(fastfetch PROPERTIES LINKER_LANGUAGE C)
+set_target_properties(flashfetch PROPERTIES LINKER_LANGUAGE C)
 
 if(WIN32)
     set(TARGET_NAME fastfetch)
@@ -744,6 +979,13 @@ if(WIN32)
     target_sources(flashfetch
         PRIVATE src/util/windows/version.rc
     )
+elseif(APPLE)
+    target_link_options(fastfetch
+        PRIVATE LINKER:-sectcreate,__TEXT,__info_plist,Info.plist
+    )
+    target_link_options(flashfetch
+        PRIVATE LINKER:-sectcreate,__TEXT,__info_plist,Info.plist
+    )
 endif()
 
 ###################
@@ -781,12 +1023,6 @@ install(
     DESTINATION "${CMAKE_INSTALL_BINDIR}"
 )
 
-install(
-    FILES "${CMAKE_SOURCE_DIR}/src/data/config_system.txt"
-    DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/${CMAKE_PROJECT_NAME}"
-    RENAME "config.conf"
-)
-
 install(
     FILES "${CMAKE_SOURCE_DIR}/completions/bash"
     DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions"

README.md

@@ -1,5 +1,16 @@
 # Fastfetch
 
+![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/fastfetch-cli/fastfetch/ci.yml)
+![GitHub license](https://img.shields.io/github/license/fastfetch-cli/fastfetch)
+![GitHub contributors](https://img.shields.io/github/contributors/fastfetch-cli/fastfetch)
+![GitHub top language](https://img.shields.io/github/languages/top/fastfetch-cli/fastfetch?logo=c&label=)
+![GitHub commit activity (branch)](https://img.shields.io/github/commit-activity/m/fastfetch-cli/fastfetch)  
+![homebrew downloads](https://img.shields.io/homebrew/installs/dm/fastfetch?logo=homebrew)
+![GitHub all releases](https://img.shields.io/github/downloads/fastfetch-cli/fastfetch/total?logo=github)  
+![GitHub release (with filter)](https://img.shields.io/github/v/release/fastfetch-cli/fastfetch?logo=github)
+[![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.
 
 <img src="screenshots/example1.png" width="49%" align="left" />
@@ -10,136 +21,55 @@ 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/LinusDierheimer/fastfetch/wiki)
+There are [screenshots on different platforms](https://github.com/fastfetch-cli/fastfetch/wiki)
 
-## Customization
+## Installation
 
-With customization and speed being two competing goals, this project actually builds two executables.
+### Linux
 
-* The main one being `fastfetch`, which can be very greatly configured via flags. These flags can be made persistent in `$XDG_CONFIG_HOME/fastfetch/config.conf`. To view the available options run `fastfetch --help`.
-* The second executable being built is called `flashfetch`, which is configured at compile time to eliminate any possible overhead. Configuration of it can be very easily done in [`src/flashfetch.c`](src/flashfetch.c).
+* Debian / Ubuntu: Download `fastfetch-<version>-Linux.deb` from [Github release page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and `sudo apt install fastfetch-<version>-Linux.deb`
+* Arch Linux: `sudo pacman -S fastfetch`
+* Fedora: `sudo dnf install fastfetch`
+* Gentoo: `sudo emerge --ask app-misc/fastfetch`
 
-At the moment the performance difference is measurable, but too small to be human recognizable. But the leap will get bigger with more and more options coming, and on slow machines this might actually make a difference.
-
-There are some premade config files in [`presets`](presets), including the ones used for the screenshots above. You can load them using `--load-config <filename>`. They may also serve as a good example for format arguments.
-
-Logos can be heavily customized to. See the [logo documentation](doc/logo.md) for more information.
-
-## Dependencies
-
-Fastfetch dynamically loads needed libraries if they are available. On Linux, its only hard dependencies are `libc` (any implementation of the c standard library), `libdl` and [`libpthread`](https://man7.org/linux/man-pages/man7/pthreads.7.html) (if built with multithreading support). They are all shipped with [`glibc`](https://www.gnu.org/software/libc/), which is already installed on most linux distributions.
-
-The following libraries are used if present at runtime:
-
-### Linux and FreeBSD
-
-* [`libpci`](https://github.com/pciutils/pciutils): GPU output.
-* [`libvulkan`](https://www.vulkan.org/): Vulkan module & fallback for GPU output.
-* [`libxcb-randr`](https://xcb.freedesktop.org/),
-    [`libXrandr`](https://gitlab.freedesktop.org/xorg/lib/libxrandr),
-    [`libxcb`](https://xcb.freedesktop.org/),
-    [`libX11`](https://gitlab.freedesktop.org/xorg/lib/libx11): At least one of them sould be present in X11 sessions for better display detection and faster WM detection. The `*randr` ones provide multi monitor support The `libxcb*` ones usually have better performance.
-* [`libwayland-client`](https://wayland.freedesktop.org/): Better display performance and output in wayland sessions. Supports different refresh rates per monitor.
-* [`libGIO`](https://developer.gnome.org/gio/unstable/): Needed for values that are only stored GSettings.
-* [`libDConf`](https://developer.gnome.org/dconf/unstable/): Needed for values that are only stored in DConf + Fallback for GSettings.
-* [`libmagickcore` (ImageMagick)](https://www.imagemagick.org/): Images in terminal using sixel or kitty graphics protocol.
-* [`libchafa`](https://github.com/hpjansson/chafa): Image output as ascii art.
-* [`libZ`](https://www.zlib.net/): Faster image output when using kitty graphics protocol.
-* [`libDBus`](https://www.freedesktop.org/wiki/Software/dbus): Needed for detecting current media player and song.
-* [`libEGL`](https://www.khronos.org/registry/EGL/),
-    [`libGLX`](https://dri.freedesktop.org/wiki/GLX/),
-    [`libOSMesa`](https://docs.mesa3d.org/osmesa.html): At least one of them is needed by the OpenGL module for gl context creation.
-* [`libOpenCL`](https://www.khronos.org/opencl/): OpenCL module
-* [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
-* [`libsqlite3`](https://www.sqlite.org/index.html): Needed for pkg & rpm package count.
-* [`librpm`](http://rpm.org/): Slower fallback for rpm package count. Needed on openSUSE.
-* [`libcJSON`](https://github.com/DaveGamble/cJSON): Needed for Windows Terminal font ( WSL ).
-* [`libnm`](https://networkmanager.dev/docs/libnm/latest/): Used for Wifi detection on Linux.
+[See also if fastfetch has been packaged for your favorite Linux distro](#Packaging)
 
 ### macOS
 
-* [`MediaRemote`](https://iphonedev.wiki/index.php/MediaRemote.framework): Need for Media detection. It's a private framework provided by newer macOS system.
-* [`DisplayServices`](https://developer.apple.com/forums/thread/666383#663154022): Need for screen brightness detection. It's a private framework provided by newer macOS system.
-* [`MoltenVK`](https://github.com/KhronosGroup/MoltenVK): Vulkan driver for macOS. [`molten-vk`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/molten-vk.rb)
-* [`libmagickcore` (ImageMagick)](https://www.imagemagick.org/): Images in terminal using sixel graphics protocol. [`imagemagick`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/imagemagick.rb)
-* [`libchafa`](https://github.com/hpjansson/chafa): Image output as ascii art. [`chafa`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/chafa.rb)
-
-For the image logo, iTerm with iterm image protocol should work. Apple Terminal is not supported.
+`brew install fastfetch`
 
 ### Windows
 
-* [`wlanapi`](https://learn.microsoft.com/en-us/windows/win32/api/wlanapi/): A system dll which isn't supported by Windows Server by default. Used for Wifi info detection.
-* [`libcJSON`](https://github.com/DaveGamble/cJSON): Used for Windows Terminal font detection. [`cjson`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-cjson)
-* [`libvulkan`](https://www.vulkan.org/): Vulkan module. Usually has been provided by GPU drivers. [`vulkan-loader`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-vulkan-loader) [`vulkan-headers`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-vulkan-headers)
-* [`libOpenCL`](https://www.khronos.org/opencl/): OpenCL module. [`opencl-icd`](https://github.com/msys2/MINGW-packages/tree/master/mingw-w64-opencl-icd)
+`scoop install fastfetch`
 
-Note: In Windows 7, 8 and 8.1, [ConEmu](https://conemu.github.io/en/AnsiEscapeCodes.html) is required to run fastfetch due to [the lack of ASCII escape code native support](https://en.wikipedia.org/wiki/ANSI_escape_code#DOS,_OS/2,_and_Windows). In addition, as fastfetch for Windows targets [UCRT](https://learn.microsoft.com/en-us/cpp/windows/universal-crt-deployment) C runtime library, [it must be installed manually](https://support.microsoft.com/en-us/topic/update-for-universal-c-runtime-in-windows-c0514201-7fe6-95a3-b0a5-287930f3560c) as UCRT is only pre-installed in Windows 10 and later.
+You may also download it directly from [GitHub releases page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and extract the archive.
 
-For the image logo, only chafa is supported due to [the design flaw of ConPTY](https://github.com/microsoft/terminal/issues/1173). In addition, chafa support is not built by default due to the massive dependencies of imagemagick. You must built it yourself.
+### FreeBSD
 
-### Android
+`pkg install fastfetch`
 
-* [`freetype`](https://www.freetype.org/): Used for Termux font detection. [`freetype`](https://github.com/termux/termux-packages/tree/master/packages/freetype)
-* [`libvulkan`](https://www.vulkan.org/): Vulkan module, also used for GPU detection. Usually has been provided by Android system. [`vulkan-loader-android`](https://github.com/termux/termux-packages/tree/master/packages/vulkan-loader-android) [`vulkan-headers`](https://github.com/termux/termux-packages/tree/master/packages/vulkan-headers)
-* [`termux-api`](https://github.com/termux/termux-api-package): Used for Wifi / Battery detection. Read [the official doc](https://wiki.termux.com/wiki/Termux:API) for detail or if you hang on these modules (IMPORTANT). [`termux-api`](https://github.com/termux/termux-packages/tree/master/packages/termux-api)
+### Android (Termux)
 
-## Support status
-All categories not listed here should work without needing a specific implementation.
+`pkg install fastfetch`
 
-##### Available Modules
-```
-Battery, Bios, Board, Break, Brightness, Colors, Command, CPU, CPUUsage, Cursor, Custom, Date, DateTime, DE, Disk, Display, Font, GPU, Host, Icons, Kernel, Locale, LocalIP, Media, Memory, OpenCL, OpenGL, Packages, Player, Power Adapter, Processes, PublicIP, Separator OS, Shell, Swap, Terminal, Terminal Font, Theme, Time, Title, Uptime, Vulkan, Wifi, WM, WMTheme
-```
+## Build from source
 
-##### Builtin logos
-```
-AlmaLinux, Alpine, Android, Arch, Arco, Artix, Bedrock, CachyOS, CentOS, CRUX, Crystal, Debian, Deepin, Devuan, Endeavour, Enso, Fedora, FreeBSD, Garuda, Gentoo, KDE Neon, KISS, Kubuntu, LangitKetujuh, Linux, MacOS, Manjaro, Mint, MSYS2, NixOS, Nobara, OpenSUSE, OpenSUSE LEAP, OpenSUSE Tumbleweed, Parabola, Pop!_OS, Raspbian, RebornOS, RedstarOS, Rocky, Rosa, Slackware, Solus, Ubuntu, Vanilla, Void, Windows, Windows 11, Windows 8, Zorin
-```
+See Wiki: https://github.com/fastfetch-cli/fastfetch/wiki/Building
 
-##### Package managers
-```
-apk, brew, Chocolatey, dpkg, emerge, eopkg, Flatpak, MacPorts, nix, Pacman, pkg, rpm, scoop, Snap, xbps
-```
+## Usage
 
-##### WM themes
-```
-DWM (Windows), KWin, Marco, Muffin, Mutter, Openbox (LXDE, LXQT & without DE), Quartz Compositor (macOS), XFWM
-```
+* Run it with default configuration: `fastfetch`
+* Run it with [all supported modules](https://github.com/fastfetch-cli/fastfetch/wiki/Support+Status#available-modules) and find what you interest: `fastfetch -c all.jsonc`
+* Find all data that fastfetch detects: `fastfetch -s <module> --format json`
+* Display help messages: `fastfetch --help`
+* Generate config file based on command line arguments: `fastfetch --arg1 --arg2 --migrate-config`
 
-##### DE versions
-```
-Budgie, Cinnamon, Gnome, KDE Plasma, LXQt, Mate, XFCE4
-```
+## Customization
 
-##### Terminal fonts
-```
-Alacritty, Apple Terminal, ConEmu, Deepin Terminal, Gnome Terminal, iTerm2, Kitty, Konsole, LXTerminal, mintty, Termux, Tilix, TTY, Warp, WezTerm, Windows Terminal, XFCE4 Terminal
-```
+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.
 
-## Building
+Logos can be heavily customized too; see the [logo documentation](https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options) for more information.
 
-fastfetch uses [`cmake`](https://cmake.org/) for building. [`pkg-config`](https://www.freedesktop.org/wiki/Software/pkg-config/) is recommended for better library detection. The simplest steps to build the fastfetch and flashfetch binaries are:
-```bash
-mkdir -p build
-cd build
-cmake ..
-cmake --build . --target fastfetch --target flashfetch
-```
-
-If the build process fails to find the headers for a library listed in [dependencies](#dependencies), fastfetch will simply build without support for that specific feature. This means, it won't look for it at runtime and just act like it isn't available.
-
-### Building on Windows
-
-Currently GCC or clang is required (MSVC is not supported). MSYS2 with CLANG64 subsystem (or CLANGARM64 if needed) is suggested (and tested) to build fastfetch. If you need Windows 7 / 8.x support, using MINGW64 is suggested.
-
-1. Install [MSYS2](https://www.msys2.org/#installation)
-1. Open `MSYS2 / CLANG64` (not `MSYS2 / MSYS`, which targets cygwin C runtime)
-1. Install dependencies
-```bash
-pacman -Syu mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-pkgconf mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-cjson mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-opencl-icd
-```
-
-Follow the building instructions of Linux next.
 
 ## Packaging
 

completions/bash

@@ -16,15 +16,15 @@ __fastfetch_complete_help()
         "display-format"
         "de-format"
         "wm-format"
-        "wm-theme-format"
+        "wmtheme-format"
         "theme-format"
         "icons-format"
         "font-format"
         "cursor-format"
         "terminal-format"
-        "terminal-font-format"
+        "terminalfont-format"
         "cpu-format"
-        "cpu-usage-format"
+        "cpuusage-format"
         "gpu-format"
         "memory-format"
         "swap-format"
@@ -32,8 +32,8 @@ __fastfetch_complete_help()
         "battery-format"
         "poweradapter-format"
         "locale-format"
-        "local-ip-format"
-        "public-ip-format"
+        "localip-format"
+        "publicip-format"
         "player-format"
         "media-format"
         "datetime-format"
@@ -42,6 +42,7 @@ __fastfetch_complete_help()
         "vulkan-format"
         "opengl-format"
         "opencl-format"
+        "bluetooth-format"
     )
     COMPREPLY=($(compgen -W "${__ff_helps[*]}" -- "$CURRENT_WORD"))
 }
@@ -112,7 +113,7 @@ __fastfetch_complete_option()
         "${FF_OPTIONS_LOGO[@]}"
         "${FF_OPTIONS_LOGO_TYPE[@]}"
         "${FF_OPTIONS_BINARY_PREFIX[@]}"
-        "${FF_OPTIONS_GL[@]}"
+        "${FF_OPTIONS_OPENGL[@]}"
     )
 
     if [[ $WORD_COUND -lt 3 ]]; then
@@ -181,23 +182,26 @@ __fastfetch_completion()
         "--cpu-temp"
         "--gpu-temp"
         "--battery-temp"
+        "--display-detect-name"
+        "--display-precise-refresh-rate"
         "--localip-show-ipv4"
         "--localip-show-ipv6"
         "--localip-show-loop"
         "--localip-name-prefix"
+        "--localip-compact-type"
         "--escape-bedrock"
         "--pipe"
         "--title-fqdn"
         "--escape-bedrock"
-        "--shell-version"
-        "--terminal-version"
         "--disk-folders"
-        "--disk-show-removable"
+        "--disk-show-external"
         "--disk-show-hidden"
         "--disk-show-subvolumes"
         "--gpu-hide-integrated"
         "--gpu-hide-discrete"
+        "--gpu-force-vulkan"
         "--disk-show-unknown"
+        "--bluetooth-show-disconnected"
     )
 
     local FF_OPTIONS_STRING=(
@@ -221,6 +225,7 @@ __fastfetch_completion()
         "--color"
         "--color-keys"
         "--color-title"
+        "--display-compact-type"
         "--separator"
         "-s"
         "--structure"
@@ -228,127 +233,130 @@ __fastfetch_completion()
         "--set-keyless"
         "--player-name"
         "--percent-type"
-        "--public-ip-url"
-        "--public-ip-timeout"
+        "--publicip-url"
+        "--publicip-timeout"
         "--weather-output-format"
         "--weather-timeout"
         "--os-key"
         "--os-format"
-        "--os-error"
+        "--os-key-color"
         "--host-key"
         "--host-format"
-        "--host-error"
+        "--host-key-color"
         "--kernel-key"
         "--kernel-format"
-        "--kernel-error"
+        "--kernel-key-color"
         "--uptime-key"
         "--uptime-format"
-        "--uptime-error"
+        "--uptime-key-color"
         "--processes-key"
         "--processes-format"
-        "--processes-error"
+        "--processes-key-color"
         "--packages-key"
         "--packages-format"
-        "--packages-error"
+        "--packages-key-color"
         "--shell-key"
         "--shell-format"
-        "--shell-error"
+        "--shell-key-color"
         "--display-key"
         "--display-format"
-        "--display-error"
+        "--display-key-color"
         "--de-key"
         "--de-format"
-        "--de-error"
+        "--de-key-color"
         "--wm-key"
         "--wm-format"
-        "--wm-error"
-        "--wm-theme-key"
-        "--wm-theme-format"
-        "--wm-theme-error"
+        "--wm-key-color"
+        "--wmtheme-key"
+        "--wmtheme-format"
+        "--wmtheme-key-color"
         "--theme-key"
         "--theme-format"
-        "--theme-error"
+        "--theme-key-color"
         "--icons-key"
         "--icons-format"
-        "--icons-error"
+        "--icons-key-color"
         "--font-key"
         "--font-format"
-        "--font-error"
+        "--font-key-color"
         "--cursor-key"
         "--cursor-format"
-        "--cursor-error"
+        "--cursor-key-color"
         "--terminal-key"
         "--terminal-format"
-        "--terminal-error"
-        "--terminal-font-key"
-        "--terminal-font-format"
-        "--terminal-font-error"
+        "--terminal-key-color"
+        "--terminalfont-key"
+        "--terminalfont-format"
+        "--terminalfont-key-color"
         "--cpu-key"
         "--cpu-format"
-        "--cpu-error"
+        "--cpu-key-color"
         "--cpu-useage-key"
         "--cpu-useage-format"
-        "--cpu-useage-error"
+        "--cpu-useage-key-color"
         "--gpu-key"
         "--gpu-format"
-        "--gpu-error"
+        "--gpu-key-color"
         "--memory-key"
         "--memory-format"
-        "--memory-error"
+        "--memory-key-color"
         "--swap-key"
         "--swap-format"
-        "--swap-error"
+        "--swap-key-color"
         "--disk-key"
         "--disk-format"
-        "--disk-error"
+        "--disk-key-color"
         "--battery-key"
         "--battery-format"
-        "--battery-error"
+        "--battery-key-color"
         "--poweradapter-key"
         "--poweradapter-format"
-        "--poweradapter-error"
+        "--poweradapter-key-color"
         "--locale-key"
         "--locale-format"
-        "--locale-error"
-        "--local-ip-key"
-        "--local-ip-format"
-        "--local-ip-error"
-        "--public-ip-key"
-        "--public-ip-format"
-        "--public-ip-error"
+        "--locale-key-color"
+        "--localip-key"
+        "--localip-format"
+        "--localip-key-color"
+        "--publicip-key"
+        "--publicip-format"
+        "--publicip-key-color"
         "--wifi-key"
         "--wifi-format"
-        "--wifi-error"
+        "--wifi-key-color"
         "--weather-key"
         "--weather-format"
-        "--weather-error"
+        "--weather-key-color"
         "--player-key"
         "--player-format"
-        "--player-error"
+        "--player-key-color"
         "--media-key"
         "--media-format"
-        "--media-error"
+        "--media-key-color"
         "--datetime-key"
         "--datetime-format"
-        "--datetime-error"
+        "--datetime-key-color"
         "--date-key"
         "--date-format"
-        "--date-error"
+        "--date-key-color"
         "--time-key"
         "--time-format"
-        "--time-error"
+        "--time-key-color"
         "--vulkan-key"
         "--vulkan-format"
-        "--vulkan-error"
+        "--vulkan-key-color"
         "--opengl-key"
         "--opengl-format"
-        "--opengl-error"
+        "--opengl-key-color"
         "--opencl-key"
         "--opencl-format"
-        "--opencl-error"
+        "--opencl-key-color"
         "--users-key"
         "--users-format"
-        "--users-error"
+        "--users-key-color"
+        "--bluetooth-key"
+        "--bluetooth-format"
+        "--bluetooth-key-color"
     )
 
     local FF_OPTIONS_PATH=(
@@ -374,6 +382,9 @@ __fastfetch_completion()
         "--lib-glx"
         "--lib-osmesa"
         "--lib-opencl"
+        "--lib-pulse"
+        "--lib-ddcutil"
+        "--lib-nm"
         "--battery-dir"
     )
 
@@ -390,8 +401,8 @@ __fastfetch_completion()
         "--binary-prefix"
     )
 
-    local FF_OPTIONS_GL=(
-        "--gl"
+    local FF_OPTIONS_OPENGL=(
+        "--opengl-type"
     )
 
     if __fastfetch_previous_matches "${FF_OPTIONS_SINGLE[@]}"; then
@@ -414,7 +425,7 @@ __fastfetch_completion()
         __fastfetch_complete_logo_type
     elif __fastfetch_previous_matches "${FF_OPTIONS_BINARY_PREFIX[@]}"; then
         __fastfetch_complete_binary_prefix
-    elif __fastfetch_previous_matches "${FF_OPTIONS_GL[@]}"; then
+    elif __fastfetch_previous_matches "${FF_OPTIONS_OPENGL[@]}"; then
         __fastfetch_complete_gl
     else
         __fastfetch_complete_option

doc/logo.md

@@ -1,116 +0,0 @@
-# Logo options
-
-## General
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--logo`, `-l` | `""` | The logo source, interpreted depending on type |
-| `--logo-type` | `auto` | The logo type. See the following categories for possible values |
-| `--<type>` | `""` | Short for `--logo-type <type> --logo <value>` |
-| `--logo-padding` | `""` | Sets the padding left and right of the logo |
-| `--logo-padding-left` | `0` | Sets the padding left of the logo |
-| `--logo-padding-right` | `4` | Sets the padding right of the logo |
-| `--logo-padding-top` | `0` | Sets the padding top of the logo |
-
-All filesytem paths can be:
-* Absolute
-* Relative to the current working directory
-* Relative to any of the directories listed by `fastfetch --list-data-paths` + `/logos`  
-  For example, the file `~/.local/share/fastfetch/logos/shrek` can simply be referenced as `shrek`.
-
-## Text
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--logo-color-[1-9]` | `""` | Overrides a color for logos that support it |
-| `--logo-print-remaining` | `true` | Print the remaining logo, if it is higher than the keys |
-
-* Color placeholders are in the form `$[1-9]`. To print a `$`, use `$$`. 
-* If a color placeholder value is not set, the placeholder is simply discarded.
-
-## Image
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--logo-width` | `""` | Sets the width of the logo for logos that support it |
-| `--logo-height` | `""` | Sets the height of the logo for logos that support it |
-
-* If one of the height / width options is set, but the other not, the aspect ratio is preserved.
-* If neither height nor width is set, the original size is used.
-
-# Logo types
-
-## auto
-
-Trys to detect the logo type depending on the value of `--logo`, in the following order:
-* If the value is empty / not set, an autodected builtin logo is displayed.
-* If the value is the name of a builtin logo, it is displayed.
-* If the value is the path to an image file, and the terminal emulator is known to support an image protocol, the image is displayed.
-* If the value is the path to a text file, the content is displayed.
-* The autodetected builtin logo is displayed.
-
-## builtin
-
-The value of `--logo` is interpreted as the name of a builtin logo.
-* If the value is empty / not set, it is autodetected.
-* Use `--list-logos` to get a list of all available logos.
-* Use `--print-logos` to see all available logos.
-* All builtin logos set default values for `--logo-color-[1-9]`.
-* Use `none` to disable the logo, but keep key colors from the detected logo.
-
-## file
-
-The value of `--logo` is interpreted as the path to a file. The content of the file is displayed.
-* If the file can't be read, the autodetected builtin logo is displayed.
-
-## file-raw
-
-The value of `--logo` is interpreted as the path to a file. The content of the file is displayed.
-* No color placeholder replacement is done.
-* If the file can't be read, the autodetected builtin logo is displayed.
-
-## data
-
-The value of `--logo` is interpreted as the logo and directly displayed.
-* If the value is empty / not set, the autodetected builtin logo is displayed.
-
-## data-raw
-
-The value of `--logo` is interpreted as the logo and directly displayed.
-* No color placeholder replacement is done.
-* If the value is empty / not set, the autodetected builtin logo is displayed.
-
-## sixel
-
-The value of `--logo` is interpreted as the path to an image file. It is displayed using the sixel graphics protocol.
-* `fastfetch` must be compiled with the `imagemagick6` or `imagemagick7` feature.
-
-## kitty
-
-The value of `--logo` is interpreted as the path to an image file. It is displayed using the kitty graphics protocol.
-* If the file is a png file, and both `--logo-width` and `--logo-height` are specified, the image is directly send to the terminal emulator.
-* Otherwise `fastfetch` must be compiled with the `imagemagick6` or `imagemagick7` feature.
-
-## iterm
-
-The value of `--logo` is interpreted as the path to an image file. It is displayed using the iTerm graphics protocol.
-* Both `--logo-width` and `--logo-height` must be specified.
-
-## chafa
-
-The value of `--logo` is interpreted as the path to an image file. It is converted to an ascii logo using `libchafa`.
-* `fastfetch` must be compiled with the `chafa` feature.
-* `fastfetch` must be compiled with the `imagemagick6` or `imagemagick7` feature.
-* Use `--chafa-fg-only` to set weather to render foreground only.
-* Use `--chafa-symbols` to set the symbols.
-* Use `--chafa-canvas-mode` to set the canvas mode.
-* Use `--chafa-color-space` to set the color space.
-* Use `--chafa-dither-mode` to set the dither mode.
-* See the [chafa documentation](https://hpjansson.org/chafa/man/) for more information.
-
-## raw
-
-The value of `--logo` is interpreted as the path to a binary file. It is printed as-is.
-* Both `--logo-width` and `--logo-height` must be specified.
-* Use this to display a pre converted image file.
-* If the file can't be read, the autodetected builtin logo is displayed.

presets/all

@@ -1 +1 @@
---structure Title:Separator:OS:Host:Bios:Board:Chassis:Kernel:Uptime:Processes:Packages:Shell:Display:Brightness:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:CPUUsage:GPU:Memory:Swap:Disk:Battery:PowerAdapter:Player:Media:PublicIP:LocalIP:Wifi:DateTime:Locale:Vulkan:OpenGL:OpenCL:Users:Weather:Break:Colors
+--structure Title:Separator:OS:Host:Bios:Board:Chassis:Kernel:Uptime:Processes:Packages:Shell:Display:Brightness:Monitor:LM:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Wallpaper:Terminal:TerminalFont:TerminalSize:CPU:CPUUsage:GPU:Memory:Swap:Disk:Battery:PowerAdapter:Player:Media:PublicIP:LocalIP:Wifi:DateTime:Locale:Vulkan:OpenGL:OpenCL:Users:Bluetooth:Sound:Gamepad:Weather:NetIO:DiskIO:Version:Break:Colors

presets/all.jsonc

@@ -0,0 +1,60 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "modules": [
+        "title",
+        "separator",
+        "os",
+        "host",
+        "bios",
+        "board",
+        "chassis",
+        "kernel",
+        "uptime",
+        "processes",
+        "packages",
+        "shell",
+        "display",
+        "brightness",
+        "monitor",
+        "lm",
+        "de",
+        "wm",
+        "wmtheme",
+        "theme",
+        "icons",
+        "font",
+        "cursor",
+        "wallpaper",
+        "terminal",
+        "terminalfont",
+        "terminalsize",
+        "cpu",
+        "cpuusage",
+        "gpu",
+        "memory",
+        "swap",
+        "disk",
+        "battery",
+        "poweradapter",
+        "player",
+        "media",
+        "publicip",
+        "localip",
+        "wifi",
+        "datetime",
+        "locale",
+        "vulkan",
+        "opengl",
+        "opencl",
+        "users",
+        "bluetooth",
+        "sound",
+        "gamepad",
+        "weather",
+        "netio",
+        "diskio",
+        "version",
+        "break",
+        "colors"
+    ]
+}

presets/btw.jsonc

@@ -0,0 +1,42 @@
+{
+    "$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"
+    ]
+}

presets/ci

@@ -0,0 +1,7 @@
+-c all
+--pipe
+--show-errors
+--no-buffer
+--publicip-timeout 1000
+--weather-timeout 1000
+--stat

presets/devinfo

@@ -1,3 +0,0 @@
---disable-linewrap false
---multithreading false
---show-errors

presets/devinfo-verbose

@@ -1,3 +0,0 @@
---load-config devinfo
---load-config all
---load-config verbose

presets/examples/10.jsonc

@@ -0,0 +1,150 @@
+// Load with --load-config examples/2.jsonc
+// Note that you must replace the image path to an existing image to display it.
+
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "padding": {
+            "top": 2
+        }
+    },
+    "display": {
+        "separator": " -> "
+    },
+    "modules": [
+        {
+            "type": "custom",
+            "format": "\u001b[90m┌────────────────────────────────────────────────────────────┐"
+        },
+        {
+            "type": "title",
+            "keyWidth": 10
+        },
+        {
+            "type": "custom",
+            "format": "\u001b[90m└────────────────────────────────────────────────────────────┘"
+        },
+        {
+            "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"
+        },
+        {
+            "type": "custom",
+            "format": "\u001b[90m┌────────────────────────────────────────────────────────────┐"
+        },
+        {
+            "type": "os",
+            "key": " OS",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "kernel",
+            "key": "│ ├",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "packages",
+            "key": "│ ├󰏖",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "shell",
+            "key": "│ └",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "wm",
+            "key": " DE/WM",
+            "keyColor": "blue"
+        },
+        {
+            "type": "lm",
+            "key": "│ ├󰧨",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wmtheme",
+            "key": "│ ├󰉼",
+            "keyColor": "blue"
+        },
+        {
+            "type": "icons",
+            "key": "│ ├󰀻",
+            "keyColor": "blue"
+        },
+        {
+            "type": "terminal",
+            "key": "│ ├",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wallpaper",
+            "key": "│ └󰸉",
+            "keyColor": "blue"
+        },
+        {
+            "type": "host",
+            "key": " PC",
+            "keyColor": "green"
+        },
+        {
+            "type": "cpu",
+            "key": "│ ├",
+            "keyColor": "green"
+        },
+        {
+            "type": "gpu",
+            "key": "│ ├﬙",
+            "keyColor": "green"
+        },
+        {
+            "type": "disk",
+            "key": "│ ├",
+            "keyColor": "green"
+        },
+        {
+            "type": "memory",
+            "key": "│ ├󰑭",
+            "keyColor": "green"
+        },
+        {
+            "type": "swap",
+            "key": "│ ├󰓡",
+            "keyColor": "green"
+        },
+        {
+            "type": "uptime",
+            "key": "│ ├󰅐",
+            "keyColor": "green"
+        },
+        {
+            "type": "display",
+            "key": "│ └󰍹",
+            "keyColor": "green"
+        },
+        {
+            "type": "sound",
+            "key": " SND",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "player",
+            "key": "│ ├󰥠",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "media",
+            "key": "│ └󰝚",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "custom",
+            "format": "\u001b[90m└────────────────────────────────────────────────────────────┘"
+        },
+        "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"
+        }
+    ]
+}

presets/examples/11.jsonc

@@ -0,0 +1,37 @@
+{
+    "$schema": "file:///C:/msys64/home/zhang/fastfetch/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "display": {
+        "separator": "\u001b[31m->   "
+    },
+    "modules": [
+        {
+            "key": "Distro      ",
+            "type": "os"
+        },
+        {
+            "key": "Shell       ",
+            "type": "shell"
+        },
+        {
+            "key": "Terminal    ",
+            "type": "terminal"
+        },
+        {
+            "key": "Display     ",
+            "type": "display"
+        },
+        {
+            "key": "Backlight   ",
+            "type": "brightness"
+        },
+        "break",
+        {
+            "type": "colors",
+            "paddingLeft": 6,
+            "symbol": "circle"
+        }
+    ]
+}

presets/examples/2

@@ -20,5 +20,5 @@
 --wm-key "  "
 --shell-key "  "
 --terminal-key "  "
---terminal-font-key "  "
+--terminalfont-key "  "
 --packages-key "  "

presets/examples/2.jsonc

@@ -0,0 +1,166 @@
+// Load with --load-config examples/2.jsonc
+// Note that you must replace the image path to an existing image to display it.
+
+{
+    "$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": "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": "  "
+        },
+        {
+            "type": "custom", // SoftwareStart
+            "format": "├─────────── \u001b[1mSoftware Information\u001b[0m ───────────┤"
+        },
+        {
+            "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": "  󰝚"
+        },
+        {
+            "type": "localip",
+            "key": "  󰩟",
+            "compact": true
+        },
+        {
+            "type": "publicip",
+            "key": "  󰩠"
+        },
+        {
+            "type": "wifi",
+            "key": "  ",
+            "format": "{4}" // ssid
+        },
+        {
+            "type": "locale",
+            "key": "  "
+        },
+        {
+            "type": "custom", // InformationEnd
+            "format": "└────────────────────────────────────────────┘"
+        },
+        {
+            "type": "colors",
+            "paddingLeft": 2,
+            "symbol": "circle"
+        }
+    ]
+}

presets/examples/3.jsonc

@@ -0,0 +1,20 @@
+// Load with --load-config examples/3.jsonc
+
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": "debian_small",
+    "display": {
+        "binaryPrefix": "si"
+    },
+    "modules": [
+        "vulkan",
+        "opengl",
+        "opencl",
+        "memory",
+        {
+            "type": "disk",
+            "folders": "/:/home:/boot:/efi"
+        },
+        "localip"
+    ]
+}

presets/examples/4

@@ -4,4 +4,4 @@
 --logo arch_small
 --logo-padding-right 1
 --separator "  "
---structure Date:Time:Break:Player:Media
+--structure DateTime:Break:Player:Media

presets/examples/4.jsonc

@@ -0,0 +1,31 @@
+// Load with --load-config examples/4.jsonc
+
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "source": "arch_small",
+        "padding": {
+            "right": 1
+        }
+    },
+    "display": {
+        "binaryPrefix": "si",
+        "color": "blue",
+        "separator": "  "
+    },
+    "modules": [
+        {
+            "type": "datetime",
+            "key": "Date",
+            "format": "{1}-{3}-{11}"
+        },
+        {
+            "type": "datetime",
+            "key": "Time",
+            "format": "{14}:{17}:{20}"
+        },
+        "break",
+        "player",
+        "media"
+    ]
+}

presets/examples/5.jsonc

@@ -0,0 +1,29 @@
+// Load with --load-config examples/5.jsonc
+
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": null,
+    "display": {
+        "color": "reset_magenta"
+    },
+    "modules": [
+        {
+            "type": "theme",
+            "key": "T",
+            "format": "{7}"
+        },
+        {
+            "type": "icons",
+            "key": "I",
+            "format": "{5}"
+        },
+        {
+            "type": "font",
+            "key": "F"
+        },
+        {
+            "type": "cursor",
+            "key": "C"
+        }
+    ]
+}

presets/examples/6.jsonc

@@ -0,0 +1,185 @@
+// Load with --load-config examples/2.jsonc
+// Note that you must replace the image path to an existing image to display it.
+
+{
+    "$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": "╭─",
+            "keyColor": "green"
+        },
+        {
+            "type": "cpu",
+            "key": "├─",
+            "keyColor": "green"
+        },
+        {
+            "type": "gpu",
+            "key": "├─﬙",
+            "keyColor": "green"
+        },
+        {
+            "type": "disk",
+            "key": "├─",
+            "keyColor": "green"
+        },
+        {
+            "type": "memory",
+            "key": "├─󰑭",
+            "keyColor": "green"
+        },
+        {
+            "type": "swap",
+            "key": "├─󰓡",
+            "keyColor": "green"
+        },
+        {
+            "type": "display",
+            "key": "├─󰍹",
+            "keyColor": "green"
+        },
+        {
+            "type": "brightness",
+            "key": "├─󰃞",
+            "keyColor": "green"
+        },
+        {
+            "type": "battery",
+            "key": "├─",
+            "keyColor": "green"
+        },
+        {
+            "type": "poweradapter",
+            "key": "├─",
+            "keyColor": "green"
+        },
+        {
+            "type": "gamepad",
+            "key": "├─",
+            "keyColor": "green"
+        },
+        {
+            "type": "bluetooth",
+            "key": "├─",
+            "keyColor": "green"
+        },
+        {
+            "type": "sound",
+            "key": "╰─",
+            "keyColor": "green"
+        },
+        "break",
+
+        {
+            "type": "shell",
+            "key": "╭─",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "terminal",
+            "key": "├─",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "terminalfont",
+            "key": "├─",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "lm",
+            "key": "├─󰧨",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "de",
+            "key": "├─",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "wm",
+            "key": "├─",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "theme",
+            "key": "├─󰉼",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "icons",
+            "key": "├─󰀻",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "wallpaper",
+            "key": "╰─󰸉",
+            "keyColor": "yellow"
+        },
+
+        "break",
+        {
+            "type": "title",
+            "key": "╭─",
+            "format": "{1}@{2}",
+            "keyColor": "blue"
+        },
+        {
+            "type": "os",
+            "key": "├─", // Just get your distro's logo off nerdfonts.com
+            "keyColor": "blue"
+        },
+        {
+            "type": "kernel",
+            "key": "├─",
+            "format": "{1} {2}",
+            "keyColor": "blue"
+        },
+        {
+            "type": "packages",
+            "key": "├─󰏖",
+            "keyColor": "blue"
+        },
+        {
+            "type": "uptime",
+            "key": "├─󰅐",
+            "keyColor": "blue"
+        },
+        {
+            "type": "media",
+            "key": "├─󰝚",
+            "keyColor": "blue"
+        },
+        {
+            "type": "localip",
+            "key": "├─󰩟",
+            "compact": true,
+            "keyColor": "blue"
+        },
+        {
+            "type": "publicip",
+            "key": "├─󰩠",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wifi",
+            "key": "├─",
+            "format": "{4}", // ssid
+            "keyColor": "blue"
+        },
+        {
+            "type": "locale",
+            "key": "╰─",
+            "keyColor": "blue"
+        }
+    ]
+}

presets/examples/7.jsonc

@@ -0,0 +1,139 @@
+// Load with --load-config examples/2.jsonc
+// Note that you must replace the image path to an existing image to display it.
+
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "padding": {
+            "top": 2
+        }
+    },
+    "display": {
+        "separator": " -> "
+    },
+    "modules": [
+        "title",
+        "separator",
+        {
+            "type": "os",
+            "key": " OS",
+            "keyColor": "yellow",
+            "format": "{2}"
+        },
+        {
+            "type": "os",
+            "key": "├", // Just get your distro's logo off nerdfonts.com
+            "keyColor": "yellow",
+            "format": "{6}{?6} {?}{10} {8}"
+        },
+        {
+            "type": "kernel",
+            "key": "├",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "packages",
+            "key": "├󰏖",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "shell",
+            "key": "└",
+            "keyColor": "yellow"
+        },
+        "break",
+
+        {
+            "type": "wm",
+            "key": " DE/WM",
+            "keyColor": "blue"
+        },
+        {
+            "type": "lm",
+            "key": "├󰧨",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wmtheme",
+            "key": "├󰉼",
+            "keyColor": "blue"
+        },
+        {
+            "type": "icons",
+            "key": "├󰀻",
+            "keyColor": "blue"
+        },
+        {
+            "type": "terminal",
+            "key": "├",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wallpaper",
+            "key": "└󰸉",
+            "keyColor": "blue"
+        },
+
+        "break",
+        {
+            "type": "host",
+            "key": " PC",
+            "keyColor": "green"
+        },
+        {
+            "type": "cpu",
+            "key": "├",
+            "keyColor": "green"
+        },
+        {
+            "type": "gpu",
+            "key": "├﬙",
+            "keyColor": "green"
+        },
+        {
+            "type": "disk",
+            "key": "├",
+            "keyColor": "green"
+        },
+        {
+            "type": "memory",
+            "key": "├󰑭",
+            "keyColor": "green"
+        },
+        {
+            "type": "swap",
+            "key": "├󰓡",
+            "keyColor": "green"
+        },
+        {
+            "type": "uptime",
+            "key": "├󰅐",
+            "keyColor": "green"
+        },
+        {
+            "type": "display",
+            "key": "└󰍹",
+            "keyColor": "green"
+        },
+
+        "break",
+        {
+            "type": "sound",
+            "key": " SOUND",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "player",
+            "key": "├󰥠",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "media",
+            "key": "└󰝚",
+            "keyColor": "cyan"
+        },
+
+        "break",
+        "colors"
+    ]
+}

presets/examples/8.jsonc

@@ -0,0 +1,52 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "display": {
+        "separator": "  ",
+        "color": {
+            "keys": "magenta"
+        },
+        "size": {
+            "ndigits": 0,
+            "maxPrefix": "MB"
+        }
+    },
+    "modules": [
+        {
+            "type": "title",
+            "color": {
+                "user": "green",
+                "at": "red",
+                "host": "blue"
+            }
+        },
+        {
+            "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███"
+        }
+    ]
+}

presets/examples/9.jsonc

@@ -0,0 +1,27 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "display": {
+        "keyWidth": 11,
+        "bar": {
+            "charElapsed": "=",
+            "charTotal": "-",
+            "width": 13
+        }
+    },
+    "modules": [
+        "title",
+        "separator",
+        "memory",
+        "swap",
+        "disk",
+        "battery",
+        {
+            "type": "colors",
+            "paddingLeft": 11,
+            "symbol": "circle"
+        }
+    ]
+}

presets/hardware.jsonc

@@ -0,0 +1,25 @@
+{
+    "$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}){?}"
+        }
+    ]
+}

presets/neofetch

@@ -1,10 +1,9 @@
 --structure "Title:Separator:OS:Host:Kernel:Uptime:Packages:Shell:Display:DE:WM:WMTheme:Theme:Icons:Terminal:TerminalFont:CPU:GPU:Memory:Break:Colors"
 --host-format "{/2}{-}{/}{2}{?3} {3}{?}"
 --os-format "{3} {12}"
---display-format "{}x{}"
+--display-key Resolution
+--display-compact-type original
 --de-format "{2} {3}"
 --theme-format "{?1}{1}{?3} {3}{?} [Plasma], {?}{7}"
---terminal-font-format "{/2}{-}{/}{2}{?3} {3}{?}"
+--terminalfont-format "{/2}{-}{/}{2}{?3} {3}{?}"
 --memory-format "{/1}{-}{/}{/2}{-}{/}{} / {}"
---gpu-key "GPU"
---display-key "Display"

presets/neofetch.jsonc

@@ -0,0 +1,48 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "modules": [
+        "title",
+        "separator",
+        {
+            "type": "os",
+            "format": "{3} {12}"
+        },
+        {
+            "type": "host",
+            "format": "{/2}{-}{/}{2}{?3} {3}{?}"
+        },
+        "kernel",
+        "uptime",
+        "packages",
+        "shell",
+        {
+            "type": "display",
+            "compactType": "original",
+            "key": "Resolution"
+        },
+        "de",
+        "wm",
+        "wmtheme",
+        {
+            "type": "theme",
+            "format": "{?1}{1}{?3} {3}{?} [Plasma], {?}{7}"
+        },
+        "icons",
+        "terminal",
+        {
+            "type": "terminalfont",
+            "format": "{/2}{-}{/}{2}{?3} {3}{?}"
+        },
+        "cpu",
+        {
+            "type": "gpu",
+            "key": "GPU"
+        },
+        {
+            "type": "memory",
+            "format": "{/1}{-}{/}{/2}{-}{/}{} / {}"
+        },
+        "break",
+        "colors"
+    ]
+}

presets/paleofetch.jsonc

@@ -0,0 +1,35 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "modules": [
+        "title",
+        "separator",
+        "os",
+        {
+            "type": "host",
+            "format": "{/2}{-}{/}{2}{?3} {3}{?}"
+        },
+        "kernel",
+        "uptime",
+        {
+            "type": "battery",
+            "format": "{/4}{-}{/}{4}%{?5} [{5}]{?}"
+        },
+        "break",
+        "packages",
+        "shell",
+        {
+            "type": "display",
+            "key": "Display"
+        },
+        "terminal",
+        "break",
+        "cpu",
+        {
+            "type": "gpu",
+            "key": "GPU"
+        },
+        "memory",
+        "break",
+        "colors"
+    ]
+}

presets/software.jsonc

@@ -0,0 +1,17 @@
+{
+    "$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"
+    ]
+}

presets/verbose

@@ -1,30 +0,0 @@
---os-format System: {}; Name: {}; Pretty name: {}; ID: {}; ID like: {}; Variant: {}; Variant ID: {}; Version: {}; Version ID: {}; Version codename: {}; Build ID: {}; Architecture: {}
---host-format Family: product_family: {}; product_name: {}; product_version: {}; product_sku: {}; sys_vendor: {}
---kernel-format Sysname: {}; Release: {}; Version: {}
---uptime-format Days: {}; Hours: {}; Minutes: {}; Seconds: {}
---processes-format Count: {}
---packages-format All: {}; pacman: {}; pacman branch: {}; dpkg: {}; rpm: {}; emerge: {}; eopkg: {}; xbps: {}; apk: {}; flatpak: {}; snap: {}; brew: {}; brew-cask: {}; port: {}; scoop: {}; choco: {}
---shell-format Process name: {}; Process path: {}; Process exe: {}; Process version: {}; User path: {}; User exe: {}; User version: {}
---display-format Width: {}; Height: {}; Refresh rate: {}
---de-format Process name: {}; Pretty name: {}; Version: {}
---wm-format Process name: {}; Pretty name: {}; Protocol: {}
---wm-theme-format Name: {}
---theme-format Plasma: {}; Plasma colors: {}; Plasma colors pretty: {}; GTK2: {}; GTK3: {}; GTK4: {}; GTK: {}
---icons-format Plasma: {}; GTK2: {}; GTK3: {}; GTK4: {}; GTK: {}
---font-format Font1: {}; Font2: {}; Font3: {}; Font4: {}
---cursor-format Theme: {}; Size: {}
---terminal-format Process: {}; Path: {}; Exe: {}
---terminal-font-format Pretty: {}; Name: {}; Size: {}; Styles: {}
---cpu-format Name: {}, Vendor: {}, CoresPhysical: {}, CoresLogical: {}, CoresOnline: {}, FrequencyMin: {}, FrequencyMax: {}, Temperature: {}
---cpu-usage-format Percentage: {}
---gpu-format Vendor: {}; Name: {}; Driver: {}; Temperature: {}; CoreCount: {}
---memory-format Used: {}; Total: {}; Percentage: {}
---disk-format SizeUsed: {}; SizeTotal: {}; SizePercentage: {}; FilesUsed: {}; FilesTotal: {}; FilesPercentage: {}; Removable: {}; Hidden: {}; Filesystem: {}; Name: {}
---battery-format Manufactor: {}; Model: {}; Technology: {}; Capacity: {}; Status: {}
---poweradapter-format Watts: {}; Name: {}; Manufactor: {}; Model: {}; Description: {}
---player-format Pretty: {}; Name: {}; Bus: {}; Url: {}
---media-format Pretty: {}; Name: {};  Artist: {}; Album: {}
---datetime-format year: {}; yearShort: {}; month: {}; monthPretty: {}; monthName: {}; monthNameShort: {}; weekNumber: {}; weekday: {}; weekdayShort: {}; dayInYear: {}; dayInMonth: {}; dayInWeek: {}; hour: {}; hourPretty: {}; hour12: {}; hour12Pretty: {}; minute: {}; minutePretty: {}; second: {}; secondPretty: {}
---vulkan-format driver: {}; Api Version: {}; Conformance Version: {}
---opengl-format version: {}; renderer: {}; vendor: {}
---opencl-format version: {}; device: {}; vendor: {}

src/3rdparty/mk_wcwidch/repo.json

@@ -0,0 +1,7 @@
+{
+    "home": "https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c",
+    "license": "Embed in source",
+    "version": "2007-05-26 (Unicode 5.0)",
+    "author": "Markus Kuhn",
+    "modified": "CarterLi"
+}

src/3rdparty/mk_wcwidch/wcwidth.c

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

src/3rdparty/nvml/repo.json

@@ -0,0 +1,6 @@
+{
+    "home": "https://github.com/NVIDIA/nvidia-settings/blob/main/src/nvml.h",
+    "license": "Embed in source",
+    "version": "545.23.06",
+    "author": "NVIDIA Corporation"
+}

src/3rdparty/yyjson/repo.json

@@ -0,0 +1,6 @@
+{
+    "home": "https://github.com/ibireme/yyjson",
+    "license": "MIT ( embed in source )",
+    "version": "0.8.0",
+    "author": "ibireme"
+}

src/common/bar.c

@@ -1,49 +1,111 @@
+#include "common/bar.h"
+#include "common/color.h"
 #include "util/textModifier.h"
-#include "bar.h"
 
-// green, yellow, red: print the color on nth (0~9) block
-// set its value == 10 means the color will not be printed
-void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red)
+void ffAppendPercentBar(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, uint8_t red)
 {
-    assert(green <= 10 && yellow <= 10 && red <= 10);
+    assert(green <= 100 && yellow <= 100 && red <= 100);
 
-    // [ 0%,  5%) prints 0 blocks
-    // [ 5%, 15%) prints 1 block;
-    // ...
-    // [85%, 95%) prints 9 blocks;
-    // [95%,100%] prints 10 blocks
-    percent = (uint8_t)(percent + 5) / 10;
-    assert(percent <= 10);
+    const FFOptionsDisplay* options = &instance.config.display;
 
-    if(!instance->config.pipe)
-        ffStrbufAppendS(buffer, "\033[97m[ ");
-    else
-        ffStrbufAppendS(buffer, "[ ");
+    uint32_t blocksPercent = (uint32_t) (percent / 100.0 * options->barWidth + 0.5);
+    uint32_t blocksGreen = (uint32_t) (green / 100.0 * options->barWidth + 0.5);
+    uint32_t blocksYellow = (uint32_t) (yellow / 100.0 * options->barWidth + 0.5);
+    uint32_t blocksRed = (uint32_t) (red / 100.0 * options->barWidth + 0.5);
+    assert(blocksPercent <= options->barWidth);
 
-    for (uint8_t i = 0; i < percent; ++i)
+    if(options->barBorder)
     {
-        if(!instance->config.pipe)
+        if(!options->pipe)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m[ ");
+        else
+            ffStrbufAppendS(buffer, "[ ");
+    }
+
+    for (uint32_t i = 0; i < blocksPercent; ++i)
+    {
+        if(!options->pipe)
         {
-            if (i == green)
-                ffStrbufAppendS(buffer, "\033[32m");
-            else if (i == yellow)
-                ffStrbufAppendS(buffer, "\033[93m");
-            else if (i == red)
-                ffStrbufAppendS(buffer, "\033[91m");
+            if (i == blocksGreen)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m");
+            else if (i == blocksYellow)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m");
+            else if (i == blocksRed)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m");
         }
-        ffStrbufAppendS(buffer, "■");
+        ffStrbufAppend(buffer, &options->barCharElapsed);
     }
 
-    if (percent < 10)
+    if (blocksPercent < options->barWidth)
     {
-        if(!instance->config.pipe)
-            ffStrbufAppendS(buffer, "\033[97m");
-        for (uint8_t i = percent; i < 10; ++i)
-            ffStrbufAppendS(buffer, "-");
+        if(!options->pipe)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
+        for (uint32_t i = blocksPercent; i < options->barWidth; ++i)
+            ffStrbufAppend(buffer, &options->barCharTotal);
     }
 
-    if(!instance->config.pipe)
-        ffStrbufAppendS(buffer, "\033[97m ]" FASTFETCH_TEXT_MODIFIER_RESET);
-    else
-        ffStrbufAppendS(buffer, " ]");
+    if(options->barBorder)
+    {
+        if(!options->pipe)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m ]");
+        else
+            ffStrbufAppendS(buffer, " ]");
+    }
+
+    if(!options->pipe)
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+}
+
+// if (green < yellow)
+// [0, green]: print green
+// (green, yellow]: print yellow
+// (yellow, 100]: print red
+//
+// if (green > yellow)
+// [green, 100]: print green
+// [yellow, green): print yellow
+// [0, yellow): PRINT RED
+void ffAppendPercentNum(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, bool parentheses)
+{
+    assert(green <= 100 && yellow <= 100);
+
+    const FFOptionsDisplay* options = &instance.config.display;
+
+    bool colored = !!(options->percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
+
+    if (parentheses)
+        ffStrbufAppendC(buffer, '(');
+
+    if (colored && !options->pipe)
+    {
+        if(percent != percent)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_BLACK "m");
+        else if(green < yellow)
+        {
+            if (percent <= green)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m");
+            else if (percent <= yellow)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m");
+            else
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m");
+        }
+        else
+        {
+            if (percent >= green)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m");
+            else if (percent >= yellow)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m");
+            else
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m");
+        }
+    }
+    ffStrbufAppendF(buffer, "%.*f%%", options->percentNdigits, percent);
+
+    if (colored && !options->pipe)
+    {
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+    }
+
+    if (parentheses)
+        ffStrbufAppendC(buffer, ')');
 }

src/common/bar.h

@@ -7,11 +7,13 @@
 
 enum
 {
-    FF_PERCENTAGE_TYPE_NUM_BIT = 1,
-    FF_PERCENTAGE_TYPE_BAR_BIT = 2,
-    FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT = 4,
+    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,
 };
 
-void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red);
+void ffAppendPercentBar(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, uint8_t red);
+void ffAppendPercentNum(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, bool parentheses);
 
 #endif

src/common/color.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#define FF_COLOR_MODE_RESET "0;"
+#define FF_COLOR_MODE_BOLD "1;"
+#define FF_COLOR_MODE_DIM "2;"
+#define FF_COLOR_MODE_ITALIC "3;"
+#define FF_COLOR_MODE_UNDERLINE "4;"
+#define FF_COLOR_MODE_BLINK "5;"
+#define FF_COLOR_MODE_INVERSE "7;"
+#define FF_COLOR_MODE_HIDDEN "8;"
+#define FF_COLOR_MODE_STRIKETHROUGH "9;"
+
+#define FF_COLOR_FG_BLACK "30"
+#define FF_COLOR_FG_RED "31"
+#define FF_COLOR_FG_GREEN "32"
+#define FF_COLOR_FG_YELLOW "33"
+#define FF_COLOR_FG_BLUE "34"
+#define FF_COLOR_FG_MAGENTA "35"
+#define FF_COLOR_FG_CYAN "36"
+#define FF_COLOR_FG_WHITE "37"
+#define FF_COLOR_FG_DEFAULT "39"
+
+#define FF_COLOR_FG_LIGHT_BLACK "90"
+#define FF_COLOR_FG_LIGHT_RED "91"
+#define FF_COLOR_FG_LIGHT_GREEN "92"
+#define FF_COLOR_FG_LIGHT_YELLOW "93"
+#define FF_COLOR_FG_LIGHT_BLUE "94"
+#define FF_COLOR_FG_LIGHT_MAGENTA "95"
+#define FF_COLOR_FG_LIGHT_CYAN "96"
+#define FF_COLOR_FG_LIGHT_WHITE "97"
+
+#define FF_COLOR_BG_BLACK "40"
+#define FF_COLOR_BG_RED "41"
+#define FF_COLOR_BG_GREEN "42"
+#define FF_COLOR_BG_YELLOW "43"
+#define FF_COLOR_BG_BLUE "44"
+#define FF_COLOR_BG_MAGENTA "45"
+#define FF_COLOR_BG_CYAN "46"
+#define FF_COLOR_BG_WHITE "47"
+#define FF_COLOR_BG_DEFAULT "49"
+
+#define FF_COLOR_BG_LIGHT_BLACK "100"
+#define FF_COLOR_BG_LIGHT_RED "101"
+#define FF_COLOR_BG_LIGHT_GREEN "102"
+#define FF_COLOR_BG_LIGHT_YELLOW "103"
+#define FF_COLOR_BG_LIGHT_BLUE "104"
+#define FF_COLOR_BG_LIGHT_MAGENTA "105"
+#define FF_COLOR_BG_LIGHT_CYAN "106"
+#define FF_COLOR_BG_LIGHT_WHITE "107"
+
+#define FF_COLOR_FG_256 "38;5;"
+#define FF_COLOR_BG_256 "48;5;"
+
+#define FF_COLOR_FG_RGB "38;2;"
+#define FF_COLOR_BG_RGB "48;2;"

src/common/commandoption.c

@@ -0,0 +1,184 @@
+#include "commandoption.h"
+#include "common/printing.h"
+#include "common/time.h"
+#include "common/jsonconfig.h"
+#include "fastfetch_datatext.h"
+#include "modules/modules.h"
+#include "util/stringUtils.h"
+
+#include <ctype.h>
+#include <inttypes.h>
+
+bool ffParseModuleOptions(const char* key, const char* value)
+{
+    if (!ffStrStartsWith(key, "--") || !isalpha(key[2])) return false;
+
+    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules)
+    {
+        FFModuleBaseInfo* baseInfo = *modules;
+        if (baseInfo->parseCommandOptions(baseInfo, key, value)) return true;
+    }
+    return false;
+}
+
+void ffPrepareCommandOption(FFdata* data)
+{
+    FFOptionsModules* const options = &instance.config.modules;
+    //If we don't have a custom structure, use the default one
+    if(data->structure.length == 0)
+        ffStrbufAppendS(&data->structure, FASTFETCH_DATATEXT_STRUCTURE);
+
+    if(ffStrbufContainIgnCaseS(&data->structure, FF_CPUUSAGE_MODULE_NAME))
+        ffPrepareCPUUsage();
+
+    if(ffStrbufContainIgnCaseS(&data->structure, FF_DISKIO_MODULE_NAME))
+        ffPrepareDiskIO(&options->diskIo);
+
+    if(ffStrbufContainIgnCaseS(&data->structure, FF_NETIO_MODULE_NAME))
+        ffPrepareNetIO(&options->netIo);
+
+    if(instance.config.general.multithreading)
+    {
+        if(ffStrbufContainIgnCaseS(&data->structure, FF_PUBLICIP_MODULE_NAME))
+            ffPreparePublicIp(&options->publicIP);
+
+        if(ffStrbufContainIgnCaseS(&data->structure, FF_WEATHER_MODULE_NAME))
+            ffPrepareWeather(&options->weather);
+    }
+}
+
+static void genJsonConfig(FFModuleBaseInfo* baseInfo, yyjson_mut_doc* doc)
+{
+    yyjson_mut_val* modules = yyjson_mut_obj_get(doc->root, "modules");
+    if (!modules)
+        modules = yyjson_mut_obj_add_arr(doc, doc->root, "modules");
+
+    yyjson_mut_val* module = yyjson_mut_obj(doc);
+    FF_STRBUF_AUTO_DESTROY type = ffStrbufCreateS(baseInfo->name);
+    ffStrbufLowerCase(&type);
+    yyjson_mut_obj_add_strbuf(doc, module, "type", &type);
+
+    if (baseInfo->generateJsonConfig)
+        baseInfo->generateJsonConfig(baseInfo, doc, module);
+
+    if (yyjson_mut_obj_size(module) > 1)
+        yyjson_mut_arr_add_val(modules, module);
+    else
+        yyjson_mut_arr_add_strbuf(doc, modules, &type);
+}
+
+static void genJsonResult(FFModuleBaseInfo* baseInfo, yyjson_mut_doc* doc)
+{
+    yyjson_mut_val* module = yyjson_mut_arr_add_obj(doc, doc->root);
+    yyjson_mut_obj_add_str(doc, module, "type", baseInfo->name);
+    if (baseInfo->generateJsonResult)
+        baseInfo->generateJsonResult(baseInfo, doc, module);
+    else
+        yyjson_mut_obj_add_str(doc, module, "error", "Unsupported for JSON format");
+}
+
+static 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]))
+    {
+        for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(line[0]) - 'A']; *modules; ++modules)
+        {
+            FFModuleBaseInfo* baseInfo = *modules;
+            if (ffStrEqualsIgnCase(line, baseInfo->name))
+            {
+                if (__builtin_expect(jsonDoc != NULL, false))
+                    fn(baseInfo, jsonDoc);
+                else
+                    baseInfo->printModule(baseInfo);
+                return;
+            }
+        }
+    }
+
+    ffPrintErrorString(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
+    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)
+            ms = ffTimeGetTick();
+
+        parseStructureCommand(data->structure.chars + startIndex, &data->customValues, genJsonResult, jsonDoc);
+
+        if(instance.config.display.stat)
+        {
+            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);
+            }
+            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
+            }
+        }
+
+        #if defined(_WIN32)
+            if (!jsonDoc && !instance.config.display.noBuffer) fflush(stdout);
+        #endif
+
+        startIndex = colonIndex + 1;
+    }
+}
+
+void ffMigrateCommandOptionToJsonc(FFdata* data, yyjson_mut_doc* jsonDoc)
+{
+    //If we don't have a custom structure, use the default one
+    if(data->structure.length == 0)
+        ffStrbufAppendS(&data->structure, FASTFETCH_DATATEXT_STRUCTURE);
+
+    //Parse the structure and call the modules
+    uint32_t startIndex = 0;
+    while (startIndex < data->structure.length)
+    {
+        uint32_t colonIndex = ffStrbufNextIndexC(&data->structure, startIndex, ':');
+        data->structure.chars[colonIndex] = '\0';
+
+        parseStructureCommand(data->structure.chars + startIndex, &data->customValues, genJsonConfig, jsonDoc);
+
+        startIndex = colonIndex + 1;
+    }
+}

src/common/commandoption.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_commandoption
+#define FF_INCLUDED_common_commandoption
+
+#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 loadUserConfig;
+} FFdata;
+
+bool ffParseModuleOptions(const char* key, const char* value);
+void ffPrepareCommandOption(FFdata* data);
+void ffPrintCommandOption(FFdata* data, yyjson_mut_doc* jsonDoc);
+void ffMigrateCommandOptionToJsonc(FFdata* data, yyjson_mut_doc* jsonDoc);
+
+#endif

src/common/dbus.c

@@ -0,0 +1,202 @@
+#include "dbus.h"
+
+#ifdef FF_HAVE_DBUS
+
+#include "common/thread.h"
+#include "util/stringUtils.h"
+
+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_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)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_has_next, false)
+    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;
+}
+
+static const FFDBusLibrary* loadLib(void)
+{
+    static FFDBusLibrary lib;
+    static bool loaded = false;
+    static bool loadSuccess = false;
+
+    if(!loaded)
+    {
+        loaded = true;
+        loadSuccess = loadLibSymbols(&lib);
+    }
+
+    return loadSuccess ? &lib : NULL;
+}
+
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data)
+{
+    data->lib = loadLib();
+    if(data->lib == NULL)
+        return "Failed to load DBus library";
+
+    data->connection = data->lib->ffdbus_bus_get(busType, NULL);
+    if(data->connection == NULL)
+        return "Failed to connect to DBus";
+
+    return NULL;
+}
+
+bool ffDBusGetValue(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result)
+{
+    int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);
+
+    if(argType == DBUS_TYPE_STRING)
+    {
+        const char* value = NULL;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+
+        if(!ffStrSet(value))
+            return false;
+
+        ffStrbufAppendS(result, value);
+        return true;
+    }
+
+    if(argType != DBUS_TYPE_VARIANT && argType != DBUS_TYPE_ARRAY)
+        return false;
+
+    DBusMessageIter subIter;
+    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
+
+    if(argType == DBUS_TYPE_VARIANT)
+        return ffDBusGetValue(dbus, &subIter, result);
+
+    //At this point we have an array
+
+    bool foundAValue = false;
+
+    while(true)
+    {
+        if(ffDBusGetValue(dbus, &subIter, result))
+        {
+            foundAValue = true;
+            ffStrbufAppendS(result, ", ");
+        }
+
+        FF_DBUS_ITER_CONTINUE(dbus, &subIter);
+    }
+
+    if(foundAValue)
+        ffStrbufSubstrBefore(result, result->length - 2);
+
+    return foundAValue;
+}
+
+bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result)
+{
+    int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);
+
+    if(argType == DBUS_TYPE_BOOLEAN)
+    {
+        dbus_bool_t value = 0;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+        *result = value != 0;
+        return true;
+    }
+
+    if(argType != DBUS_TYPE_VARIANT)
+        return false;
+
+    DBusMessageIter subIter;
+    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
+    return ffDBusGetBool(dbus, &subIter, result);
+}
+
+bool ffDBusGetByte(FFDBusData* dbus, DBusMessageIter* iter, uint8_t* result)
+{
+    int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);
+
+    if(argType == DBUS_TYPE_BYTE)
+    {
+        dbus->lib->ffdbus_message_iter_get_basic(iter, result);
+        return true;
+    }
+
+    if(argType != DBUS_TYPE_VARIANT)
+        return false;
+
+    DBusMessageIter subIter;
+    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
+    return ffDBusGetByte(dbus, &subIter, result);
+}
+
+DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method)
+{
+    DBusMessage* message = dbus->lib->ffdbus_message_new_method_call(busName, objectPath, interface, method);
+    if(message == NULL)
+        return NULL;
+
+    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);
+
+    return reply;
+}
+
+DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property)
+{
+    DBusMessage* message = dbus->lib->ffdbus_message_new_method_call(busName, objectPath, "org.freedesktop.DBus.Properties", "Get");
+    if(message == NULL)
+        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;
+    }
+
+    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);
+
+    return reply;
+}
+
+void 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;
+
+    DBusMessageIter rootIterator;
+    if(!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator))
+    {
+        dbus->lib->ffdbus_message_unref(reply);
+        return;
+    }
+
+    ffDBusGetValue(dbus, &rootIterator, result);
+
+    dbus->lib->ffdbus_message_unref(reply);
+}
+
+#endif //FF_HAVE_DBUS

src/common/dbus.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_dbus
+#define FF_INCLUDED_common_dbus
+
+#ifdef FF_HAVE_DBUS
+#include <dbus/dbus.h>
+
+#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; \
+    }
+
+typedef struct FFDBusLibrary
+{
+    FF_LIBRARY_SYMBOL(dbus_bus_get)
+    FF_LIBRARY_SYMBOL(dbus_message_new_method_call)
+    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)
+    FF_LIBRARY_SYMBOL(dbus_message_iter_has_next)
+    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
+{
+    const FFDBusLibrary* lib;
+    DBusConnection* connection;
+} 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 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);
+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);
+
+#endif // FF_HAVE_DBUS
+#endif // FF_INCLUDED_common_dbus

src/common/font.c

@@ -3,12 +3,13 @@
 
 #include <string.h>
 
-static void fontInit(FFfont* font)
+void ffFontInit(FFfont* font)
 {
+    // Ensure no memory allocates
     ffStrbufInit(&font->pretty);
     ffStrbufInit(&font->name);
-    ffStrbufInitA(&font->size, 4);
-    ffListInitA(&font->styles, sizeof(FFstrbuf), 4);
+    ffStrbufInit(&font->size);
+    ffListInit(&font->styles, sizeof(FFstrbuf));
 }
 
 static void fontInitPretty(FFfont* font)
@@ -44,7 +45,7 @@ static void fontInitPretty(FFfont* font)
 
 void ffFontInitQt(FFfont* font, const char* data)
 {
-    fontInit(font);
+    ffFontInit(font);
 
     //See https://doc.qt.io/qt-5/qfont.html#toString
 
@@ -181,7 +182,7 @@ static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* altern
 
 void ffFontInitPango(FFfont* font, const char* data)
 {
-    fontInit(font);
+    ffFontInit(font);
 
     while(*data != '\0' && *data != '`' && *data != '\\')
         fontPangoParseWord(&data, font, NULL);
@@ -191,7 +192,7 @@ void ffFontInitPango(FFfont* font, const char* data)
 
 void ffFontInitValues(FFfont* font, const char* name, const char* size)
 {
-    fontInit(font);
+    ffFontInit(font);
 
     ffStrbufAppendS(&font->name, name);
     ffStrbufAppendS(&font->size, size);
@@ -213,7 +214,7 @@ void ffFontInitWithSpace(FFfont* font, const char* rawName)
         return;
     }
 
-    fontInit(font);
+    ffFontInit(font);
 
     ffStrbufAppendNS(&font->name, (uint32_t)(pspace - rawName), rawName);
     ffStrbufAppendS(&font->size, pspace + 1);

src/common/font.h

@@ -14,6 +14,7 @@ typedef struct FFfont
     FFlist styles;
 } FFfont;
 
+void ffFontInit(FFfont* font);
 void ffFontInitQt(FFfont* font, const char* data);
 void ffFontInitPango(FFfont* font, const char* data);
 void ffFontInitCopy(FFfont* font, const char* name);

src/common/format.c

@@ -2,6 +2,7 @@
 #include "common/format.h"
 #include "common/parsing.h"
 #include "util/textModifier.h"
+#include "util/stringUtils.h"
 
 #include <inttypes.h>
 
@@ -11,6 +12,8 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
         ffStrbufAppendF(buffer, "%i", *(int*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT)
         ffStrbufAppendF(buffer, "%" PRIu32, *(uint32_t*)formatarg->value);
+    else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT64)
+        ffStrbufAppendF(buffer, "%" PRIu64, *(uint64_t*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT16)
         ffStrbufAppendF(buffer, "%" PRIu16, *(uint16_t*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT8)
@@ -24,7 +27,7 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_DOUBLE)
         ffStrbufAppendF(buffer, "%g", *(double*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_BOOL)
-        ffStrbufAppendS(buffer, formatarg->value != NULL ? "true" : "false");
+        ffStrbufAppendS(buffer, *(bool*)formatarg->value ? "true" : "false");
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_LIST)
     {
         const FFlist* list = formatarg->value;
@@ -133,18 +136,14 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             continue;
         }
 
-        FFstrbuf placeholderValue;
-        ffStrbufInit(&placeholderValue);
+        FF_STRBUF_AUTO_DESTROY placeholderValue = ffStrbufCreate();
 
         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] == '-')
-        {
-            ffStrbufDestroy(&placeholderValue);
             break;
-        }
 
         // test for end of an if, if so do nothing
         if(placeholderValue.length == 1 && placeholderValue.chars[0] == '?')
@@ -154,7 +153,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             else
                 --numOpenIfs;
 
-            ffStrbufDestroy(&placeholderValue);
             continue;
         }
 
@@ -166,7 +164,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             else
                 --numOpenNotIfs;
 
-            ffStrbufDestroy(&placeholderValue);
             continue;
         }
 
@@ -181,7 +178,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
                 --numOpenColors;
             }
 
-            ffStrbufDestroy(&placeholderValue);
             continue;
         }
 
@@ -196,7 +192,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             if(index > numArgs)
             {
                 appendInvalidPlaceholder(buffer, "{?", &placeholderValue, i, formatstr->length);
-                ffStrbufDestroy(&placeholderValue);
                 continue;
             }
 
@@ -204,13 +199,11 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             if(formatArgSet(&arguments[index - 1]))
             {
                 ++numOpenIfs;
-                ffStrbufDestroy(&placeholderValue);
                 continue;
             }
 
             // fastforward to the end of the if without printing the in between
             i = ffStrbufNextIndexS(formatstr, i, "{?}") + 2; // 2 is the length of "{?}" - 1 because the loop will increament it again directly after continue
-            ffStrbufDestroy(&placeholderValue);
             continue;
         }
 
@@ -225,7 +218,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             if(index > numArgs)
             {
                 appendInvalidPlaceholder(buffer, "{/", &placeholderValue, i, formatstr->length);
-                ffStrbufDestroy(&placeholderValue);
                 continue;
             }
 
@@ -233,13 +225,11 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             if(!formatArgSet(&arguments[index - 1]))
             {
                 ++numOpenNotIfs;
-                ffStrbufDestroy(&placeholderValue);
                 continue;
             }
 
             // fastforward to the end of the if without printing the in between
             i = ffStrbufNextIndexS(formatstr, i, "{/}") + 2; // 2 is the length of "{/}" - 1 because the loop will increament it again directly after continue
-            ffStrbufDestroy(&placeholderValue);
             continue;
         }
 
@@ -251,7 +241,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             ffStrbufAppendS(buffer, "\033[");
             ffStrbufAppend(buffer, &placeholderValue);
             ffStrbufAppendC(buffer, 'm');
-            ffStrbufDestroy(&placeholderValue);
             continue;
         }
 
@@ -261,16 +250,11 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
         if(index > numArgs)
         {
             appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-            ffStrbufDestroy(&placeholderValue);
             continue;
         }
 
         ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
-
-        ffStrbufDestroy(&placeholderValue);
     }
 
-    ffStrbufTrimRight(buffer, ' ');
-
     ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
 }

src/common/format.h

@@ -7,6 +7,7 @@ typedef enum FFformatargtype
 {
     FF_FORMAT_ARG_TYPE_NULL = 0,
     FF_FORMAT_ARG_TYPE_UINT,
+    FF_FORMAT_ARG_TYPE_UINT64,
     FF_FORMAT_ARG_TYPE_UINT16,
     FF_FORMAT_ARG_TYPE_UINT8,
     FF_FORMAT_ARG_TYPE_INT,
@@ -27,6 +28,4 @@ typedef struct FFformatarg
 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
 void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments);
 
-#define FF_FORMAT_ARG_VALUE_BOOL(xpr) ((xpr) ? (const void*) 1 : NULL)
-
 #endif

src/common/init.c

@@ -1,23 +1,22 @@
 #include "fastfetch.h"
 #include "common/parsing.h"
 #include "common/thread.h"
-#include "detection/qt.h"
-#include "detection/gtk.h"
 #include "detection/displayserver/displayserver.h"
 #include "util/textModifier.h"
+#include "logo/logo.h"
 
 #include <stdlib.h>
 #include <unistd.h>
-#include <sys/stat.h>
+#include <locale.h>
 #ifdef _WIN32
-    #include <wincon.h>
-    #include <locale.h>
-    #include <shlobj.h>
+    #include <windows.h>
     #include "util/windows/unicode.h"
 #else
     #include <signal.h>
 #endif
 
+FFinstance instance; // Global singleton
+
 static void initState(FFstate* state)
 {
     state->logoWidth = 0;
@@ -25,223 +24,37 @@ static void initState(FFstate* state)
     state->keysHeight = 0;
 
     ffPlatformInit(&state->platform);
+    state->configDoc = NULL;
+    state->resultDoc = NULL;
 }
 
-static void initModuleArg(FFModuleArgs* args)
+static void defaultConfig(void)
 {
-    ffStrbufInit(&args->key);
-    ffStrbufInit(&args->outputFormat);
-    ffStrbufInit(&args->errorFormat);
+    ffOptionsInitLogo(&instance.config.logo);
+    ffOptionsInitGeneral(&instance.config.general);
+    ffOptionsInitModules(&instance.config.modules);
+    ffOptionsInitDisplay(&instance.config.display);
+    ffOptionsInitLibrary(&instance.config.library);
 }
 
-static void defaultConfig(FFinstance* instance)
-{
-    ffStrbufInitA(&instance->config.logo.source, 0);
-    instance->config.logo.type = FF_LOGO_TYPE_AUTO;
-    for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
-        ffStrbufInit(&instance->config.logo.colors[i]);
-    instance->config.logo.width = 0;
-    instance->config.logo.height = 0; //preserve aspect ratio
-    instance->config.logo.paddingTop = 0;
-    instance->config.logo.paddingLeft = 0;
-    instance->config.logo.paddingRight = 4;
-    instance->config.logo.printRemaining = true;
-    instance->config.logo.preserveAspectRadio = false;
-
-    instance->config.logo.chafaFgOnly = false;
-    ffStrbufInitS(&instance->config.logo.chafaSymbols, "block+border+space-wide-inverted"); // Chafa default
-    instance->config.logo.chafaCanvasMode = UINT32_MAX;
-    instance->config.logo.chafaColorSpace = UINT32_MAX;
-    instance->config.logo.chafaDitherMode = UINT32_MAX;
-
-    ffStrbufInit(&instance->config.colorKeys);
-    ffStrbufInit(&instance->config.colorTitle);
-
-    ffStrbufInit(&instance->config.separator);
-    ffStrbufAppendS(&instance->config.separator, ": ");
-
-    instance->config.showErrors = false;
-    instance->config.recache = false;
-    instance->config.allowSlowOperations = false;
-    instance->config.disableLinewrap = true;
-    instance->config.hideCursor = true;
-    instance->config.escapeBedrock = true;
-    instance->config.binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
-    instance->config.glType = FF_GL_TYPE_AUTO;
-    instance->config.pipe = false;
-    instance->config.multithreading = true;
-    instance->config.stat = false;
-
-    initModuleArg(&instance->config.os);
-    initModuleArg(&instance->config.host);
-    initModuleArg(&instance->config.bios);
-    initModuleArg(&instance->config.board);
-    initModuleArg(&instance->config.brightness);
-    initModuleArg(&instance->config.chassis);
-    initModuleArg(&instance->config.kernel);
-    initModuleArg(&instance->config.uptime);
-    initModuleArg(&instance->config.processes);
-    initModuleArg(&instance->config.packages);
-    initModuleArg(&instance->config.shell);
-    initModuleArg(&instance->config.display);
-    initModuleArg(&instance->config.de);
-    initModuleArg(&instance->config.wm);
-    initModuleArg(&instance->config.wmTheme);
-    initModuleArg(&instance->config.theme);
-    initModuleArg(&instance->config.icons);
-    initModuleArg(&instance->config.font);
-    initModuleArg(&instance->config.cursor);
-    initModuleArg(&instance->config.terminal);
-    initModuleArg(&instance->config.terminalFont);
-    initModuleArg(&instance->config.cpu);
-    initModuleArg(&instance->config.cpuUsage);
-    initModuleArg(&instance->config.gpu);
-    initModuleArg(&instance->config.memory);
-    initModuleArg(&instance->config.swap);
-    initModuleArg(&instance->config.disk);
-    initModuleArg(&instance->config.battery);
-    initModuleArg(&instance->config.powerAdapter);
-    initModuleArg(&instance->config.locale);
-    initModuleArg(&instance->config.localIP);
-    initModuleArg(&instance->config.publicIP);
-    initModuleArg(&instance->config.weather);
-    initModuleArg(&instance->config.wifi);
-    initModuleArg(&instance->config.player);
-    initModuleArg(&instance->config.media);
-    initModuleArg(&instance->config.dateTime);
-    initModuleArg(&instance->config.date);
-    initModuleArg(&instance->config.time);
-    initModuleArg(&instance->config.vulkan);
-    initModuleArg(&instance->config.openGL);
-    initModuleArg(&instance->config.openCL);
-    initModuleArg(&instance->config.users);
-
-    ffStrbufInitA(&instance->config.libPCI, 0);
-    ffStrbufInitA(&instance->config.libVulkan, 0);
-    ffStrbufInitA(&instance->config.libWayland, 0);
-    ffStrbufInitA(&instance->config.libXcbRandr, 0);
-    ffStrbufInitA(&instance->config.libXcb, 0);
-    ffStrbufInitA(&instance->config.libXrandr, 0);
-    ffStrbufInitA(&instance->config.libX11, 0);
-    ffStrbufInitA(&instance->config.libGIO, 0);
-    ffStrbufInitA(&instance->config.libDConf, 0);
-    ffStrbufInitA(&instance->config.libDBus, 0);
-    ffStrbufInitA(&instance->config.libXFConf, 0);
-    ffStrbufInitA(&instance->config.libSQLite3, 0);
-    ffStrbufInitA(&instance->config.librpm, 0);
-    ffStrbufInitA(&instance->config.libImageMagick, 0);
-    ffStrbufInitA(&instance->config.libZ, 0);
-    ffStrbufInitA(&instance->config.libChafa, 0);
-    ffStrbufInitA(&instance->config.libEGL, 0);
-    ffStrbufInitA(&instance->config.libGLX, 0);
-    ffStrbufInitA(&instance->config.libOSMesa, 0);
-    ffStrbufInitA(&instance->config.libOpenCL, 0);
-    ffStrbufInitA(&instance->config.libcJSON, 0);
-    ffStrbufInitA(&instance->config.libfreetype, 0);
-    ffStrbufInit(&instance->config.libwlanapi);
-    ffStrbufInit(&instance->config.libnm);
-
-    instance->config.cpuTemp = false;
-    instance->config.gpuTemp = false;
-    instance->config.batteryTemp = false;
-
-    instance->config.gpuHideIntegrated = false;
-    instance->config.gpuHideDiscrete = false;
-
-    instance->config.shellVersion = true;
-    instance->config.terminalVersion = true;
-
-    instance->config.titleFQDN = false;
-
-    ffStrbufInitA(&instance->config.diskFolders, 0);
-    instance->config.diskShowRemovable = true;
-    instance->config.diskShowHidden = false;
-    instance->config.diskShowUnknown = false;
-    instance->config.diskShowSubvolumes = false;
-
-    ffStrbufInitA(&instance->config.batteryDir, 0);
-
-    ffStrbufInitA(&instance->config.separatorString, 0);
-
-    instance->config.localIpShowIpV4 = true;
-    instance->config.localIpShowIpV6 = false;
-    instance->config.localIpShowLoop = false;
-    ffStrbufInit(&instance->config.localIpNamePrefix);
-
-    instance->config.publicIpTimeout = 0;
-    ffStrbufInit(&instance->config.publicIpUrl);
-
-    instance->config.weatherTimeout = 0;
-    ffStrbufInitS(&instance->config.weatherOutputFormat, "%t+-+%C+(%l)");
-
-    ffStrbufInitA(&instance->config.osFile, 0);
-
-    ffStrbufInitA(&instance->config.playerName, 0);
-
-    instance->config.percentType = 1;
-
-    ffStrbufInitS(&instance->config.commandShell,
-        #ifdef _WIN32
-        "cmd"
-        #elif defined(__FreeBSD__)
-        "csh"
-        #else
-        "bash"
-        #endif
-    );
-    ffListInit(&instance->config.commandKeys, sizeof(FFstrbuf));
-    ffListInit(&instance->config.commandTexts, sizeof(FFstrbuf));
-}
-
-void ffInitInstance(FFinstance* instance)
+void ffInitInstance(void)
 {
     #ifdef WIN32
         //https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendations&view=msvc-170#utf-8-support
         setlocale(LC_ALL, ".UTF8");
-    #endif
-
-    initState(&instance->state);
-    defaultConfig(instance);
-}
-
-#ifdef FF_HAVE_THREADS
-
-FF_THREAD_ENTRY_DECL_WRAPPER(ffConnectDisplayServer, FFinstance*)
-
-#if !(defined(__APPLE__) || defined(_WIN32))
-
-#define FF_DETECT_QT_GTK 1
-
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectQt, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK2, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK3, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK4, FFinstance*)
-
-#endif //!(defined(__APPLE__) || defined(_WIN32))
-
-#endif //FF_HAVE_THREADS
-
-void startDetectionThreads(FFinstance* instance)
-{
-    #ifdef FF_HAVE_THREADS
-    ffThreadDetach(ffThreadCreate(ffConnectDisplayServerThreadMain, instance));
-
-    #ifdef FF_DETECT_QT_GTK
-    ffThreadDetach(ffThreadCreate(ffDetectQtThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK2ThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK3ThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK4ThreadMain, instance));
-    #endif
-
     #else
-    FF_UNUSED(instance);
+        // used for mbsrtowcs in Module `separator`
+        setlocale(LC_ALL, "");
     #endif
+
+    initState(&instance.state);
+    defaultConfig();
 }
 
 static volatile bool ffDisableLinewrap = true;
 static volatile bool ffHideCursor = true;
 
-static void resetConsole()
+static void resetConsole(void)
 {
     if(ffDisableLinewrap)
         fputs("\033[?7h", stdout);
@@ -249,7 +62,7 @@ static void resetConsole()
     if(ffHideCursor)
         fputs("\033[?25h", stdout);
 
-    #if defined(_WIN32) && defined(FF_ENABLE_BUFFER)
+    #if defined(_WIN32)
         fflush(stdout);
     #endif
 }
@@ -258,7 +71,7 @@ static void resetConsole()
 BOOL WINAPI consoleHandler(DWORD signal)
 {
     FF_UNUSED(signal);
-        resetConsole();
+    resetConsole();
     exit(0);
 }
 #else
@@ -270,18 +83,18 @@ static void exitSignalHandler(int signal)
 }
 #endif
 
-void ffStart(FFinstance* instance)
+void ffStart(void)
 {
-    if(instance->config.multithreading)
-        startDetectionThreads(instance);
+    #ifdef FF_START_DETECTION_THREADS
+        if(instance.config.general.multithreading)
+            startDetectionThreads();
+    #endif
 
-    ffDisableLinewrap = instance->config.disableLinewrap && !instance->config.pipe;
-    ffHideCursor = instance->config.hideCursor && !instance->config.pipe;
+    ffDisableLinewrap = instance.config.display.disableLinewrap && !instance.config.display.pipe && !instance.state.resultDoc;
+    ffHideCursor = instance.config.display.hideCursor && !instance.config.display.pipe && !instance.state.resultDoc;
 
     #ifdef _WIN32
-    #ifdef FF_ENABLE_BUFFER
-        setvbuf(stdout, NULL, _IOFBF, 4096);
-    #endif
+    setvbuf(stdout, NULL, _IOFBF, instance.config.display.noBuffer ? 0 : 4096);
     SetConsoleCtrlHandler(consoleHandler, TRUE);
     HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
     DWORD mode = 0;
@@ -289,9 +102,7 @@ void ffStart(FFinstance* instance)
     SetConsoleMode(hStdout, mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
     SetConsoleOutputCP(CP_UTF8);
     #else
-    #ifndef FF_ENABLE_BUFFER
-        setvbuf(stdout, NULL, _IONBF, 0);
-    #endif
+    if (instance.config.display.noBuffer) setvbuf(stdout, NULL, _IONBF, 0);
     struct sigaction action = { .sa_handler = exitSignalHandler };
     sigaction(SIGINT, &action, NULL);
     sigaction(SIGTERM, &action, NULL);
@@ -299,7 +110,7 @@ void ffStart(FFinstance* instance)
     #endif
 
     //reset everything to default before we start printing
-    if(!instance->config.pipe)
+    if(!instance.config.display.pipe && !instance.state.resultDoc)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
     if(ffHideCursor)
@@ -308,134 +119,47 @@ void ffStart(FFinstance* instance)
     if(ffDisableLinewrap)
         fputs("\033[?7l", stdout);
 
-    ffLogoPrint(instance);
+    ffLogoPrint();
 }
 
-void ffFinish(FFinstance* instance)
+void ffFinish(void)
 {
-    if(instance->config.logo.printRemaining)
-        ffLogoPrintRemaining(instance);
+    if(instance.config.logo.printRemaining)
+        ffLogoPrintRemaining();
 
     resetConsole();
 }
 
-static void destroyModuleArg(FFModuleArgs* args)
+static void destroyConfig(void)
 {
-    ffStrbufDestroy(&args->key);
-    ffStrbufDestroy(&args->outputFormat);
-    ffStrbufDestroy(&args->errorFormat);
+    ffOptionsDestroyLogo(&instance.config.logo);
+    ffOptionsDestroyGeneral(&instance.config.general);
+    ffOptionsDestroyModules(&instance.config.modules);
+    ffOptionsDestroyDisplay(&instance.config.display);
+    ffOptionsDestroyLibrary(&instance.config.library);
 }
 
-static void destroyConfig(FFinstance* instance)
+static void destroyState(void)
 {
-    ffStrbufDestroy(&instance->config.logo.source);
-    ffStrbufDestroy(&instance->config.logo.chafaSymbols);
-    for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
-        ffStrbufDestroy(&instance->config.logo.colors[i]);
-    ffStrbufDestroy(&instance->config.colorKeys);
-    ffStrbufDestroy(&instance->config.colorTitle);
-    ffStrbufDestroy(&instance->config.separator);
-
-    destroyModuleArg(&instance->config.os);
-    destroyModuleArg(&instance->config.host);
-    destroyModuleArg(&instance->config.bios);
-    destroyModuleArg(&instance->config.board);
-    destroyModuleArg(&instance->config.kernel);
-    destroyModuleArg(&instance->config.uptime);
-    destroyModuleArg(&instance->config.processes);
-    destroyModuleArg(&instance->config.packages);
-    destroyModuleArg(&instance->config.shell);
-    destroyModuleArg(&instance->config.display);
-    destroyModuleArg(&instance->config.de);
-    destroyModuleArg(&instance->config.wm);
-    destroyModuleArg(&instance->config.wmTheme);
-    destroyModuleArg(&instance->config.theme);
-    destroyModuleArg(&instance->config.icons);
-    destroyModuleArg(&instance->config.font);
-    destroyModuleArg(&instance->config.cursor);
-    destroyModuleArg(&instance->config.terminal);
-    destroyModuleArg(&instance->config.terminalFont);
-    destroyModuleArg(&instance->config.cpu);
-    destroyModuleArg(&instance->config.cpuUsage);
-    destroyModuleArg(&instance->config.gpu);
-    destroyModuleArg(&instance->config.memory);
-    destroyModuleArg(&instance->config.swap);
-    destroyModuleArg(&instance->config.disk);
-    destroyModuleArg(&instance->config.battery);
-    destroyModuleArg(&instance->config.powerAdapter);
-    destroyModuleArg(&instance->config.locale);
-    destroyModuleArg(&instance->config.localIP);
-    destroyModuleArg(&instance->config.publicIP);
-    destroyModuleArg(&instance->config.weather);
-    destroyModuleArg(&instance->config.wifi);
-    destroyModuleArg(&instance->config.player);
-    destroyModuleArg(&instance->config.media);
-    destroyModuleArg(&instance->config.dateTime);
-    destroyModuleArg(&instance->config.date);
-    destroyModuleArg(&instance->config.time);
-    destroyModuleArg(&instance->config.vulkan);
-    destroyModuleArg(&instance->config.openGL);
-    destroyModuleArg(&instance->config.openCL);
-    destroyModuleArg(&instance->config.users);
-
-    ffStrbufDestroy(&instance->config.libPCI);
-    ffStrbufDestroy(&instance->config.libVulkan);
-    ffStrbufDestroy(&instance->config.libWayland);
-    ffStrbufDestroy(&instance->config.libXcbRandr);
-    ffStrbufDestroy(&instance->config.libXcb);
-    ffStrbufDestroy(&instance->config.libXrandr);
-    ffStrbufDestroy(&instance->config.libX11);
-    ffStrbufDestroy(&instance->config.libGIO);
-    ffStrbufDestroy(&instance->config.libDConf);
-    ffStrbufDestroy(&instance->config.libDBus);
-    ffStrbufDestroy(&instance->config.libXFConf);
-    ffStrbufDestroy(&instance->config.libSQLite3);
-    ffStrbufDestroy(&instance->config.librpm);
-    ffStrbufDestroy(&instance->config.libImageMagick);
-    ffStrbufDestroy(&instance->config.libZ);
-    ffStrbufDestroy(&instance->config.libChafa);
-    ffStrbufDestroy(&instance->config.libEGL);
-    ffStrbufDestroy(&instance->config.libGLX);
-    ffStrbufDestroy(&instance->config.libOSMesa);
-    ffStrbufDestroy(&instance->config.libOpenCL);
-    ffStrbufDestroy(&instance->config.libcJSON);
-    ffStrbufDestroy(&instance->config.libfreetype);
-    ffStrbufDestroy(&instance->config.libwlanapi);
-    ffStrbufDestroy(&instance->config.libnm);
-
-    ffStrbufDestroy(&instance->config.diskFolders);
-    ffStrbufDestroy(&instance->config.batteryDir);
-    ffStrbufDestroy(&instance->config.separatorString);
-    ffStrbufDestroy(&instance->config.localIpNamePrefix);
-    ffStrbufDestroy(&instance->config.publicIpUrl);
-    ffStrbufDestroy(&instance->config.weatherOutputFormat);
-    ffStrbufDestroy(&instance->config.osFile);
-    ffStrbufDestroy(&instance->config.playerName);
-
-    ffStrbufDestroy(&instance->config.commandShell);
-    FF_LIST_FOR_EACH(FFstrbuf, item, instance->config.commandKeys)
-        ffStrbufDestroy(item);
-    ffListDestroy(&instance->config.commandKeys);
-    FF_LIST_FOR_EACH(FFstrbuf, item, instance->config.commandTexts)
-        ffStrbufDestroy(item);
-    ffListDestroy(&instance->config.commandTexts);
+    ffPlatformDestroy(&instance.state.platform);
+    yyjson_doc_free(instance.state.configDoc);
+    yyjson_mut_doc_free(instance.state.resultDoc);
+    ffStrbufDestroy(&instance.state.migrateConfigPath);
 }
 
-static void destroyState(FFinstance* instance)
+void ffDestroyInstance(void)
 {
-    ffPlatformDestroy(&instance->state.platform);
-}
-
-void ffDestroyInstance(FFinstance* instance)
-{
-    destroyConfig(instance);
-    destroyState(instance);
+    destroyConfig();
+    destroyState();
 }
 
 //Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
-void ffListFeatures()
+void ffListFeatures(void)
 {
     fputs(
+        #ifdef FF_HAVE_THREADS
+            "threads\n"
+        #endif
         #ifdef FF_HAVE_LIBPCI
             "libpci\n"
         #endif
@@ -499,15 +223,21 @@ void ffListFeatures()
         #ifdef FF_HAVE_OPENCL
             "opencl\n"
         #endif
-        #ifdef FF_HAVE_LIBCJSON
-            "libcjson\n"
-        #endif
         #ifdef FF_HAVE_FREETYPE
             "freetype\n"
         #endif
+        #ifdef FF_HAVE_PULSE
+            "libpulse\n"
+        #endif
         #ifdef FF_HAVE_LIBNM
             "libnm\n"
         #endif
+        #ifdef FF_HAVE_DDCUTIL
+            "libddcutil\n"
+        #endif
+        #ifdef FF_HAVE_DIRECTX_HEADERS
+            "Directx Headers\n"
+        #endif
         ""
     , stdout);
 }

src/common/io.c

@@ -1,285 +0,0 @@
-#include "fastfetch.h"
-#include "common/io.h"
-
-#include <unistd.h>
-#include <fcntl.h>
-
-#ifdef _WIN32
-    #include <fileapi.h>
-#else
-    #include <termios.h>
-    #include <poll.h>
-#endif
-
-static void createSubfolders(const char* fileName)
-{
-    FFstrbuf path;
-    ffStrbufInit(&path);
-
-    while(*fileName != '\0')
-    {
-        ffStrbufAppendC(&path, *fileName);
-        if(*fileName == '/')
-        {
-            mkdir(path.chars
-                #ifndef WIN32
-                , S_IRWXU | S_IRGRP | S_IROTH
-                #endif
-            );
-        }
-        ++fileName;
-    }
-
-    ffStrbufDestroy(&path);
-}
-
-bool ffWriteFDBuffer(int fd, const FFstrbuf* content)
-{
-    return write(fd, content->chars, content->length) != -1;
-}
-
-bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data)
-{
-    #ifdef _WIN32
-    HANDLE handle = CreateFileA(fileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-    if(handle == INVALID_HANDLE_VALUE)
-    {
-        createSubfolders(fileName);
-        handle = CreateFileA(fileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-        if(handle == INVALID_HANDLE_VALUE)
-            return false;
-    }
-
-    DWORD written;
-    bool ret = !!WriteFile(handle, data, (DWORD)dataSize, &written, NULL);
-
-    CloseHandle(handle);
-    #else
-    int openFlagsModes = O_WRONLY | O_CREAT | O_TRUNC;
-    int openFlagsRights = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
-
-    int fd = open(fileName, openFlagsModes, openFlagsRights);
-    if(fd == -1)
-    {
-        createSubfolders(fileName);
-        fd = open(fileName, openFlagsModes, openFlagsRights);
-        if(fd == -1)
-            return false;
-    }
-
-    bool ret = write(fd, data, dataSize) != -1;
-
-    close(fd);
-    #endif
-
-    return ret;
-}
-
-bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer)
-{
-    return ffWriteFileData(fileName, buffer->length, buffer->chars);
-}
-
-#ifdef _WIN32
-
-bool ffAppendHandleBuffer(HANDLE handle, FFstrbuf* buffer)
-{
-    DWORD readed = 0;
-
-    LARGE_INTEGER fileSize;
-    if(!GetFileSizeEx(handle, &fileSize))
-        fileSize.QuadPart = 0;
-
-    ffStrbufEnsureFree(buffer, fileSize.QuadPart > 0 ? (uint32_t)fileSize.QuadPart : 31);
-    uint32_t free = ffStrbufGetFree(buffer);
-
-    bool success;
-    while(
-        (success = !!ReadFile(handle, buffer->chars + buffer->length, free, &readed, NULL)) &&
-        (uint32_t) readed == free
-    ) {
-        buffer->length += (uint32_t) readed;
-        ffStrbufEnsureFree(buffer, buffer->allocated - 1); // Doubles capacity every round. -1 for the null byte.
-        free = ffStrbufGetFree(buffer);
-    }
-
-    if(readed > 0)
-        buffer->length += (uint32_t) readed;
-
-    buffer->chars[buffer->length] = '\0';
-
-    ffStrbufTrimRight(buffer, '\n');
-    ffStrbufTrimRight(buffer, ' ');
-
-    return success;
-}
-
-#endif
-
-bool ffAppendFDBuffer(int fd, FFstrbuf* buffer)
-{
-    ssize_t readed = 0;
-
-    struct stat fileInfo;
-    if(fstat(fd, &fileInfo) != 0)
-        return false;
-
-    ffStrbufEnsureFree(buffer, fileInfo.st_size > 0 ? (uint32_t)fileInfo.st_size : 31);
-    uint32_t free = ffStrbufGetFree(buffer);
-
-    while(
-        (readed = read(fd, buffer->chars + buffer->length, free)) > 0 &&
-        (uint32_t) readed == free
-    ) {
-        buffer->length += (uint32_t) readed;
-        ffStrbufEnsureFree(buffer, buffer->allocated - 1); // Doubles capacity every round. -1 for the null byte.
-        free = ffStrbufGetFree(buffer);
-    }
-
-    // In case of failure, read returns -1. We don't want to substract the length of the buffer.
-    if(readed > 0)
-        buffer->length += (uint32_t) readed;
-
-    buffer->chars[buffer->length] = '\0';
-
-    ffStrbufTrimRight(buffer, '\n');
-    ffStrbufTrimRight(buffer, ' ');
-
-    return readed >= 0;
-}
-
-ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data)
-{
-    #ifdef _WIN32
-    HANDLE handle = CreateFileA(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-    if(handle == INVALID_HANDLE_VALUE)
-        return false;
-
-    DWORD readed;
-    if(!ReadFile(handle, data, (DWORD)dataSize, &readed, NULL))
-        return -1;
-
-    return (ssize_t)readed;
-    #else
-    int fd = open(fileName, O_RDONLY);
-    if(fd == -1)
-        return -1;
-
-    ssize_t readed = read(fd, data, dataSize);
-
-    close(fd);
-
-    return readed;
-    #endif
-}
-
-bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer)
-{
-    #ifdef _WIN32
-    HANDLE handle = CreateFileA(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-    if(handle == INVALID_HANDLE_VALUE)
-        return false;
-
-    bool ret = ffAppendHandleBuffer(handle, buffer);
-
-    CloseHandle(handle);
-    #else
-    int fd = open(fileName, O_RDONLY);
-    if(fd == -1)
-        return false;
-
-    bool ret = ffAppendFDBuffer(fd, buffer);
-
-    close(fd);
-    #endif
-
-    return ret;
-}
-
-bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer)
-{
-    ffStrbufClear(buffer);
-    return ffAppendFileBuffer(fileName, buffer);
-}
-
-// Not thread safe!
-void ffSuppressIO(bool suppress)
-{
-    static bool init = false;
-    static int origOut = -1;
-    static int origErr = -1;
-    static int nullFile = -1;
-
-    if(!init)
-    {
-        if(!suppress)
-            return;
-
-        origOut = dup(STDOUT_FILENO);
-        origErr = dup(STDERR_FILENO);
-        nullFile = open("/dev/null", O_WRONLY);
-        init = true;
-    }
-
-    if(nullFile == -1)
-        return;
-
-    fflush(stdout);
-    fflush(stderr);
-
-    dup2(suppress ? nullFile : origOut, STDOUT_FILENO);
-    dup2(suppress ? nullFile : origErr, STDERR_FILENO);
-}
-
-bool ffFileExists(const char* fileName, mode_t mode)
-{
-    struct stat fileStat;
-    return stat(fileName, &fileStat) == 0 && ((fileStat.st_mode & S_IFMT) == mode);
-}
-
-void ffGetTerminalResponse(const char* request, const char* format, ...)
-{
-    #ifndef WIN32
-    struct termios oldTerm, newTerm;
-    if(tcgetattr(STDIN_FILENO, &oldTerm) == -1)
-        return;
-
-    newTerm = oldTerm;
-    newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
-    if(tcsetattr(STDIN_FILENO, TCSANOW, &newTerm) == -1)
-        return;
-
-    fputs(request, stdout);
-    fflush(stdout);
-
-    struct pollfd pfd;
-    pfd.fd = STDIN_FILENO;
-    pfd.events = POLLIN;
-    pfd.revents = 0;
-
-    //Give the terminal 35ms to respond
-    if(poll(&pfd, 1, 35) <= 0)
-    {
-        tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
-        return;
-    }
-
-    char buffer[512];
-    ssize_t readed = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
-
-    tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
-
-    if(readed <= 0)
-        return;
-
-    buffer[readed] = '\0';
-
-    va_list args;
-    va_start(args, format);
-    vsscanf(buffer, format, args);
-    va_end(args);
-    #else
-    //Unimplemented
-    FF_UNUSED(request, format);
-    #endif
-}

src/common/io.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#ifndef FF_INCLUDED_common_io
-#define FF_INCLUDED_common_io
-
-#include "fastfetch.h"
-
-#include <sys/stat.h> //mode_t, fstat, stat
-
-bool ffWriteFDBuffer(int fd, const FFstrbuf* content);
-bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data);
-bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer);
-
-bool ffAppendFDBuffer(int fd, FFstrbuf* buffer);
-ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data);
-bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer);
-bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer);
-
-#ifdef _WIN32
-bool ffAppendHandleBuffer(HANDLE handle, FFstrbuf* buffer);
-#endif
-
-bool ffFileExists(const char* fileName, mode_t mode);
-
-// Not thread safe!
-void ffSuppressIO(bool suppress);
-
-FF_C_SCANF(2, 3) void ffGetTerminalResponse(const char* request, const char* format, ...);
-
-#endif

src/common/io/io.h

@@ -0,0 +1,157 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_io_io
+#define FF_INCLUDED_common_io_io
+
+#include "util/FFstrbuf.h"
+
+#ifdef _WIN32
+    #include <fileapi.h>
+    #include <handleapi.h>
+    #include <io.h>
+    typedef HANDLE FFNativeFD;
+#else
+    #include <unistd.h>
+    #include <dirent.h>
+    typedef int FFNativeFD;
+#endif
+
+static inline FFNativeFD FFUnixFD2NativeFD(int unixfd)
+{
+    #ifndef _WIN32
+        return unixfd;
+    #else
+        return (FFNativeFD) _get_osfhandle(unixfd);
+    #endif
+}
+
+static inline bool ffWriteFDData(FFNativeFD fd, size_t dataSize, const void* data)
+{
+    #ifndef _WIN32
+        return write(fd, data, dataSize) != -1;
+    #else
+        DWORD written;
+        return WriteFile(fd, data, (DWORD) dataSize, &written, NULL) && written == dataSize;
+    #endif
+}
+
+static inline bool ffWriteFDBuffer(FFNativeFD fd, const FFstrbuf* content)
+{
+    return ffWriteFDData(fd, content->length, content->chars);
+}
+
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data);
+
+static inline bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer)
+{
+    return ffWriteFileData(fileName, buffer->length, buffer->chars);
+}
+
+static inline ssize_t ffReadFDData(FFNativeFD fd, size_t dataSize, void* data)
+{
+    #ifndef _WIN32
+        return read(fd, data, dataSize);
+    #else
+        DWORD readed;
+        if(!ReadFile(fd, data, (DWORD)dataSize, &readed, NULL))
+            return -1;
+
+        return (ssize_t)readed;
+    #endif
+}
+
+ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data);
+
+bool ffAppendFDBuffer(FFNativeFD fd, FFstrbuf* buffer);
+bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer);
+
+static inline bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer)
+{
+    ffStrbufClear(buffer);
+    return ffAppendFileBuffer(fileName, buffer);
+}
+
+//Bit flags, combine with |
+typedef enum FFPathType
+{
+    FF_PATHTYPE_REGULAR = 1,
+    FF_PATHTYPE_LINK = 2,
+    FF_PATHTYPE_DIRECTORY = 4
+} FFPathType;
+
+#define FF_PATHTYPE_FILE (FF_PATHTYPE_REGULAR | FF_PATHTYPE_LINK)
+#define FF_PATHTYPE_ANY (FF_PATHTYPE_FILE | FF_PATHTYPE_DIRECTORY)
+
+bool ffPathExists(const char* path, FFPathType pathType);
+bool ffPathExpandEnv(const char* in, FFstrbuf* out);
+
+#define FF_IO_TERM_RESP_WAIT_MS 100 // #554
+
+FF_C_SCANF(2, 3)
+const char* ffGetTerminalResponse(const char* request, const char* format, ...);
+
+// Not thread safe!
+bool ffSuppressIO(bool suppress);
+
+static inline void ffUnsuppressIO(bool* suppressed)
+{
+    if (!*suppressed) return;
+    ffSuppressIO(false);
+    *suppressed = false;
+}
+
+#define FF_SUPPRESS_IO() bool __attribute__((__cleanup__(ffUnsuppressIO), __unused__)) io_suppressed__ = ffSuppressIO(true)
+
+void ffListFilesRecursively(const char* path);
+
+static inline bool wrapClose(FFNativeFD* pfd)
+{
+    assert(pfd);
+
+    #ifndef WIN32
+        if (*pfd < 0)
+            return false;
+        close(*pfd);
+    #else
+        // https://devblogs.microsoft.com/oldnewthing/20040302-00/?p=40443
+        if (*pfd == NULL || *pfd == INVALID_HANDLE_VALUE)
+            return false;
+        CloseHandle(*pfd);
+    #endif
+
+    return true;
+}
+#define FF_AUTO_CLOSE_FD __attribute__((__cleanup__(wrapClose)))
+
+static inline bool wrapFclose(FILE** pfile)
+{
+    assert(pfile);
+    if (!*pfile)
+        return false;
+    fclose(*pfile);
+    return true;
+}
+#define FF_AUTO_CLOSE_FILE __attribute__((__cleanup__(wrapFclose)))
+
+#ifndef _WIN32
+static inline bool wrapClosedir(DIR** pdir)
+{
+    assert(pdir);
+    if (!*pdir)
+        return false;
+    closedir(*pdir);
+    return true;
+}
+#else
+static inline bool wrapClosedir(HANDLE* pdir)
+{
+    assert(pdir);
+    if (!*pdir)
+        return false;
+    FindClose(*pdir);
+    return true;
+}
+#endif
+#define FF_AUTO_CLOSE_DIR __attribute__((__cleanup__(wrapClosedir)))
+
+#endif // FF_INCLUDED_common_io_io

src/common/io/io_unix.c

@@ -0,0 +1,243 @@
+#include "io.h"
+#include "util/stringUtils.h"
+#include "util/unused.h"
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <termios.h>
+#include <poll.h>
+#include <dirent.h>
+
+#if __has_include(<wordexp.h>)
+#include <wordexp.h>
+#endif
+
+static void createSubfolders(const char* fileName)
+{
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
+
+    while(*fileName != '\0')
+    {
+        ffStrbufAppendC(&path, *fileName);
+        if(*fileName == '/')
+            mkdir(path.chars, S_IRWXU | S_IRGRP | S_IROTH);
+        ++fileName;
+    }
+}
+
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data)
+{
+    int openFlagsModes = O_WRONLY | O_CREAT | O_TRUNC;
+    int openFlagsRights = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+
+    int FF_AUTO_CLOSE_FD fd = open(fileName, openFlagsModes, openFlagsRights);
+    if(fd == -1)
+    {
+        createSubfolders(fileName);
+        fd = open(fileName, openFlagsModes, openFlagsRights);
+        if(fd == -1)
+            return false;
+    }
+
+    return write(fd, data, dataSize) > 0;
+}
+
+bool ffAppendFDBuffer(int fd, FFstrbuf* buffer)
+{
+    ssize_t readed = 0;
+
+    struct stat fileInfo;
+    if(fstat(fd, &fileInfo) != 0)
+        return false;
+
+    ffStrbufEnsureFree(buffer, fileInfo.st_size > 0 ? (uint32_t)fileInfo.st_size : 31);
+    uint32_t free = ffStrbufGetFree(buffer);
+
+    while(
+        (readed = read(fd, buffer->chars + buffer->length, free)) > 0
+    ) {
+        buffer->length += (uint32_t) readed;
+        if((uint32_t) readed == free)
+            ffStrbufEnsureFree(buffer, buffer->allocated - 1); // Doubles capacity every round. -1 for the null byte.
+        free = ffStrbufGetFree(buffer);
+    }
+
+    buffer->chars[buffer->length] = '\0';
+
+    ffStrbufTrimRight(buffer, '\n');
+    ffStrbufTrimRight(buffer, ' ');
+
+    return buffer->length > 0;
+}
+
+ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data)
+{
+    int FF_AUTO_CLOSE_FD fd = open(fileName, O_RDONLY);
+    if(fd == -1)
+        return -1;
+
+    return ffReadFDData(fd, dataSize, data);
+}
+
+bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer)
+{
+    int FF_AUTO_CLOSE_FD fd = open(fileName, O_RDONLY);
+    if(fd == -1)
+        return false;
+
+    return ffAppendFDBuffer(fd, buffer);
+}
+
+bool ffPathExists(const char* path, FFPathType type)
+{
+    struct stat fileStat;
+    if(stat(path, &fileStat) != 0)
+        return false;
+
+    int mode = fileStat.st_mode & S_IFMT;
+
+    if(type & FF_PATHTYPE_REGULAR && mode == S_IFREG)
+        return true;
+
+    if(type & FF_PATHTYPE_DIRECTORY && mode == S_IFDIR)
+        return true;
+
+    if(type & FF_PATHTYPE_LINK && mode == S_IFLNK)
+        return true;
+
+    return false;
+}
+
+bool ffPathExpandEnv(FF_MAYBE_UNUSED const char* in, FF_MAYBE_UNUSED FFstrbuf* out)
+{
+    bool result = false;
+
+    #if __has_include(<wordexp.h>) // https://github.com/termux/termux-packages/pull/7056
+
+    wordexp_t exp;
+    if(wordexp(in, &exp, WRDE_NOCMD) != 0)
+        return false;
+
+    if (exp.we_wordc == 1)
+    {
+        result = true;
+        ffStrbufSetS(out, exp.we_wordv[0]);
+    }
+
+    wordfree(&exp);
+
+    #endif
+
+    return result;
+}
+
+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)
+    {
+        tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+        return "poll() timeout or failed";
+    }
+
+    char buffer[512];
+    ssize_t readed = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
+
+    tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+
+    if(readed <= 0)
+        return "read(STDIN_FILENO, buffer, sizeof(buffer) - 1) failed";
+
+    buffer[readed] = '\0';
+
+    va_list args;
+    va_start(args, format);
+    vsscanf(buffer, format, args);
+    va_end(args);
+
+    return NULL;
+}
+
+bool ffSuppressIO(bool suppress)
+{
+    static bool init = false;
+    static int origOut = -1;
+    static int origErr = -1;
+    static int nullFile = -1;
+
+    if(!init)
+    {
+        if(!suppress)
+            return true;
+
+        origOut = dup(STDOUT_FILENO);
+        origErr = dup(STDERR_FILENO);
+        nullFile = open("/dev/null", O_WRONLY);
+        init = true;
+    }
+
+    if(nullFile == -1)
+        return false;
+
+    fflush(stdout);
+    fflush(stderr);
+
+    dup2(suppress ? nullFile : origOut, STDOUT_FILENO);
+    dup2(suppress ? nullFile : origErr, STDERR_FILENO);
+    return true;
+}
+
+void listFilesRecursively(FFstrbuf* folder, uint8_t indentation, const char* folderName)
+{
+    DIR* dir = opendir(folder->chars);
+    if(dir == NULL)
+        return;
+
+    uint32_t folderLength = folder->length;
+
+    if(folderName != NULL)
+        printf("%s/\n", folderName);
+
+    struct dirent* entry;
+
+    while((entry = readdir(dir)) != NULL)
+    {
+        if(entry->d_type == DT_DIR)
+        {
+            if(ffStrEquals(entry->d_name, ".") || ffStrEquals(entry->d_name, ".."))
+                continue;
+
+            ffStrbufAppendS(folder, entry->d_name);
+            ffStrbufAppendC(folder, '/');
+            listFilesRecursively(folder, (uint8_t) (indentation + 1), entry->d_name);
+            ffStrbufSubstrBefore(folder, folderLength);
+            continue;
+        }
+
+        for(uint8_t i = 0; i < indentation; i++)
+            fputs("  | ", stdout);
+
+        puts(entry->d_name);
+    }
+
+    closedir(dir);
+}
+
+void ffListFilesRecursively(const char* path)
+{
+    FF_STRBUF_AUTO_DESTROY folder = ffStrbufCreateS(path);
+    ffStrbufEnsureEndsWithC(&folder, '/');
+    listFilesRecursively(&folder, 0, NULL);
+}

src/common/io/io_windows.c

@@ -0,0 +1,213 @@
+#include "io.h"
+#include "util/stringUtils.h"
+
+#include <windows.h>
+
+static void createSubfolders(const char* fileName)
+{
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
+    while(*fileName != '\0')
+    {
+        ffStrbufAppendC(&path, *fileName);
+        if(*fileName == '/')
+            CreateDirectoryA(path.chars, NULL);
+        ++fileName;
+    }
+}
+
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data)
+{
+    HANDLE FF_AUTO_CLOSE_FD handle = CreateFileA(fileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+    if(handle == INVALID_HANDLE_VALUE)
+    {
+        createSubfolders(fileName);
+        handle = CreateFileA(fileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+        if(handle == INVALID_HANDLE_VALUE)
+            return false;
+    }
+
+    DWORD written;
+    return !!WriteFile(handle, data, (DWORD)dataSize, &written, NULL);
+}
+
+bool ffAppendFDBuffer(HANDLE handle, FFstrbuf* buffer)
+{
+    DWORD readed = 0;
+
+    LARGE_INTEGER fileSize;
+    if(!GetFileSizeEx(handle, &fileSize))
+        fileSize.QuadPart = 0;
+
+    ffStrbufEnsureFree(buffer, fileSize.QuadPart > 0 ? (uint32_t)fileSize.QuadPart : 31);
+    uint32_t free = ffStrbufGetFree(buffer);
+
+    bool success;
+    while(
+        (success = !!ReadFile(handle, buffer->chars + buffer->length, free, &readed, NULL)) &&
+        readed > 0
+    ) {
+        buffer->length += (uint32_t) readed;
+        if((uint32_t) readed == free)
+            ffStrbufEnsureFree(buffer, buffer->allocated - 1); // Doubles capacity every round. -1 for the null byte.
+        free = ffStrbufGetFree(buffer);
+    }
+
+    buffer->chars[buffer->length] = '\0';
+
+    ffStrbufTrimRight(buffer, '\n');
+    ffStrbufTrimRight(buffer, ' ');
+
+    return success;
+}
+
+ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data)
+{
+    HANDLE FF_AUTO_CLOSE_FD handle = CreateFileA(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if(handle == INVALID_HANDLE_VALUE)
+        return -1;
+
+    return ffReadFDData(handle, dataSize, data);
+}
+
+bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer)
+{
+    HANDLE FF_AUTO_CLOSE_FD handle = CreateFileA(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if(handle == INVALID_HANDLE_VALUE)
+        return false;
+
+    return ffAppendFDBuffer(handle, buffer);
+}
+
+bool ffPathExists(const char* path, FFPathType type)
+{
+    DWORD attr = GetFileAttributesA(path);
+    if(attr == INVALID_FILE_ATTRIBUTES)
+        return false;
+
+    if(type & FF_PATHTYPE_REGULAR && !(attr & FILE_ATTRIBUTE_DIRECTORY))
+        return true;
+
+    if(type & FF_PATHTYPE_DIRECTORY && (attr & FILE_ATTRIBUTE_DIRECTORY))
+        return true;
+
+    if(type & FF_PATHTYPE_LINK && (attr & FILE_ATTRIBUTE_REPARSE_POINT))
+        return true;
+
+    return false;
+}
+
+bool ffPathExpandEnv(const char* in, FFstrbuf* out)
+{
+    DWORD length = ExpandEnvironmentStringsA(in, NULL, 0);
+    if (length <= 1) return false;
+
+    ffStrbufClear(out);
+    ffStrbufEnsureFree(out, (uint32_t)length);
+    ExpandEnvironmentStringsA(in, out->chars, length);
+    out->length = (uint32_t)length - 1;
+    return true;
+}
+
+bool ffSuppressIO(bool suppress)
+{
+    (void) suppress; //Not implemented.
+    return false;
+}
+
+void listFilesRecursively(FFstrbuf* folder, uint8_t indentation, const char* folderName)
+{
+    uint32_t folderLength = folder->length;
+
+    if(folderName != NULL)
+        printf("%s/\n", folderName);
+
+    ffStrbufAppendC(folder, '*');
+    WIN32_FIND_DATAA entry;
+    HANDLE hFind = FindFirstFileA(folder->chars, &entry);
+    if(hFind == INVALID_HANDLE_VALUE)
+        return;
+
+    do
+    {
+        if (entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+        {
+            if(ffStrEquals(entry.cFileName, ".") || ffStrEquals(entry.cFileName, ".."))
+                continue;
+
+            ffStrbufSubstrBefore(folder, folderLength);
+            ffStrbufAppendS(folder, entry.cFileName);
+            ffStrbufAppendC(folder, '/');
+            listFilesRecursively(folder, (uint8_t) (indentation + 1), entry.cFileName);
+            ffStrbufSubstrBefore(folder, folderLength);
+            continue;
+        }
+
+        for(uint8_t i = 0; i < indentation; i++)
+            fputs("  | ", stdout);
+
+        puts(entry.cFileName);
+    } while (FindNextFileA(hFind, &entry));
+    FindClose(hFind);
+}
+
+void ffListFilesRecursively(const char* path)
+{
+    FF_STRBUF_AUTO_DESTROY folder = ffStrbufCreateS(path);
+    ffStrbufEnsureEndsWithC(&folder, '/');
+    listFilesRecursively(&folder, 0, NULL);
+}
+
+const char* ffGetTerminalResponse(const char* request, const char* format, ...)
+{
+    HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
+    DWORD prev_mode;
+    GetConsoleMode(hInput, &prev_mode);
+    SetConsoleMode(hInput, 0);
+
+    FlushConsoleInputBuffer(hInput);
+
+    DWORD bytes = 0;
+    WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), 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);
+            return "WaitForSingleObject() failed or timeout";
+        }
+
+        // Ignore all unexpected input events
+        INPUT_RECORD record;
+        DWORD len = 0;
+        if (!PeekConsoleInputW(hInput, &record, 1, &len))
+            break;
+
+        if (
+            record.EventType == KEY_EVENT &&
+            record.Event.KeyEvent.uChar.UnicodeChar != L'\r' &&
+            record.Event.KeyEvent.uChar.UnicodeChar != L'\n'
+        )
+            break;
+        else
+            ReadConsoleInputW(hInput, &record, 1, &len);
+    }
+
+    char buffer[512];
+    bytes = 0;
+    ReadFile(hInput, buffer, sizeof(buffer) - 1, &bytes, NULL);
+
+    SetConsoleMode(hInput, prev_mode);
+
+    if(bytes <= 0)
+        return "ReadFile() failed";
+
+    buffer[bytes] = '\0';
+
+    va_list args;
+    va_start(args, format);
+    vsscanf(buffer, format, args);
+    va_end(args);
+
+    return NULL;
+}

src/common/jsonconfig.c

@@ -0,0 +1,240 @@
+#include "fastfetch.h"
+#include "common/jsonconfig.h"
+#include "common/printing.h"
+#include "common/io/io.h"
+#include "common/time.h"
+#include "modules/modules.h"
+#include "util/stringUtils.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* moduleArgs)
+{
+    if(ffStrEqualsIgnCase(key, "key"))
+    {
+        ffStrbufSetNS(&moduleArgs->key, (uint32_t) yyjson_get_len(val), yyjson_get_str(val));
+        return true;
+    }
+    else if(ffStrEqualsIgnCase(key, "format"))
+    {
+        ffStrbufSetNS(&moduleArgs->outputFormat, (uint32_t) yyjson_get_len(val), yyjson_get_str(val));
+        return true;
+    }
+    else if(ffStrEqualsIgnCase(key, "keyColor"))
+    {
+        ffOptionParseColor(yyjson_get_str(val), &moduleArgs->keyColor);
+        return true;
+    }
+    else if(ffStrEqualsIgnCase(key, "keyWidth"))
+    {
+        moduleArgs->keyWidth = (uint32_t) yyjson_get_uint(val);
+        return true;
+    }
+    return false;
+}
+
+void ffJsonConfigGenerateModuleArgsConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFModuleArgs* defaultModuleArgs, FFModuleArgs* moduleArgs)
+{
+    if (!ffStrbufEqual(&defaultModuleArgs->key, &moduleArgs->key))
+        yyjson_mut_obj_add_strbuf(doc, module, "key", &moduleArgs->key);
+    if (!ffStrbufEqual(&defaultModuleArgs->outputFormat, &moduleArgs->outputFormat))
+        yyjson_mut_obj_add_strbuf(doc, module, "format", &moduleArgs->outputFormat);
+    if (!ffStrbufEqual(&defaultModuleArgs->keyColor, &moduleArgs->keyColor))
+        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);
+}
+
+const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair pairs[])
+{
+    if (yyjson_is_int(val))
+    {
+        int intVal = yyjson_get_int(val);
+
+        for (const FFKeyValuePair* pPair = pairs; pPair->key; ++pPair)
+        {
+            if (intVal == pPair->value)
+            {
+                *result = pPair->value;
+                return NULL;
+            }
+        }
+
+        return "Invalid enum integer";
+    }
+    else if (yyjson_is_str(val))
+    {
+        const char* strVal = yyjson_get_str(val);
+        for (const FFKeyValuePair* pPair = pairs; pPair->key; ++pPair)
+        {
+            if (ffStrEqualsIgnCase(strVal, pPair->key))
+            {
+                *result = pPair->value;
+                return NULL;
+            }
+        }
+
+        return "Invalid enum string";
+    }
+    else
+        return "Invalid enum value type; must be a string or integer";
+}
+
+static inline void genJsonResult(FFModuleBaseInfo* baseInfo, yyjson_mut_doc* doc)
+{
+    yyjson_mut_val* module = yyjson_mut_arr_add_obj(doc, doc->root);
+    yyjson_mut_obj_add_str(doc, module, "type", baseInfo->name);
+    if (baseInfo->generateJsonResult)
+        baseInfo->generateJsonResult(baseInfo, doc, module);
+    else
+        yyjson_mut_obj_add_str(doc, module, "error", "Unsupported for JSON format");
+}
+
+static bool parseModuleJsonObject(const char* type, yyjson_val* jsonVal, yyjson_mut_doc* jsonDoc)
+{
+    if(!isalpha(type[0])) return false;
+
+    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(type[0]) - 'A']; *modules; ++modules)
+    {
+        FFModuleBaseInfo* baseInfo = *modules;
+        if (ffStrEqualsIgnCase(type, baseInfo->name))
+        {
+            if (jsonVal) baseInfo->parseJsonObject(baseInfo, jsonVal);
+            if (__builtin_expect(jsonDoc != NULL, false))
+                genJsonResult(baseInfo, jsonDoc);
+            else
+                baseInfo->printModule(baseInfo);
+            return true;
+        }
+    }
+    return false;
+}
+
+static void prepareModuleJsonObject(const char* type, yyjson_val* module)
+{
+    FFconfig* cfg = &instance.config;
+    switch (type[0])
+    {
+        case 'b': case 'B': {
+            if (ffStrEqualsIgnCase(type, FF_CPUUSAGE_MODULE_NAME))
+                ffPrepareCPUUsage();
+            break;
+        }
+        case 'd': case 'D': {
+            if (ffStrEqualsIgnCase(type, FF_DISKIO_MODULE_NAME))
+            {
+                if (module) cfg->modules.diskIo.moduleInfo.parseJsonObject(&cfg->modules.diskIo, module);
+                ffPrepareDiskIO(&cfg->modules.diskIo);
+            }
+            break;
+        }
+        case 'n': case 'N': {
+            if (ffStrEqualsIgnCase(type, FF_NETIO_MODULE_NAME))
+            {
+                if (module) cfg->modules.netIo.moduleInfo.parseJsonObject(&cfg->modules.netIo, module);
+                ffPrepareNetIO(&cfg->modules.netIo);
+            }
+            break;
+        }
+        case 'p': case 'P': {
+            if (ffStrEqualsIgnCase(type, FF_PUBLICIP_MODULE_NAME))
+            {
+                if (module) cfg->modules.publicIP.moduleInfo.parseJsonObject(&cfg->modules.publicIP, module);
+                ffPreparePublicIp(&cfg->modules.publicIP);
+            }
+            break;
+        }
+        case 'w': case 'W': {
+            if (ffStrEqualsIgnCase(type, FF_WEATHER_MODULE_NAME))
+            {
+                if (module) cfg->modules.weather.moduleInfo.parseJsonObject(&cfg->modules.weather, module);
+                ffPrepareWeather(&cfg->modules.weather);
+            }
+            break;
+        }
+    }
+}
+
+static const char* printJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
+{
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
+    assert(root);
+
+    if (!yyjson_is_obj(root))
+        return "Invalid JSON config format. Root value must be an object";
+
+    yyjson_val* modules = yyjson_obj_get(root, "modules");
+    if (!modules) return NULL;
+    if (!yyjson_is_arr(modules)) return "Property 'modules' must be an array of strings or objects";
+
+    yyjson_val* item;
+    size_t idx, max;
+    yyjson_arr_foreach(modules, idx, max, item)
+    {
+        uint64_t ms = 0;
+        if(!prepare && instance.config.display.stat)
+            ms = ffTimeGetTick();
+
+        yyjson_val* module = item;
+        const char* type = yyjson_get_str(module);
+        if (type)
+            module = NULL;
+        else if (yyjson_is_obj(module))
+        {
+            type = yyjson_get_str(yyjson_obj_get(module, "type"));
+            if (!type) return "module object must contain a \"type\" key ( case sensitive )";
+            if (yyjson_obj_size(module) == 1) // contains only Property type
+                module = NULL;
+        }
+        else
+            return "modules must be an array of strings or objects";
+
+        if(prepare)
+            prepareModuleJsonObject(type, module);
+        else if(!parseModuleJsonObject(type, module, jsonDoc))
+            return "Unknown module type";
+
+        if(!prepare && instance.config.display.stat)
+        {
+            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);
+            }
+            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
+            }
+        }
+
+        #if defined(_WIN32)
+        if (!instance.config.display.noBuffer && !jsonDoc) fflush(stdout);
+        #endif
+    }
+
+    return NULL;
+}
+
+void ffPrintJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
+{
+    const char* error = printJsonConfig(prepare, jsonDoc);
+    if (error)
+    {
+        if (jsonDoc)
+        {
+            yyjson_mut_val* obj = yyjson_mut_obj(jsonDoc);
+            yyjson_mut_obj_add_str(jsonDoc, obj, "error", error);
+            yyjson_mut_doc_set_root(jsonDoc, obj);
+        }
+        else
+            ffPrintErrorString("JsonConfig", 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "%s", error);
+    }
+}

src/common/jsonconfig.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "fastfetch.h"
+
+bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* moduleArgs);
+const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair pairs[]);
+void ffPrintJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc);
+void ffJsonConfigGenerateModuleArgsConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFModuleArgs* defaultModuleArgs, FFModuleArgs* moduleArgs);
+
+yyjson_api_inline yyjson_mut_val* yyjson_mut_strbuf(yyjson_mut_doc *doc, const FFstrbuf* buf) {
+    return yyjson_mut_strncpy(doc, buf->chars, buf->length);
+}
+
+yyjson_api_inline bool yyjson_mut_obj_add_strbuf(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *obj,
+                                                  const char *_key,
+                                                  const FFstrbuf* buf) {
+    return yyjson_mut_obj_add_strncpy(doc, obj, _key, buf->chars, buf->length);
+}
+
+yyjson_api_inline bool yyjson_mut_arr_add_strbuf(yyjson_mut_doc *doc,
+                                                  yyjson_mut_val *obj,
+                                                  const FFstrbuf* buf) {
+    return yyjson_mut_arr_add_strncpy(doc, obj, buf->chars, buf->length);
+}

src/common/library.c

@@ -32,8 +32,7 @@ static void* libraryLoad(const char* path, int maxVersion)
     if(result != NULL || maxVersion < 0)
         return result;
 
-    FFstrbuf pathbuf;
-    ffStrbufInitA(&pathbuf, 64);
+    FF_STRBUF_AUTO_DESTROY pathbuf = ffStrbufCreateA(64);
     ffStrbufAppendS(&pathbuf, path);
     ffStrbufAppendC(&pathbuf, '.');
 
@@ -49,8 +48,6 @@ static void* libraryLoad(const char* path, int maxVersion)
         ffStrbufSubstrBefore(&pathbuf, originalLength);
     }
 
-    ffStrbufDestroy(&pathbuf);
-
     #endif
 
     return result;

src/common/library.h

@@ -6,11 +6,11 @@
 #include "fastfetch.h"
 #include "util/FFcheckmacros.h"
 
-#if defined(_WIN32) //We don't force MSYS using LoadLibrary because dlopen also searches $LD_LIBRARY_PATH
+#if defined(_WIN32)
     #include <libloaderapi.h>
     #define FF_DLOPEN_FLAGS 0
     FF_C_NODISCARD static inline void* dlopen(const char* path, int mode) { FF_UNUSED(mode); return LoadLibraryA(path); }
-    FF_C_NODISCARD static inline void* dlsym(void* handle, const char* symbol) { return GetProcAddress((HMODULE)handle, symbol); }
+    FF_C_NODISCARD static inline void* dlsym(void* handle, const char* symbol) { return (void*) GetProcAddress((HMODULE)handle, symbol); }
     static inline int dlclose(void* handle) { return !FreeLibrary((HMODULE)handle); }
 #else
     #include <dlfcn.h>
@@ -24,39 +24,54 @@
     #define FF_LIBRARY_EXTENSION ".so"
 #endif
 
+static inline void ffLibraryUnload(void** handle)
+{
+    assert(handle);
+    if (*handle)
+        dlclose(*handle);
+}
+
 #define FF_LIBRARY_SYMBOL(symbolName) \
     __typeof__(&symbolName) ff ## symbolName;
 
 #define FF_LIBRARY_LOAD(libraryObjectName, userLibraryName, returnValue, ...) \
-    void* libraryObjectName = ffLibraryLoad(userLibraryName, __VA_ARGS__, NULL);\
+    void* __attribute__((__cleanup__(ffLibraryUnload))) libraryObjectName = ffLibraryLoad(userLibraryName, __VA_ARGS__, NULL);\
     if(libraryObjectName == NULL) \
         return returnValue;
 
 #define FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, symbolMapping, symbolName, returnValue) \
-    symbolMapping = dlsym(library, #symbolName); \
+    symbolMapping = (__typeof__(&symbolName)) dlsym(library, #symbolName); \
     if(symbolMapping == NULL) \
-    { \
-        dlclose(library); \
-        return returnValue; \
-    }
+        return returnValue;
+
+#define FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, symbolMapping, symbolName, alternateName, returnValue) \
+    symbolMapping = dlsym(library, #symbolName); \
+    if(symbolMapping == NULL && !(symbolMapping = (__typeof__(&symbolName)) dlsym(library, #alternateName))) \
+        return returnValue;
 
 #define FF_LIBRARY_LOAD_SYMBOL(library, symbolName, returnValue) \
     __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, ff ## symbolName, symbolName, returnValue);
 
 #define FF_LIBRARY_LOAD_SYMBOL_LAZY(library, symbolName) \
-    __typeof__(&symbolName) ff ## symbolName = dlsym(library, #symbolName);
+    __typeof__(&symbolName) ff ## symbolName = (__typeof__(&symbolName)) dlsym(library, #symbolName);
 
 #define FF_LIBRARY_LOAD_SYMBOL_MESSAGE(library, symbolName) \
     __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
 
+#define FF_LIBRARY_LOAD_SYMBOL_MESSAGE2(library, symbolName, alternateName) \
+    __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);
+    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");
+    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);
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName)->ff ## symbolName, symbolName, returnValue);
 
 void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
 

src/common/modules.c

@@ -0,0 +1,166 @@
+#include "fastfetch.h"
+
+static FFModuleBaseInfo* A[] = {
+    NULL,
+};
+
+static FFModuleBaseInfo* B[] = {
+    (void*) &instance.config.modules.battery,
+    (void*) &instance.config.modules.bios,
+    (void*) &instance.config.modules.bluetooth,
+    (void*) &instance.config.modules.board,
+    (void*) &instance.config.modules.break_,
+    (void*) &instance.config.modules.brightness,
+    NULL,
+};
+
+static FFModuleBaseInfo* C[] = {
+    (void*) &instance.config.modules.chassis,
+    (void*) &instance.config.modules.command,
+    (void*) &instance.config.modules.colors,
+    (void*) &instance.config.modules.cpu,
+    (void*) &instance.config.modules.cpuUsage,
+    (void*) &instance.config.modules.cursor,
+    (void*) &instance.config.modules.custom,
+    NULL,
+};
+
+static FFModuleBaseInfo* D[] = {
+    (void*) &instance.config.modules.dateTime,
+    (void*) &instance.config.modules.de,
+    (void*) &instance.config.modules.display,
+    (void*) &instance.config.modules.disk,
+    (void*) &instance.config.modules.diskIo,
+    NULL,
+};
+
+static FFModuleBaseInfo* E[] = {
+    NULL,
+};
+
+static FFModuleBaseInfo* F[] = {
+    (void*) &instance.config.modules.font,
+    NULL,
+};
+
+static FFModuleBaseInfo* G[] = {
+    (void*) &instance.config.modules.gamepad,
+    (void*) &instance.config.modules.gpu,
+    NULL,
+};
+
+static FFModuleBaseInfo* H[] = {
+    (void*) &instance.config.modules.host,
+    NULL,
+};
+
+static FFModuleBaseInfo* I[] = {
+    (void*) &instance.config.modules.icons,
+    NULL,
+};
+
+static FFModuleBaseInfo* J[] = {
+    NULL,
+};
+
+static FFModuleBaseInfo* K[] = {
+    (void*) &instance.config.modules.kernel,
+    NULL,
+};
+
+static FFModuleBaseInfo* L[] = {
+    (void*) &instance.config.modules.lm,
+    (void*) &instance.config.modules.locale,
+    (void*) &instance.config.modules.localIP,
+    NULL,
+};
+
+static FFModuleBaseInfo* M[] = {
+    (void*) &instance.config.modules.media,
+    (void*) &instance.config.modules.memory,
+    (void*) &instance.config.modules.monitor,
+    NULL,
+};
+
+static FFModuleBaseInfo* N[] = {
+    (void*) &instance.config.modules.netIo,
+    NULL,
+};
+
+static FFModuleBaseInfo* O[] = {
+    (void*) &instance.config.modules.openCL,
+    (void*) &instance.config.modules.openGL,
+    (void*) &instance.config.modules.os,
+    NULL,
+};
+
+static FFModuleBaseInfo* P[] = {
+    (void*) &instance.config.modules.packages,
+    (void*) &instance.config.modules.player,
+    (void*) &instance.config.modules.powerAdapter,
+    (void*) &instance.config.modules.processes,
+    (void*) &instance.config.modules.publicIP,
+    NULL,
+};
+
+static FFModuleBaseInfo* Q[] = {
+    NULL,
+};
+
+static FFModuleBaseInfo* R[] = {
+    NULL,
+};
+
+static FFModuleBaseInfo* S[] = {
+    (void*) &instance.config.modules.separator,
+    (void*) &instance.config.modules.shell,
+    (void*) &instance.config.modules.sound,
+    (void*) &instance.config.modules.swap,
+    NULL,
+};
+
+static FFModuleBaseInfo* T[] = {
+    (void*) &instance.config.modules.terminal,
+    (void*) &instance.config.modules.terminalFont,
+    (void*) &instance.config.modules.terminalSize,
+    (void*) &instance.config.modules.title,
+    (void*) &instance.config.modules.theme,
+    NULL,
+};
+
+static FFModuleBaseInfo* U[] = {
+    (void*) &instance.config.modules.uptime,
+    (void*) &instance.config.modules.users,
+    NULL,
+};
+
+static FFModuleBaseInfo* V[] = {
+    (void*) &instance.config.modules.version,
+    (void*) &instance.config.modules.vulkan,
+    NULL,
+};
+
+static FFModuleBaseInfo* W[] = {
+    (void*) &instance.config.modules.wallpaper,
+    (void*) &instance.config.modules.weather,
+    (void*) &instance.config.modules.wm,
+    (void*) &instance.config.modules.wifi,
+    (void*) &instance.config.modules.wmTheme,
+    NULL,
+};
+
+static FFModuleBaseInfo* X[] = {
+    NULL,
+};
+
+static FFModuleBaseInfo* Y[] = {
+    NULL,
+};
+
+static FFModuleBaseInfo* Z[] = {
+    NULL,
+};
+
+FFModuleBaseInfo** ffModuleInfos[] = {
+    A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
+};

src/common/netif/netif.c

@@ -0,0 +1,30 @@
+#include "netif.h"
+
+#ifndef _WIN32
+    #include <net/if.h>
+#else
+    #define IF_NAMESIZE 16
+#endif
+
+bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex);
+enum { IF_INDEX_UNINITIALIZED = (uint32_t) -1, IF_INDEX_INVALID = (uint32_t) -2 };
+static uint32_t ifIndex = IF_INDEX_UNINITIALIZED;
+static char ifName[IF_NAMESIZE + 1];
+
+static inline void init()
+{
+    if (ifIndex == (uint32_t) IF_INDEX_UNINITIALIZED && !ffNetifGetDefaultRouteImpl(ifName, &ifIndex))
+        ifIndex = (uint32_t) IF_INDEX_INVALID;
+}
+
+const char* ffNetifGetDefaultRouteIfName()
+{
+    init();
+    return ifName;
+}
+
+uint32_t ffNetifGetDefaultRouteIfIndex()
+{
+    init();
+    return ifIndex;
+}

src/common/netif/netif.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "fastfetch.h"
+
+#ifndef _WIN32
+const char* ffNetifGetDefaultRouteIfName();
+#endif
+
+uint32_t ffNetifGetDefaultRouteIfIndex();

src/common/netif/netif_bsd.c

@@ -0,0 +1,98 @@
+#include "netif.h"
+
+#include "common/io/io.h"
+
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#define ROUNDUP2(a, n)       ((a) > 0 ? (1 + (((a) - 1U) | ((n) - 1))) : (n))
+
+#if defined(__APPLE__)
+# define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
+#elif defined(__NetBSD__)
+# define ROUNDUP(a)           ROUNDUP2((a), sizeof(uint64_t))
+#elif defined(__FreeBSD__)
+# define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
+#elif defined(__OpenBSD__)
+# define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
+#else
+# error unknown platform
+#endif
+
+static struct sockaddr *
+get_rt_address(struct rt_msghdr *rtm, int desired)
+{
+    struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
+
+    for (int i = 0; i < RTAX_MAX; i++)
+    {
+        if (rtm->rtm_addrs & (1 << i))
+        {
+            if ((1 <<i ) == desired)
+                return sa;
+            sa = (struct sockaddr *)(ROUNDUP(sa->sa_len) + (char *)sa);
+        }
+    }
+    return NULL;
+}
+
+bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
+{
+    //https://github.com/hashPirate/copenheimer-masscan-fork/blob/36f1ed9f7b751a7dccd5ed27874e2e703db7d481/src/rawsock-getif.c#L104
+
+    FF_AUTO_CLOSE_FD int pfRoute = socket(PF_ROUTE, SOCK_RAW, AF_INET);
+    if (pfRoute < 0)
+        return false;
+
+    {
+        struct timeval timeout = {1, 0};
+        setsockopt(pfRoute, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+        setsockopt(pfRoute, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
+    }
+
+    int pid = getpid();
+
+    struct {
+        struct rt_msghdr hdr;
+        struct sockaddr_in dst;
+        uint8_t data[512];
+    } rtmsg = {
+        .hdr = {
+            .rtm_type = RTM_GET,
+            .rtm_flags = RTF_UP | RTF_GATEWAY,
+            .rtm_version = RTM_VERSION,
+            .rtm_addrs = RTA_DST | RTA_IFP,
+            .rtm_msglen = sizeof(rtmsg.hdr) + sizeof(rtmsg.dst),
+            .rtm_pid = pid,
+            .rtm_seq = 1,
+        },
+        .dst = {
+            .sin_family = AF_INET,
+            .sin_len = sizeof(rtmsg.dst),
+        },
+    };
+
+    if (write(pfRoute, &rtmsg, rtmsg.hdr.rtm_msglen) != rtmsg.hdr.rtm_msglen)
+        return false;
+
+    while (read(pfRoute, &rtmsg, sizeof(rtmsg)) > 0)
+    {
+        if (rtmsg.hdr.rtm_seq == 1 && rtmsg.hdr.rtm_pid == pid)
+        {
+            struct sockaddr_dl* sdl = (struct sockaddr_dl *)get_rt_address(&rtmsg.hdr, RTA_IFP);
+            if (sdl)
+            {
+                assert(sdl->sdl_nlen <= IF_NAMESIZE);
+                memcpy(iface, sdl->sdl_data, sdl->sdl_nlen);
+                iface[sdl->sdl_nlen] = '\0';
+                *ifIndex = sdl->sdl_index;
+                return true;
+            }
+            return false;
+        }
+    }
+    return false;
+}

src/common/netif/netif_linux.c

@@ -0,0 +1,28 @@
+#include "netif.h"
+#include "common/io/io.h"
+
+#include <net/if.h>
+#include <stdio.h>
+
+#define FF_STR_INDIR(x) #x
+#define FF_STR(x) FF_STR_INDIR(x)
+
+bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
+{
+    FILE* FF_AUTO_CLOSE_FILE netRoute = fopen("/proc/net/route", "r");
+    if (!netRoute) return false;
+
+    // skip first line
+    flockfile(netRoute);
+    while (getc_unlocked(netRoute) != '\n');
+    funlockfile(netRoute);
+    unsigned long long destination; //, gateway, flags, refCount, use, metric, mask, mtu,
+
+    while (fscanf(netRoute, "%" FF_STR(IF_NAMESIZE) "s%llx%*[^\n]", iface, &destination) == 2)
+    {
+        if (destination != 0) continue;
+        *ifIndex = if_nametoindex(iface);
+        return true;
+    }
+    return false;
+}

src/common/netif/netif_windows.c

@@ -0,0 +1,27 @@
+#include "netif.h"
+#include "util/mallocHelper.h"
+
+#include <iphlpapi.h>
+
+bool ffNetifGetDefaultRouteImpl(FF_MAYBE_UNUSED char* iface/* unsupported */, uint32_t* ifIndex)
+{
+    ULONG size = 0;
+    if (GetIpForwardTable(NULL, &size, TRUE) != ERROR_INSUFFICIENT_BUFFER)
+        return false;
+
+    FF_AUTO_FREE MIB_IPFORWARDTABLE* pIpForwardTable = (MIB_IPFORWARDTABLE*) malloc(size);
+    if (GetIpForwardTable(pIpForwardTable, &size, TRUE) != ERROR_SUCCESS)
+        return false;
+
+    for (uint32_t i = 0; i < pIpForwardTable->dwNumEntries; ++i)
+    {
+        MIB_IPFORWARDROW* ipForwardRow = &pIpForwardTable->table[i];
+        if (ipForwardRow->dwForwardDest == 0 && ipForwardRow->dwForwardMask == 0)
+        {
+            *ifIndex = ipForwardRow->dwForwardIfIndex;
+            break;
+        }
+    }
+
+    return true;
+}

src/common/networking_linux.c

@@ -77,7 +77,8 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
 bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout)
 {
     #ifdef FF_HAVE_THREADS
-        ffThreadJoin(state->thread);
+        if (!ffThreadJoin(state->thread, timeout))
+            return false;
     #endif
     if(state->sockfd == -1)
         return false;
@@ -85,8 +86,8 @@ bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, ui
     if(timeout > 0)
     {
         struct timeval timev;
-        timev.tv_sec = 0;
-        timev.tv_usec = (__typeof__(timev.tv_usec)) (timeout * 1000); //milliseconds to microseconds
+        timev.tv_sec = timeout / 1000;
+        timev.tv_usec = (__typeof__(timev.tv_usec)) ((timeout % 1000) * 1000); //milliseconds to microseconds
         setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
     }
 

src/common/networking_windows.c

@@ -75,8 +75,7 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
         }
     }
 
-    FF_STRBUF_AUTO_DESTROY command;
-    ffStrbufInitA(&command, 64);
+    FF_STRBUF_AUTO_DESTROY command = ffStrbufCreateA(64);
     ffStrbufAppendS(&command, "GET ");
     ffStrbufAppendS(&command, path);
     ffStrbufAppendS(&command, " HTTP/1.1\nHost: ");

src/common/option.c

@@ -0,0 +1,191 @@
+#include "common/option.h"
+#include "common/color.h"
+#include "util/stringUtils.h"
+
+// Return start position of the inner key if the argument key belongs to the module specified, NULL otherwise
+const char* ffOptionTestPrefix(const char* argumentKey, const char* moduleName)
+{
+    const char* subKey = argumentKey;
+    if(!(subKey[0] == '-' && subKey[1] == '-'))
+        return NULL;
+
+    subKey += 2;
+    uint32_t moduleNameLen = (uint32_t)strlen(moduleName);
+    if(strncasecmp(subKey, moduleName, moduleNameLen) != 0)
+        return NULL;
+
+    subKey += moduleNameLen;
+
+    if(subKey[0] == '\0')
+        return subKey;
+
+    if(subKey[0] != '-')
+        return NULL;
+
+    subKey += 1;
+
+    return subKey;
+}
+
+bool ffOptionParseModuleArgs(const char* argumentKey, const char* subKey, const char* value, FFModuleArgs* result)
+{
+    if(ffStrEqualsIgnCase(subKey, "key"))
+    {
+        ffOptionParseString(argumentKey, value, &result->key);
+        return true;
+    }
+    else if(ffStrEqualsIgnCase(subKey, "format"))
+    {
+        ffOptionParseString(argumentKey, value, &result->outputFormat);
+        return true;
+    }
+    else if(ffStrEqualsIgnCase(subKey, "key-color"))
+    {
+        if(value == NULL)
+        {
+            fprintf(stderr, "Error: usage: %s <str>\n", argumentKey);
+            exit(477);
+        }
+        ffOptionParseColor(value, &result->keyColor);
+        return true;
+    }
+    else if(ffStrEqualsIgnCase(subKey, "key-width"))
+    {
+        result->keyWidth = ffOptionParseUInt32(argumentKey, value);
+        return true;
+    }
+    return false;
+}
+
+void ffOptionParseString(const char* argumentKey, const char* value, FFstrbuf* buffer)
+{
+    if(value == NULL)
+    {
+        fprintf(stderr, "Error: usage: %s <str>\n", argumentKey);
+        exit(477);
+    }
+
+    ffStrbufSetS(buffer, value);
+}
+
+uint32_t ffOptionParseUInt32(const char* argumentKey, const char* value)
+{
+    if(value == NULL)
+    {
+        fprintf(stderr, "Error: usage: %s <num>\n", argumentKey);
+        exit(480);
+    }
+
+    char* end;
+    uint32_t num = (uint32_t) strtoul(value, &end, 10);
+    if(*end != '\0')
+    {
+        fprintf(stderr, "Error: usage: %s <num>\n", argumentKey);
+        exit(479);
+    }
+
+    return num;
+}
+
+int32_t ffOptionParseInt32(const char* argumentKey, const char* value)
+{
+    if(value == NULL)
+    {
+        fprintf(stderr, "Error: usage: %s <num>\n", argumentKey);
+        exit(480);
+    }
+
+    char* end;
+    int32_t num = (int32_t) strtol(value, &end, 10);
+    if(*end != '\0')
+    {
+        fprintf(stderr, "Error: usage: %s <num>\n", argumentKey);
+        exit(479);
+    }
+
+    return num;
+}
+
+int ffOptionParseEnum(const char* argumentKey, const char* requestedKey, FFKeyValuePair pairs[])
+{
+    if(requestedKey == NULL)
+    {
+        fprintf(stderr, "Error: usage: %s <value>\n", argumentKey);
+        exit(476);
+    }
+
+    for (const FFKeyValuePair* pPair = pairs; pPair->key; ++pPair)
+    {
+        if(ffStrEqualsIgnCase(requestedKey, pPair->key))
+            return pPair->value;
+    }
+
+    fprintf(stderr, "Error: unknown %s value: %s\n", argumentKey, requestedKey);
+    exit(478);
+}
+
+bool ffOptionParseBoolean(const char* str)
+{
+    return (
+        !ffStrSet(str) ||
+        ffStrEqualsIgnCase(str, "true") ||
+        ffStrEqualsIgnCase(str, "yes")  ||
+        ffStrEqualsIgnCase(str, "on")   ||
+        ffStrEqualsIgnCase(str, "1")
+    );
+}
+
+void ffOptionParseColor(const char* value, FFstrbuf* buffer)
+{
+    ffStrbufClear(buffer);
+    ffStrbufEnsureFree(buffer, 63);
+
+    while(*value != '\0')
+    {
+        #define FF_APPEND_COLOR_CODE_COND(prefix, code) \
+            if(strncasecmp(value, #prefix, strlen(#prefix)) == 0) { ffStrbufAppendS(buffer, code); value += strlen(#prefix); }
+
+        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
+        {
+            ffStrbufAppendC(buffer, *value);
+            ++value;
+        }
+
+        #undef FF_APPEND_COLOR_CODE_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);
+}

src/common/option.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "util/FFstrbuf.h"
+
+struct yyjson_val;
+struct yyjson_mut_doc;
+struct yyjson_mut_val;
+
+// Must be the first field of FFModuleOptions
+typedef struct FFModuleBaseInfo
+{
+    const char* name;
+    // A dirty polymorphic implementation in C.
+    // This is UB, because `void*` is not compatible with `FF*Options*`.
+    // However we can't do it better unless we move to C++, so that `option` becomes a `this` pointer
+    // https://stackoverflow.com/questions/559581/casting-a-function-pointer-to-another-type
+    bool (*parseCommandOptions)(void* options, const char* key, const char* value);
+    void (*parseJsonObject)(void* options, struct yyjson_val *module);
+    void (*printModule)(void* options);
+    void (*generateJsonResult)(void* options, struct yyjson_mut_doc* doc, struct yyjson_mut_val* module);
+    void (*printHelpFormat)(void);
+    void (*generateJsonConfig)(void* options, struct yyjson_mut_doc* doc, struct yyjson_mut_val* obj);
+} FFModuleBaseInfo;
+
+static inline void ffOptionInitModuleBaseInfo(
+    FFModuleBaseInfo* baseInfo,
+    const char* name,
+    void* parseCommandOptions, // bool (*const parseCommandOptions)(void* options, const char* key, const char* value)
+    void* parseJsonObject, // void (*const parseJsonObject)(void* options, yyjson_val *module)
+    void* printModule, // void (*const printModule)(void* options)
+    void* generateJsonResult, // void (*const generateJsonResult)(void* options, yyjson_mut_doc* doc, yyjson_mut_val* obj)
+    void (*printHelpFormat)(void),
+    void* generateJsonConfig // void (*const generateJsonConfig)(void* options, yyjson_mut_doc* doc, yyjson_mut_val* obj)
+)
+{
+    baseInfo->name = name;
+    baseInfo->parseCommandOptions = (__typeof__(baseInfo->parseCommandOptions)) parseCommandOptions;
+    baseInfo->parseJsonObject = (__typeof__(baseInfo->parseJsonObject)) parseJsonObject;
+    baseInfo->printModule = (__typeof__(baseInfo->printModule)) printModule;
+    baseInfo->generateJsonResult = (__typeof__(baseInfo->generateJsonResult)) generateJsonResult;
+    baseInfo->printHelpFormat = printHelpFormat;
+    baseInfo->generateJsonConfig = (__typeof__(baseInfo->generateJsonConfig)) generateJsonConfig;
+}
+
+typedef struct FFModuleArgs
+{
+    FFstrbuf key;
+    FFstrbuf keyColor;
+    FFstrbuf outputFormat;
+    uint32_t keyWidth;
+} FFModuleArgs;
+
+typedef struct FFKeyValuePair
+{
+    const char* key;
+    int value;
+} FFKeyValuePair;
+
+const char* ffOptionTestPrefix(const char* argumentKey, const char* moduleName);
+bool ffOptionParseModuleArgs(const char* argumentKey, const char* pkey, const char* value, FFModuleArgs* result);
+void ffOptionParseString(const char* argumentKey, const char* value, FFstrbuf* buffer);
+FF_C_NODISCARD uint32_t ffOptionParseUInt32(const char* argumentKey, const char* value);
+FF_C_NODISCARD int32_t ffOptionParseInt32(const char* argumentKey, const char* value);
+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);

src/common/parsing.c

@@ -1,8 +1,14 @@
 #include "fastfetch.h"
 #include "common/parsing.h"
+
 #include <ctype.h>
 #include <inttypes.h>
 
+#ifdef _WIN32
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wformat"
+#endif
+
 void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch)
 {
     if(major->length > 0)
@@ -54,12 +60,12 @@ void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty)
         ffStrbufAppendF(pretty, ".%u", version->patch);
 }
 
-static void parseSize(FFstrbuf* result, uint64_t bytes, uint32_t base, uint8_t prefixesLength, const char** prefixes)
+static void parseSize(FFstrbuf* result, uint64_t bytes, uint32_t base, const char** prefixes)
 {
-    long double size = (long double) bytes;
+    double size = (double) bytes;
     uint8_t counter = 0;
 
-    while(size > base && counter < prefixesLength - 1)
+    while(size >= base && counter < instance.config.display.sizeMaxPrefix && prefixes[counter + 1])
     {
         size /= base;
         counter++;
@@ -67,22 +73,43 @@ static void parseSize(FFstrbuf* result, uint64_t bytes, uint32_t base, uint8_t p
 
     if(counter == 0)
         ffStrbufAppendF(result, "%"PRIu64" %s", bytes, prefixes[0]);
-    else if(counter < 3 || (counter == 3 && size < 100.0))
-        ffStrbufAppendF(result, "%.2Lf %s", size, prefixes[counter]);
     else
-        ffStrbufAppendF(result, "%.0Lf %s", size, prefixes[counter]);
+        ffStrbufAppendF(result, "%.*f %s", instance.config.display.sizeNdigits, size, prefixes[counter]);
 }
 
-void ffParseSize(uint64_t bytes, FFBinaryPrefixType binaryPrefix, FFstrbuf* result)
+void ffParseSize(uint64_t bytes, FFstrbuf* result)
 {
-    if(binaryPrefix == FF_BINARY_PREFIX_TYPE_IEC)
-        parseSize(result, bytes, 1024, 5, (const char*[]) {"B", "KiB", "MiB", "GiB", "TiB"});
-    else if(binaryPrefix == FF_BINARY_PREFIX_TYPE_SI)
-        parseSize(result, bytes, 1000, 5, (const char*[]) {"B", "kB", "MB", "GB", "TB"});
-    else if(binaryPrefix == FF_BINARY_PREFIX_TYPE_JEDEC)
-        parseSize(result, bytes, 1024, 5, (const char*[]) {"B", "KB", "MB", "GB", "TB"});
-    else
-        parseSize(result, bytes, 1024, 1, (const char*[]) {"B"});
+    switch (instance.config.display.binaryPrefixType)
+    {
+        case FF_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:
+            parseSize(result, bytes, 1000, (const char*[]) {"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", NULL});
+            break;
+        case FF_BINARY_PREFIX_TYPE_JEDEC:
+            parseSize(result, bytes, 1024, (const char*[]) {"B", "KB", "MB", "GB", "TB", NULL});
+            break;
+        default:
+            parseSize(result, bytes, 1024, (const char*[]) {"B", NULL});
+            break;
+    }
+}
+
+void ffParseTemperature(double celsius, FFstrbuf* buffer)
+{
+    switch (instance.config.display.temperatureUnit)
+    {
+        case FF_TEMPERATURE_UNIT_CELSIUS:
+            ffStrbufAppendF(buffer, "%.1f°C", celsius);
+            break;
+        case FF_TEMPERATURE_UNIT_FAHRENHEIT:
+            ffStrbufAppendF(buffer, "%.1f°F", celsius * 1.8 + 32);
+            break;
+        case FF_TEMPERATURE_UNIT_KELVIN:
+            ffStrbufAppendF(buffer, "%.1f K", celsius + 273.15);
+            break;
+    }
 }
 
 void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
@@ -164,3 +191,7 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
         ffStrbufAppendS(buffer, " [GTK4]");
     }
 }
+
+#ifdef _WIN32
+    #pragma GCC diagnostic pop
+#endif

src/common/parsing.h

@@ -3,6 +3,8 @@
 #ifndef FF_INCLUDED_parsing_h
 #define FF_INCLUDED_parsing_h
 
+#include "fastfetch.h"
+
 #include <stdint.h>
 
 typedef struct FFVersion
@@ -20,6 +22,7 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
 void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty);
 int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2);
 
-void ffParseSize(uint64_t bytes, FFBinaryPrefixType binaryPrefix, FFstrbuf* result);
+void ffParseSize(uint64_t bytes, FFstrbuf* result);
+void ffParseTemperature(double celsius, FFstrbuf* buffer);
 
 #endif

src/common/printing.c

@@ -2,22 +2,32 @@
 #include "common/printing.h"
 #include "util/textModifier.h"
 
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
+void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType)
 {
-    ffLogoPrintLine(instance);
+    ffLogoPrintLine();
 
     //This is used by --set-keyless, in this case we wan't neither the module name nor the separator
     if(moduleName == NULL)
         return;
 
-    if(!instance->config.pipe)
+    //This is used as a magic value for hiding keys
+    if(moduleArgs && ffStrbufEqualS(&moduleArgs->key, " "))
+        return;
+
+    if(!instance.config.display.pipe)
     {
-        fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-        ffPrintColor(&instance->config.colorKeys);
+        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(customKeyFormat == NULL || customKeyFormat->length == 0)
+    if((printType & FF_PRINT_TYPE_NO_CUSTOM_KEY) || !moduleArgs || moduleArgs->key.length == 0)
     {
         fputs(moduleName, stdout);
 
@@ -26,93 +36,76 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
     }
     else
     {
-        FFstrbuf key;
-        ffStrbufInit(&key);
-        ffParseFormatString(&key, customKeyFormat, 1, (FFformatarg[]){
+        FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate();
+        ffParseFormatString(&key, &moduleArgs->key, 1, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
         });
-        ffPrintUserString(key.chars);
-        ffStrbufDestroy(&key);
+        ffStrbufWriteTo(&key, stdout);
     }
 
-    if(!instance->config.pipe)
+    if(!instance.config.display.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
-    ffStrbufWriteTo(&instance->config.separator, stdout);
+    ffStrbufWriteTo(&instance.config.display.keyValueSeparator, stdout);
 
-    if(!instance->config.pipe)
+    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));
+    }
 }
 
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments)
 {
-    FFstrbuf buffer;
-    ffStrbufInitA(&buffer, 256);
-
-    ffParseFormatString(&buffer, format, numArgs, arguments);
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+    if (moduleArgs)
+        ffParseFormatString(&buffer, &moduleArgs->outputFormat, numArgs, arguments);
+    else
+        ffStrbufAppendS(&buffer, "unknown");
 
     if(buffer.length > 0)
     {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffPrintUserString(buffer.chars);
-        putchar('\n');
+        ffPrintLogoAndKey(moduleName, moduleIndex, moduleArgs, printType);
+        ffStrbufPutTo(&buffer, stdout);
     }
-
-    ffStrbufDestroy(&buffer);
 }
 
-void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
+static void printError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, va_list arguments)
 {
-    ffPrintFormatString(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->outputFormat, numArgs, arguments);
-}
-
-static void printError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, va_list arguments)
-{
-    bool hasCustomErrorFormat = customErrorFormat != NULL && customErrorFormat->length > 0;
-    if(!hasCustomErrorFormat && !instance->config.showErrors)
+    if(!instance.config.display.showErrors)
         return;
 
-    if(hasCustomErrorFormat)
-    {
-        FFstrbuf error;
-        ffStrbufInit(&error);
-        ffStrbufAppendVF(&error, message, arguments);
+    ffPrintLogoAndKey(moduleName, moduleIndex, moduleArgs, printType);
 
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, 1, (FFformatarg[]) {
-            {FF_FORMAT_ARG_TYPE_STRBUF, &error}
-        });
+    if(!instance.config.display.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
 
-        ffStrbufDestroy(&error);
-    }
-    else
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+    vprintf(message, arguments);
 
-        if(!instance->config.pipe)
-            fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
+    if(!instance.config.display.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
-        vprintf(message, arguments);
-
-        if(!instance->config.pipe)
-            fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
-
-        putchar('\n');
-    }
+    putchar('\n');
 }
 
-void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...)
+void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...)
 {
     va_list arguments;
     va_start(arguments, message);
-    printError(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, message, arguments);
+    printError(moduleName, moduleIndex, moduleArgs, printType, message, arguments);
     va_end(arguments);
 }
 
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
+void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
 {
     va_list arguments;
     va_start(arguments, message);
-    printError(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->errorFormat, message, arguments);
+    printError(moduleName, moduleIndex, moduleArgs, FF_PRINT_TYPE_DEFAULT, message, arguments);
     va_end(arguments);
 }
 
@@ -123,9 +116,7 @@ void ffPrintColor(const FFstrbuf* colorValue)
     if(colorValue->length == 0)
         return;
 
-    fputs("\033[", stdout);
-    ffStrbufWriteTo(colorValue, stdout);
-    fputc('m', stdout);
+    printf("\e[%sm", colorValue->chars);
 }
 
 void ffPrintCharTimes(char c, uint32_t times)
@@ -142,33 +133,17 @@ void ffPrintCharTimes(char c, uint32_t times)
         fwrite(str, 1, remaining, stdout);
 }
 
-void ffPrintUserString(const char* value)
+void ffPrintModuleFormatHelp(const char* name, const char* def, uint32_t numArgs, const char* args[])
 {
-    while(*value != '\0')
-    {
-        if(*value != '\\')
-        {
-            putchar(*value);
-            ++value;
-            continue;
-        }
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateS(name);
+    ffStrbufLowerCase(&buffer);
+    printf("--%s-format:\n", buffer.chars);
+    printf("Sets the format string for %s output.\n", name);
+    puts("To see how a format string is constructed, take a look at \"fastfetch --help format\".");
+    puts("The following values are passed:");
 
-        ++value;
+    for(unsigned i = 0; i < numArgs; i++)
+        printf("        {%u}: %s\n", i + 1, args[i]);
 
-        if(*value == 'n')
-            putchar('\n');
-        else if(*value == 't')
-            putchar('\t');
-        else if(*value == 'e')
-            putchar('\e');
-        else if(*value == '\\')
-            putchar('\\');
-        else
-        {
-            putchar('\\');
-            putchar(*value);
-        }
-
-        ++value;
-    }
+    printf("The default is something similar to \"%s\".\n", def);
 }

src/common/printing.h

@@ -6,13 +6,25 @@
 #include "fastfetch.h"
 #include "common/format.h"
 
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat);
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments);
-void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments);
-FF_C_PRINTF(6, 7) void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...);
-FF_C_PRINTF(5, 6) void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
+typedef enum FFPrintType {
+    FF_PRINT_TYPE_DEFAULT = 0,
+    FF_PRINT_TYPE_NO_CUSTOM_KEY = 1 << 0,
+    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 ffPrintColor(const FFstrbuf* colorValue);
 void ffPrintCharTimes(char c, uint32_t times);
-void ffPrintUserString(const char* str);
+
+void ffPrintModuleFormatHelp(const char* name, const char* def, uint32_t numArgs, const char* args[]);
 
 #endif

src/common/processing.h

@@ -5,6 +5,28 @@
 
 #include "util/FFstrbuf.h"
 
-const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
+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, ' ');
+    }
+    return error;
+}
+
+static inline const char* ffProcessAppendStdErr(FFstrbuf* buffer, char* const argv[])
+{
+    const char* error = ffProcessAppendOutput(buffer, argv, true);
+    if (!error)
+    {
+        ffStrbufTrimRight(buffer, '\n');
+        ffStrbufTrimRight(buffer, ' ');
+    }
+    return error;
+}
 
 #endif

src/common/processing_linux.c

@@ -1,38 +1,87 @@
 #include "fastfetch.h"
 #include "common/processing.h"
-#include "common/io.h"
+#include "common/io/io.h"
+#include "common/time.h"
 
 #include <stdlib.h>
 #include <unistd.h>
+#include <signal.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <errno.h>
 #include <sys/wait.h>
 
-const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
+enum { FF_PIPE_BUFSIZ = 4096 };
+
+static inline void waitpid_wrapper(pid_t* pid)
+{
+    // remove zombie processes
+    if (*pid > 0)
+        waitpid(*pid, NULL, 0);
+}
+
+const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool useStdErr)
 {
     int pipes[2];
 
     if(pipe(pipes) == -1)
         return "pipe() failed";
 
-    pid_t childPid = fork();
+    __attribute__((__cleanup__(waitpid_wrapper))) pid_t childPid = fork();
     if(childPid == -1)
         return "fork() failed";
 
     //Child
     if(childPid == 0)
     {
-        dup2(pipes[1], STDOUT_FILENO);
+        int nullFile = open("/dev/null", O_WRONLY);
+        dup2(pipes[1], useStdErr ? STDERR_FILENO : STDOUT_FILENO);
+        dup2(nullFile, useStdErr ? STDOUT_FILENO : STDERR_FILENO);
         close(pipes[0]);
         close(pipes[1]);
-        close(STDERR_FILENO);
+        setenv("LANG", "C", 1);
         execvp(argv[0], argv);
         exit(901);
     }
 
     //Parent
     close(pipes[1]);
-    waitpid(childPid, NULL, 0);
-    bool ok = ffAppendFDBuffer(pipes[0], buffer);
-    close(pipes[0]);
 
-    return ok ? NULL : "ffAppendFDBuffer() failed";
+    int FF_AUTO_CLOSE_FD childPipeFd = pipes[0];
+
+    int timeout = instance.config.general.processingTimeout;
+    if (timeout >= 0)
+        fcntl(childPipeFd, F_SETFL, fcntl(childPipeFd, F_GETFL) | O_NONBLOCK);
+
+    do
+    {
+        if (timeout >= 0)
+        {
+            struct pollfd pollfd = { childPipeFd, POLLIN, 0 };
+            if (poll(&pollfd, 1, timeout) == 0)
+            {
+                kill(childPid, SIGTERM);
+                return "poll(&pollfd, 1, timeout) timeout";
+            }
+            else if (pollfd.revents & POLLERR)
+            {
+                kill(childPid, SIGTERM);
+                return "poll(&pollfd, 1, timeout) error";
+            }
+        }
+
+        char str[FF_PIPE_BUFSIZ];
+        while (true)
+        {
+            ssize_t nRead = read(childPipeFd, str, FF_PIPE_BUFSIZ);
+            if (nRead > 0)
+                ffStrbufAppendNS(buffer, (uint32_t) nRead, str);
+            else if (nRead == 0)
+                return NULL;
+            else if (nRead < 0)
+                break;
+        }
+    } while (errno == EAGAIN);
+
+    return NULL;
 }

src/common/processing_windows.c

@@ -1,36 +1,59 @@
 #include "fastfetch.h"
 #include "common/processing.h"
+#include "common/io/io.h"
 
-#define WIN32_LEAN_AND_MEAN 1
 #include <Windows.h>
 
-const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
+enum { FF_PIPE_BUFSIZ = 4096 };
+
+const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool useStdErr)
 {
-    SECURITY_ATTRIBUTES saAttr = {
-        .nLength = sizeof(SECURITY_ATTRIBUTES),
-        .lpSecurityDescriptor = NULL,
-        .bInheritHandle = TRUE,
-    };
+    int timeout = instance.config.general.processingTimeout;
 
-    HANDLE hChildStdoutRead, hChildStdoutWrite;
-    if (!CreatePipe(&hChildStdoutRead, &hChildStdoutWrite, &saAttr, 0))
-        return "CreatePipe() failed";
+    FF_AUTO_CLOSE_FD HANDLE hChildPipeRead = CreateNamedPipeW(
+        L"\\\\.\\pipe\\LOCAL\\",
+        PIPE_ACCESS_INBOUND | FILE_FLAG_FIRST_PIPE_INSTANCE | (timeout < 0 ? 0 : FILE_FLAG_OVERLAPPED),
+        0,
+        1,
+        FF_PIPE_BUFSIZ,
+        FF_PIPE_BUFSIZ,
+        0,
+        NULL
+    );
+    if (hChildPipeRead == INVALID_HANDLE_VALUE)
+        return "CreateNamedPipeW(L\"\\\\.\\pipe\\LOCAL\\\") failed";
 
-    if (!SetHandleInformation(hChildStdoutRead, HANDLE_FLAG_INHERIT, 0))
-        return "SetHandleInformation(hChildStdoutRead) failed";
+    HANDLE hChildPipeWrite = CreateFileW(
+        L"\\\\.\\pipe\\LOCAL\\",
+        GENERIC_WRITE,
+        0,
+        &(SECURITY_ATTRIBUTES){
+            .nLength = sizeof(SECURITY_ATTRIBUTES),
+            .lpSecurityDescriptor = NULL,
+            .bInheritHandle = TRUE,
+        },
+        OPEN_EXISTING,
+        0,
+        NULL
+    );
+    if (hChildPipeWrite == INVALID_HANDLE_VALUE)
+        return "CreateFileW(L\"\\\\.\\pipe\\LOCAL\\\") failed";
 
     PROCESS_INFORMATION piProcInfo = {0};
-    STARTUPINFOA siStartInfo = {
-        .cb = sizeof(siStartInfo),
-        .dwFlags = STARTF_USESTDHANDLES,
-        .hStdOutput = hChildStdoutWrite,
-    };
 
     BOOL success;
 
     {
-        FF_STRBUF_AUTO_DESTROY cmdline;
-        ffStrbufInitF(&cmdline, "\"%s\"", argv[0]);
+        STARTUPINFOA siStartInfo = {
+            .cb = sizeof(siStartInfo),
+            .dwFlags = STARTF_USESTDHANDLES,
+        };
+        if (useStdErr)
+            siStartInfo.hStdError = hChildPipeWrite;
+        else
+            siStartInfo.hStdOutput = hChildPipeWrite;
+
+        FF_STRBUF_AUTO_DESTROY cmdline = ffStrbufCreateF("\"%s\"", argv[0]);
         for(char* const* parg = &argv[1]; *parg; ++parg)
         {
             ffStrbufAppendC(&cmdline, ' ');
@@ -51,18 +74,54 @@ const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
         );
     }
 
-    CloseHandle(hChildStdoutWrite);
+    CloseHandle(hChildPipeWrite);
     if(!success)
-    {
-        CloseHandle(hChildStdoutRead);
         return "CreateProcessA() failed";
-    }
 
-    char str[1024];
-    DWORD nRead;
-    while(ReadFile(hChildStdoutRead, str, sizeof(str), &nRead, NULL) && nRead > 0)
+    FF_AUTO_CLOSE_FD HANDLE hProcess = piProcInfo.hProcess;
+    FF_MAYBE_UNUSED FF_AUTO_CLOSE_FD HANDLE hThread = piProcInfo.hThread;
+
+    char str[FF_PIPE_BUFSIZ];
+    DWORD nRead = 0;
+    FF_AUTO_CLOSE_FD HANDLE hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
+    OVERLAPPED overlapped = { .hEvent = hEvent };
+    // ReadFile always completes synchronously if the pipe is not created with FILE_FLAG_OVERLAPPED
+    do
+    {
+        if (!ReadFile(hChildPipeRead, str, sizeof(str), &nRead, &overlapped))
+        {
+            switch (GetLastError())
+            {
+            case ERROR_IO_PENDING:
+                if (!timeout || WaitForSingleObject(hEvent, (DWORD) timeout) != WAIT_OBJECT_0)
+                {
+                    CancelIo(hChildPipeRead);
+                    TerminateProcess(hProcess, 1);
+                    return "WaitForSingleObject(hEvent) failed or timeout";
+                }
+
+                if (!GetOverlappedResult(hChildPipeRead, &overlapped, &nRead, FALSE))
+                {
+                    if (GetLastError() == ERROR_BROKEN_PIPE)
+                        return NULL;
+
+                    CancelIo(hChildPipeRead);
+                    TerminateProcess(hProcess, 1);
+                    return "GetOverlappedResult(hChildPipeRead) failed";
+                }
+                break;
+
+            case ERROR_BROKEN_PIPE:
+                return NULL;
+
+            default:
+                CancelIo(hChildPipeRead);
+                TerminateProcess(hProcess, 1);
+                return "ReadFile(hChildPipeRead) failed";
+            }
+        }
         ffStrbufAppendNS(buffer, nRead, str);
+    } while (nRead > 0);
 
-    CloseHandle(hChildStdoutRead);
     return NULL;
 }

src/common/properties.c

@@ -144,32 +144,22 @@ done:
     return true;
 }
 
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+bool ffParsePropFileHomeValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    FFstrbuf absolutePath;
-    ffStrbufInitA(&absolutePath, 64);
-    ffStrbufAppend(&absolutePath, &instance->state.platform.homeDir);
-    ffStrbufAppendC(&absolutePath, '/');
-    ffStrbufAppendS(&absolutePath, relativeFile);
-
-    bool result = ffParsePropFileValues(absolutePath.chars, numQueries, queries);
-
-    ffStrbufDestroy(&absolutePath);
-
-    return result;
+    FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateF("%s/%s", instance.state.platform.homeDir.chars, relativeFile);
+    return ffParsePropFileValues(absolutePath.chars, numQueries, queries);
 }
 
 bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
     bool foundAFile = false;
 
-    FFstrbuf baseDir;
-    ffStrbufInitA(&baseDir, 64);
+    FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
 
-    for(uint32_t i = 0; i < list->length; i++)
+    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, ffListGet(list, i));
+        ffStrbufSet(&baseDir, dirPrefix);
         ffStrbufAppendS(&baseDir, relativeFile);
 
         if(ffParsePropFileValues(baseDir.chars, numQueries, queries))
@@ -189,7 +179,5 @@ bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uin
             break;
     }
 
-    ffStrbufDestroy(&baseDir);
-
     return foundAFile;
 }

src/common/properties.h

@@ -14,7 +14,7 @@ typedef struct 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 FFinstance* instance, const char* relativeFile, 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);
 
 static inline bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
@@ -22,9 +22,9 @@ static inline bool ffParsePropFile(const char* filename, const char* start, FFst
     return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileHome(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileHomeValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
 static inline bool ffParsePropFileList(const FFlist* list, const char* relativeFile, const char* start, FFstrbuf* buffer)
@@ -32,24 +32,24 @@ static inline bool ffParsePropFileList(const FFlist* list, const char* relativeF
     return ffParsePropFileListValues(list, relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+static inline bool ffParsePropFileConfigValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    return ffParsePropFileListValues(&instance->state.platform.configDirs, relativeFile, numQueries, queries);
+    return ffParsePropFileListValues(&instance.state.platform.configDirs, relativeFile, numQueries, queries);
 }
 
-static inline bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileConfig(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileConfigValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileDataValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+static inline bool ffParsePropFileDataValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    return ffParsePropFileListValues(&instance->state.platform.dataDirs, relativeFile, numQueries, queries);
+    return ffParsePropFileListValues(&instance.state.platform.dataDirs, relativeFile, numQueries, queries);
 }
 
-static inline bool ffParsePropFileData(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileData(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileDataValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileDataValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
 #endif

src/common/settings.c

@@ -2,7 +2,7 @@
 #include "common/settings.h"
 #include "common/library.h"
 #include "common/thread.h"
-#include "common/io.h"
+#include "common/io/io.h"
 
 #include <string.h>
 
@@ -15,18 +15,14 @@ typedef enum FFInitState
 
 #define FF_LIBRARY_DATA_LOAD_INIT(dataObject, userLibraryName, ...) \
     static dataObject data; \
-    static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER; \
     static FFInitState initState = FF_INITSTATE_UNINITIALIZED; \
-    ffThreadMutexLock(&mutex); \
     if(initState != FF_INITSTATE_UNINITIALIZED) {\
-        ffThreadMutexUnlock(&mutex); \
         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; \
-        ffThreadMutexUnlock(&mutex); \
         return NULL; \
     } \
 
@@ -35,20 +31,17 @@ typedef enum FFInitState
     if(data.ff ## symbolName == NULL) { \
         dlclose(libraryHandle); \
         initState = FF_INITSTATE_FAILED; \
-        ffThreadMutexUnlock(&mutex); \
         return NULL; \
     }
 
 #define FF_LIBRARY_DATA_LOAD_RETURN \
     initState = FF_INITSTATE_SUCCESSFUL; \
-    ffThreadMutexUnlock(&mutex); \
     return &data;
 
 #define FF_LIBRARY_DATA_LOAD_ERROR \
     { \
         dlclose(libraryHandle); \
         initState = FF_INITSTATE_FAILED; \
-        ffThreadMutexUnlock(&mutex); \
         return NULL; \
     }
 
@@ -57,23 +50,31 @@ typedef enum FFInitState
 
 typedef struct GVariantGetters
 {
-    FF_LIBRARY_SYMBOL(g_variant_get_string)
+    FF_LIBRARY_SYMBOL(g_variant_dup_string)
     FF_LIBRARY_SYMBOL(g_variant_get_boolean)
     FF_LIBRARY_SYMBOL(g_variant_get_int32)
+    FF_LIBRARY_SYMBOL(g_variant_unref)
 } GVariantGetters;
 
 static FFvariant getGVariantValue(GVariant* variant, FFvarianttype type, const GVariantGetters* variantGetters)
 {
+    FFvariant result;
+
     if(variant == NULL)
-        return FF_VARIANT_NULL;
+        result = FF_VARIANT_NULL;
     else if(type == FF_VARIANT_TYPE_STRING)
-        return (FFvariant) {.strValue = variantGetters->ffg_variant_get_string(variant, NULL)};
+        result = (FFvariant) {.strValue = variantGetters->ffg_variant_dup_string(variant, NULL)}; // Dup string, so that variant itself can be freed
     else if(type == FF_VARIANT_TYPE_BOOL)
-        return (FFvariant) {.boolValue = (bool) variantGetters->ffg_variant_get_boolean(variant), .boolValueSet = true};
+        result = (FFvariant) {.boolValue = (bool) variantGetters->ffg_variant_get_boolean(variant), .boolValueSet = true};
     else if(type == FF_VARIANT_TYPE_INT)
-        return (FFvariant) {.intValue = variantGetters->ffg_variant_get_int32(variant)};
+        result = (FFvariant) {.intValue = variantGetters->ffg_variant_get_int32(variant)};
     else
-        return FF_VARIANT_NULL;
+        result = FF_VARIANT_NULL;
+
+    if(variant)
+        variantGetters->ffg_variant_unref(variant);
+
+    return result;
 }
 
 typedef struct GSettingsData
@@ -89,9 +90,9 @@ typedef struct GSettingsData
     GVariantGetters variantGetters;
 } GSettingsData;
 
-static const GSettingsData* getGSettingsData(const FFinstance* instance)
+static const GSettingsData* getGSettingsData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance.config.library.libGIO, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_lookup)
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_has_key)
@@ -102,9 +103,10 @@ static const GSettingsData* getGSettingsData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_get_default)
 
     #define data data.variantGetters
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_get_string)
+    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
 
     data.schemaSource = data.ffg_settings_schema_source_get_default();
@@ -114,9 +116,9 @@ static const GSettingsData* getGSettingsData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
-    const GSettingsData* data = getGSettingsData(instance);
+    const GSettingsData* data = getGSettingsData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -143,9 +145,9 @@ FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaN
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_GIO
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
-    FF_UNUSED(instance, schemaName, path, key, type)
+    FF_UNUSED(schemaName, path, key, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_GIO
@@ -161,17 +163,18 @@ typedef struct DConfData
     DConfClient* client;
 } DConfData;
 
-static const DConfData* getDConfData(const FFinstance* instance)
+static const DConfData* getDConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf" FF_LIBRARY_EXTENSION, 2);
+    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance.config.library.libDConf, "libdconf" FF_LIBRARY_EXTENSION, 2);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_read_full)
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_new)
 
     #define data data.variantGetters
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_get_string)
+    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
 
     data.client = data.ffdconf_client_new();
@@ -181,9 +184,9 @@ static const DConfData* getDConfData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type)
 {
-    const DConfData* data = getDConfData(instance);
+    const DConfData* data = getDConfData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -199,23 +202,23 @@ FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvari
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_DCONF
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type)
 {
-    FF_UNUSED(instance, key, type)
+    FF_UNUSED(key, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_DCONF
 
-FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
+FFvariant ffSettingsGet(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
 {
-    FFvariant gsettings = ffSettingsGetGSettings(instance, gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
+    FFvariant gsettings = ffSettingsGetGSettings(gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
 
     if(
         (type == FF_VARIANT_TYPE_BOOL && gsettings.boolValueSet) ||
         (type != FF_VARIANT_TYPE_BOOL && gsettings.strValue != NULL)
     ) return gsettings;
 
-    return ffSettingsGetDConf(instance, dconfKey, type);
+    return ffSettingsGetDConf(dconfKey, type);
 }
 
 #ifdef FF_HAVE_XFCONF
@@ -231,9 +234,9 @@ typedef struct XFConfData
     FF_LIBRARY_SYMBOL(xfconf_init)
 } XFConfData;
 
-static const XFConfData* getXFConfData(const FFinstance* instance)
+static const XFConfData* getXFConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance.config.library.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get)
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_has_property)
@@ -248,9 +251,9 @@ static const XFConfData* getXFConfData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type)
 {
-    const XFConfData* data = getXFConfData(instance);
+    const XFConfData* data = getXFConfData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -271,9 +274,9 @@ FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelNam
     return FF_VARIANT_NULL;
 }
 #else //FF_HAVE_XFCONF
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type)
 {
-    FF_UNUSED(instance, channelName, propertyName, type)
+    FF_UNUSED(channelName, propertyName, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_XFCONF
@@ -288,31 +291,33 @@ typedef struct SQLiteData
     FF_LIBRARY_SYMBOL(sqlite3_step)
     FF_LIBRARY_SYMBOL(sqlite3_data_count)
     FF_LIBRARY_SYMBOL(sqlite3_column_int)
+    FF_LIBRARY_SYMBOL(sqlite3_column_text)
     FF_LIBRARY_SYMBOL(sqlite3_finalize)
     FF_LIBRARY_SYMBOL(sqlite3_close)
 } SQLiteData;
 
-static const SQLiteData* getSQLiteData(const FFinstance* instance)
+static const SQLiteData* getSQLiteData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance->config.libSQLite3, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance.config.library.libSQLite3, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
 
     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)
 
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query)
 {
-    if(!ffFileExists(dbPath, S_IFREG))
+    if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
         return 0;
 
-    const SQLiteData* data = getSQLiteData(instance);
+    const SQLiteData* data = getSQLiteData();
     if(data == NULL)
         return 0;
 
@@ -341,19 +346,74 @@ int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, cons
 
     return result;
 }
-#else //FF_HAVE_SQLITE3
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result)
 {
-    FF_UNUSED(instance, dbPath, query)
+    if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
+        return false;
+
+    const SQLiteData* data = getSQLiteData();
+    if(data == NULL)
+        return false;
+
+    sqlite3* db;
+    if(data->ffsqlite3_open_v2(dbPath, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
+        return false;
+
+    sqlite3_stmt* stmt;
+    if(data->ffsqlite3_prepare_v2(db, query, (int) strlen(query), &stmt, NULL) != SQLITE_OK)
+    {
+        data->ffsqlite3_close(db);
+        return false;
+    }
+
+    if(data->ffsqlite3_step(stmt) != SQLITE_ROW || data->ffsqlite3_data_count(stmt) < 1)
+    {
+        data->ffsqlite3_finalize(stmt);
+        data->ffsqlite3_close(db);
+        return false;
+    }
+
+    ffStrbufSetS(result, (const char *) data->ffsqlite3_column_text(stmt, 0));
+
+    data->ffsqlite3_finalize(stmt);
+    data->ffsqlite3_close(db);
+
+    return true;
+}
+#else //FF_HAVE_SQLITE3
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query)
+{
+    FF_UNUSED(dbPath, query)
     return 0;
 }
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result)
+{
+    FF_UNUSED(dbPath, query, result)
+    return false;
+}
 #endif //FF_HAVE_SQLITE3
 
 #ifdef __ANDROID__
 #include <sys/system_properties.h>
-void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
+bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
     ffStrbufEnsureFree(result, PROP_VALUE_MAX);
-    result->length += (uint32_t) __system_property_get(propName, result->chars + result->length);
+    int len = __system_property_get(propName, result->chars + result->length);
+    if (len <= 0) return false;
+    result->length += (uint32_t) len;
     result->chars[result->length] = '\0';
+    return true;
 }
-#endif //__ANDROID__
+#elif defined(__FreeBSD__)
+#include <kenv.h>
+bool ffSettingsGetFreeBSDKenv(const char* propName, FFstrbuf* result)
+{
+    //https://wiki.ghostbsd.org/index.php/Kenv
+    ffStrbufEnsureFree(result, KENV_MVALLEN);
+    int len = kenv(KENV_GET, propName, result->chars + result->length, KENV_MVALLEN);
+    if (len <= 0) return false;
+    result->length += (uint32_t) len;
+    result->chars[result->length] = '\0';
+    return true;
+}
+#endif

src/common/settings.h

@@ -25,15 +25,18 @@ typedef union FFvariant
 
 #define FF_VARIANT_NULL ((FFvariant){.strValue = NULL})
 
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type);
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type);
-FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type);
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type);
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type);
+FFvariant ffSettingsGet(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type);
 
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query);
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query);
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result);
 
 #ifdef __ANDROID__
-void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
+bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
+#elif defined(__FreeBSD__)
+bool ffSettingsGetFreeBSDKenv(const char* propName, FFstrbuf* result);
 #endif
 
 #endif

src/common/thread.h

@@ -10,6 +10,7 @@
         #include <handleapi.h>
         #include <synchapi.h>
         #include <process.h>
+        #include <processthreadsapi.h>
         #define FF_THREAD_MUTEX_INITIALIZER SRWLOCK_INIT
         typedef SRWLOCK FFThreadMutex;
         typedef HANDLE FFThreadType;
@@ -19,10 +20,25 @@
             return (FFThreadType)_beginthreadex(NULL, 0, func, data, 0, NULL);
         }
         #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType) static __stdcall unsigned fn ## ThreadMain (void* data) { fn((paramType)data); return 0; }
+        #define FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(fn) static __stdcall unsigned fn ## ThreadMain () { fn(); return 0; }
         static inline void ffThreadDetach(FFThreadType thread) { CloseHandle(thread); }
-        static inline void ffThreadJoin(FFThreadType thread) { WaitForSingleObject(thread, INFINITE); }
+        static inline bool ffThreadJoin(FFThreadType thread, uint32_t timeout)
+        {
+            if (WaitForSingleObject(thread, timeout == 0 ? (DWORD) -1 : timeout) != 0 /*WAIT_OBJECT_0*/)
+            {
+                TerminateThread(thread, (DWORD) -1);
+                CloseHandle(thread);
+                return false;
+            }
+            CloseHandle(thread);
+            return true;
+        }
     #else
         #include <pthread.h>
+        #include <signal.h>
+        #if __has_include(<pthread_np.h>)
+            #include <pthread_np.h>
+        #endif
         #define FF_THREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
         typedef pthread_mutex_t FFThreadMutex;
         typedef pthread_t FFThreadType;
@@ -34,8 +50,30 @@
             return newThread;
         }
         #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType) static void* fn ## ThreadMain (void* data) { fn((paramType)data); return NULL; }
+        #define FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(fn) static void* fn ## ThreadMain () { fn(); return NULL; }
         static inline void ffThreadDetach(FFThreadType thread) { pthread_detach(thread); }
-        static inline void ffThreadJoin(FFThreadType thread) { pthread_join(thread, NULL); }
+        static inline bool ffThreadJoin(FFThreadType thread, FF_MAYBE_UNUSED uint32_t timeout)
+        {
+            #if (defined(__linux__) && !defined(__ANDROID__)) || __has_include(<pthread_np.h>)
+                if (timeout > 0)
+                {
+                    struct timespec ts;
+                    if (clock_gettime(CLOCK_REALTIME, &ts) == 0)
+                    {
+                        ts.tv_sec += ts.tv_sec / 1000;
+                        ts.tv_nsec += (ts.tv_nsec % 1000) * 1000000;
+                        if (pthread_timedjoin_np(thread, NULL, &ts) != 0)
+                        {
+                            pthread_kill(thread, SIGTERM);
+                            return false;
+                        }
+                        return true;
+                    }
+                }
+            #endif
+            pthread_join(thread, NULL);
+            return true;
+        }
     #endif
 #else //FF_HAVE_THREADS
     #define FF_THREAD_MUTEX_INITIALIZER 0

src/common/time.h

@@ -7,6 +7,7 @@
 #ifdef _WIN32
     #include <synchapi.h>
     #include <profileapi.h>
+    #include <sysinfoapi.h>
 #else
     #include <time.h>
 #endif
@@ -26,6 +27,19 @@ static inline uint64_t ffTimeGetTick() //In msec
     #endif
 }
 
+static inline uint64_t ffTimeGetNow()
+{
+    #ifdef _WIN32
+        uint64_t timeNow;
+        GetSystemTimeAsFileTime((FILETIME*) &timeNow);
+        return (timeNow - 116444736000000000ull) / 10000ull;
+    #else
+        struct timespec timeNow;
+        clock_gettime(CLOCK_REALTIME, &timeNow);
+        return (uint64_t)((timeNow.tv_sec * 1000) + (timeNow.tv_nsec / 1000000));
+    #endif
+}
+
 static inline void ffTimeSleep(uint32_t msec)
 {
     #ifdef _WIN32

src/data/config_system.txt

@@ -2,7 +2,7 @@
 # This file sets the default config for all users of the system.
 
 # For more information about how configuration files work,
-# see ~/.config/fastfetch/config.conf, generated during first run.
+# see ~/.config/fastfetch/config.conf.
 # All options that can be put there (or passed as argument) can be put here too.
 
 # Use fastfetch --print-config-system > /etc/fastfetch/config.conf

src/data/config_user.jsonc

@@ -0,0 +1,41 @@
+// ~/.config/fastfetch/config.jsonc
+// See https://github.com/fastfetch-cli/fastfetch/wiki/Configuration for more details
+// See *.jsonc in https://github.com/fastfetch-cli/fastfetch/tree/dev/presets/examples for more examples
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "padding": {
+            "top": 2
+        }
+    },
+    "modules": [
+        "title",
+        "separator",
+        "os",
+        "host",
+        "kernel",
+        "uptime",
+        "packages",
+        "shell",
+        "display",
+        "de",
+        "wm",
+        "wmtheme",
+        "theme",
+        "icons",
+        "font",
+        "cursor",
+        "terminal",
+        "terminalfont",
+        "cpu",
+        "gpu",
+        "memory",
+        "disk",
+        "localip",
+        "battery",
+        "poweradapter",
+        "locale",
+        "break",
+        "colors"
+    ]
+}

src/data/config_user.txt

@@ -58,6 +58,18 @@
 # Default is true.
 #--hide-cursor true
 
+# Processing timeout option:
+# Sets the timeout (ms) when waiting for child processes
+# Must be an integer.
+# Default is 1000
+#--processing-timeout 1000
+
+# WMI timeout option:
+# Sets the timeout (ms) for WMI queries. Windows only
+# Must be an integer.
+# Default is 5000
+#--wmi-timeout 5000
+
 # Logo option:
 # Sets the logo to use.
 # List available logos with "fastfetch --list-logos".
@@ -146,12 +158,45 @@
 # Default is IEC.
 #--binary-prefix IEC
 
+# Size number of digits option:
+# Sets the number of digits to keep after the decimal point when formatting sizes.
+# Must be an possitive integer.
+# Default is 2.
+#--size-ndigits 2
+
+# Size max prefix option:
+# Sets the largest binary prefix to use when formatting sizes.
+# Must be one of B, kB, MB, GB, TB, PB, EB, ZB, YB
+# Default is YB.
+#--size-max-prefix YB
+
+# Disable output buffer option:
+# Sets if the stdout application buffer should be disabled.
+# Must be true or false.
+# Default is false.
+#--no-buffer false
+
 # Title FQDN option:
 # Sets if the title should use the fully qualified domain name.
 # Must be true or false.
 # Default is false.
 #--title-fqdn false
 
+# Title user color option:
+# Sets color of the user name (left part).
+# Default is empty (use color of `--color-title`).
+#--title-color-user
+
+# Title at color option:
+# Sets color of the @ symbol (middle part).
+# Default is empty (use color of `--color-title`).
+#--title-color-at
+
+# Title host color option:
+# Sets color of the host name (right part).
+# Default is empty (use color of `--color-title`).
+#--title-color-host
+
 # Separator option:
 # Sets the string placed between a key and its value.
 # Can be any string.
@@ -168,13 +213,18 @@
 # Sets the URL of public IP detection server to be used.
 # Only HTTP protocol is supported, and the value should not contain "http://" prefix.
 # Default is "ipinfo.io/ip".
-#--public-ip-url "ipinfo.io/ip"
+#--publicip-url "ipinfo.io/ip"
 
 # Public IP timeout option:
 # Sets the time to wait for the public ip server to respond.
 # Must be a positive integer.
 # Default is 0 (disabled).
-#--public-ip-timeout 0
+#--publicip-timeout 0
+
+# Weather location option:
+# Sets the location to be used. It must be URI encoded (eg a whitespace must be encoded as `+`).
+# Default is empty (guessing by public IP)
+#--weather-location "Location"
 
 # Weather output format option:
 # Sets the weather format to be used. It must be URI encoded.
@@ -200,42 +250,45 @@
 # Default is the first match starting with org.mpris.MediaPlayer2.
 #--player-name spotify
 
+# Display server force DRM option
+# Sets if fastfetch should only use `/sys/class/drm` to detect displays if you get issues with the default behavior.
+# Note DRM doesn't support refresh rate or scaled resolution detection.
+# Only supported on Linux.
+# Must be true or false.
+# Default is false.
+#--ds-force-drm false
+
 # Escape bedrock option
 # Sets if fastfetch should escape the bedrock jail, if it detectes that it is running in one
 # Must be true or false.
 # Default is true.
 #--escape-bedrock true
 
-# GL option
+# OpenGL option
 # Sets with opengl context creation library to use
 # Must be either auto, egl, glx or osmesa
 # Default is auto.
-#--gl auto
+#--opengl-library auto
 
 # GPU hide options
-# Sets weather to hide certain gpu types
+# Sets whether to hide certain gpu types
 # Must be either true or false
 # Default is false.
 #--gpu-hide-integrated
 #--gpu-hide-discrete
 
-# Shell option
-# Sets if shell version should be detected and printed
+# GPU detection options
+# Forces using vulkan to detect GPUs
+# which support video memory usage detection with `--allow-slow-operations`
 # Must be either true or false
-# Default is true.
-#--shell-version true
-
-# Terminal option
-# Sets if terminal version should be detected and printed
-# Must be either true or false
-# Default is true.
-#--terminal-version true
+# Default is false.
+#--gpu-force-vulkan
 
 # Disk show options
 # Sets if certain types of disk should be printed
 # Must be either true or false
-# Default is false except for --disk-show-removable.
-#--disk-show-removable true
+# Default is false except for --disk-show-external.
+#--disk-show-external true
 #--disk-show-hidden false
 #--disk-show-subvolumes false
 #--disk-show-unknown false
@@ -247,10 +300,40 @@
 # Default is "/:/home" ("C:\\;D:\\ ..." on Windows).
 #--disk-folders /:/home
 
+# Bluetooth show disconnected option
+# Sets if disconnected bluetooth devices should be printed
+# Must be either true or false
+# Default is false.
+#--bluetooth-show-disconnected false
+
+# Display compact output option
+# Sets if all displays should be printed in one line
+# Must be either original (print pixel resolution) or scaled (print scaled resolution)
+# Default is none.
+#--display-compact-type none
+
+# Display detect name option
+# Sets if display name should be detected and printed (if supported)
+# Must be either true of false
+# Default is false.
+#--display-detect-name none
+
+# Display precise refresh rate option
+# Sets if decimal refresh rates should not be rounded into integers when printing
+# Must be either true (keep decimals) of false (round into integers)
+# Default is false.
+#--display-precise-refresh-rate false
+
+# Sound show all option
+# Sets if all sound devices should be printed
+# Must be either main, active or all. Default is main
+# Default is main.
+#--sound-type main
+
 # Percentage output type option
 # Applies to all modules that prints percentage values. Currently memory, swap, disk, battery and CPU usage are supported.
 # Only works with default format ( without --module-format option ).
-# 0: prints none; 1: prints percent number only; 2: prints bar only; 3: prints both percent number and bar; 6: prints bar and hide other texts
+# 0: prints none; 1: prints percent number only; 2: prints bar only; 3: prints both percent number and bar; 6: prints bar and hide other texts; 9: prints colored number
 #--percent-type 1
 
 # Key options:
@@ -266,41 +349,50 @@
 #--shell-key Shell
 #--display-key Display {1}
 #--brightness-key Brightness ({1})
+#--monitor-key Monitor
 #--de-key DE
 #--wm-key WM
-#--wm-theme-key WM Theme
+#--wmtheme-key WM Theme
 #--theme-key Theme
 #--icons-key Icons
 #--font-key Font
 #--cursor-key Cursor
 #--terminal-key Terminal
-#--terminal-font-key Terminal Font
+#--terminalfont-key Terminal Font
 #--cpu-key CPU
-#--cpu-usage-key CPU Usage
+#--cpuusage-key CPU Usage
 #--gpu-key GPU {1}
 #--memory-key Memory
 #--swap-key Swap
 #--disk-key Disk ({1})
 #--battery-key Battery {1}
 #--poweradapter-key Power Adapter {1}
+#--lm-key LM
 #--locale-key Locale
-#--local-ip-key Local IP ({1})
-#--public-ip-key Public IP
+#--localip-key Local IP ({1})
+#--netio-key Network IO ({1})
+#--publicip-key Public IP
 #--wifi-key Wifi
 #--weather-key Weather
 #--player-key Media Player
 #--media-key Media
 #--datetime-key Date Time
+#--version-key Version
 #--vulkan-key Vulkan
 #--opengl-key OpenGL
 #--opencl-key OpenCL
 #--users-key Users
+#--bluetooth-key Bluetooth
+#--sound-key Sound
+#--gamepad-key Gamepad
+#--wallpaper-key Wallpaper
 
 # Format options:
 # Sets the format string for module values.
 # For information on format strings, see "fastfetch --help format".
 # To see the parameter they take and their default value, see "fastfetch --help *-format", e.g. "fastfetch --help os-format".
 # An empty format string (As they are currently below) will behave as if it was not set.
+#--title-format
 #--os-format
 #--host-format
 #--chassis-format
@@ -313,76 +405,90 @@
 #--brightness-format
 #--de-format
 #--wm-format
-#--wm-theme-format
+#--wmtheme-format
 #--theme-format
 #--icons-format
 #--font-format
 #--cursor-format
 #--terminal-format
-#--terminal-font-format
+#--terminalfont-format
 #--cpu-format
-#--cpu-usage-format
+#--cpuusage-format
 #--gpu-format
 #--memory-format
 #--swap-format
 #--disk-format
 #--battery-format
 #--poweradapter-format
+#--lm-format
 #--locale-format
-#--local-ip-format
-#--public-ip-format
+#--localip-format
+#--netio-format
+#--publicip-format
 #--weather-format
+#--monitor-format
 #--player-format
 #--media-format
 #--datetime-format
+#--version-format
 #--vulkan-format
 #--opengl-format
 #--opencl-format
 #--users-format
+#--bluetooth-format
+#--sound-format
+#--gamepad-format
+#--wallpaper-format
 
-# Error options:
-# Sets the format string to use if an error occured
-# For information on format strings, see "fastfetch --help format".
-# Each of them take the error as first and only argument.
-# If one of them is set, the module will appear, even if --show-errors is not given.
-#--os-error
-#--host-error
-#--chassis-error
-#--kernel-error
-#--uptime-error
-#--processes-error
-#--packages-error
-#--shell-error
-#--display-error
-#--brightness-error
-#--de-error
-#--wm-error
-#--wm-theme-error
-#--theme-error
-#--icons-error
-#--font-error
-#--cursor-error
-#--terminal-error
-#--terminal-font-error
-#--cpu-error
-#--cpu-usage-error
-#--gpu-error
-#--memory-error
-#--swap-error
-#--disk-error
-#--battery-error
-#--poweradapter-error
-#--locale-error
-#--local-ip-error
-#--public-ip-error
-#--weather-error
-#--player-error
-#--media-error
-#--datetime-error
-#--vulkan-error
-#--opengl-error
-#--opencl-error
-#--users-error
+# Key color options:
+# Overrides the global `--color-keys` for one specified module
+#--title-key-color
+#--os-key-color
+#--host-key-color
+#--chassis-key-color
+#--kernel-key-color
+#--uptime-key-color
+#--processes-key-color
+#--packages-key-color
+#--shell-key-color
+#--display-key-color
+#--brightness-key-color
+#--de-key-color
+#--wm-key-color
+#--wmtheme-key-color
+#--theme-key-color
+#--icons-key-color
+#--font-key-color
+#--cursor-key-color
+#--terminal-key-color
+#--terminalfont-key-color
+#--cpu-key-color
+#--cpuusage-key-color
+#--gpu-key-color
+#--memory-key-color
+#--swap-key-color
+#--disk-key-color
+#--battery-key-color
+#--poweradapter-key-color
+#--lm-key-color
+#--locale-key-color
+#--localip-key-color
+#--netio-key-color
+#--publicip-key-color
+#--weather-key-color
+#--monitor-key-color
+#--player-key-color
+#--media-key-color
+#--datetime-key-color
+#--version-key-color
+#--vulkan-key-color
+#--opengl-key-color
+#--opencl-key-color
+#--users-key-color
+#--bluetooth-key-color
+#--sound-key-color
+#--gamepad-key-color
+#--wallpaper-key-color
 
 # Library options:
 # Sets an user specific path to a library to load.
@@ -407,5 +513,7 @@
 #--lib-glx /usr/lib/libGLX.so
 #--lib-osmesa /usr/lib/libOSMesa.so
 #--lib-opencl /usr/lib/libOpenCL.so
-#--lib-cjson /usr/lib/libcjson.so
 #--lib-freetype /data/data/com.termux/files/usr/lib
+#--lib-pulse /usr/lib/libpulse.so
+#--lib-ddcutil /usr/lib/libddcutil.so
+#--lib-nm /usr/lib/libnm.so

src/data/help.txt

@@ -1,42 +1,49 @@
-Usage: fastfetch <options>
+Fastfetch is a neofetch-like tool for fetching system information and displaying them in a pretty way
+
+Usage: fastfetch <?options>
 
 Informative options:
-    -h,--help:             Show this message
-    -h,--help <command>:   Show help for a specific command
-    -v,--version:          Show the version of fastfetch
-    --list-config-paths:   List search paths of config files
-    --list-data-paths:     List search paths of presets and logos
-    --list-logos:          List available logos
-    --list-modules:        List available modules
-    --list-presets:        List presets fastfetch knows about; they can be loaded with --load-config (+)
-    --list-features:       List the supported features fastfetch was compiled with (mainly for development)
-    --print-logos:         Print available logos
-    --print-config-system: Print the default system config
-    --print-config-user:   Print the default user config
-    --print-structure:     Print the default structure
-    --gen-config:          Generate a sample config file in the default path
-    --gen-config-force:    Generate a sample config file in the default path. Overwrite the existing one
+    -h, --help:                 Show this message
+    -h, --help <command>:       Show help for a specific command
+    -v, --version:              Show the version of fastfetch
+    --list-config-paths:        List search paths of config files
+    --list-data-paths:          List search paths of presets and logos
+    --list-logos:               List available logos
+    --list-modules:             List available modules
+    --list-presets:             List presets fastfetch knows about; they can be loaded with --load-config (+)
+    --list-features:            List the supported features fastfetch was compiled with (mainly for development)
+    --print-logos:              Print available logos
+    --print-config-system:      Print the default system config
+    --print-config-user:        Print the default user config
+    --print-structure:          Print the default structure
+
+Config options:
+    -c, --load-config <file>:   Load a config file or preset (+)
+    --gen-config <type>:        Generate a sample config file in the default path. Param `type` can be `jsonc` or deprecated `conf`
+    --gen-config-force <type>:  Generate a sample config file in the default path. Overwrite the existing one
+    --migrate-config <?path>:   Migrate old flag based config file to new JSONC format. Optional param `path` is the file path that new file should be write to
 
 General options:
-    --load-config <file>:             Load a config file or preset (+)
-    --multithreading <?value>:        Use multiple threads to detect values
-    --stat <?value>:                  Show time usage (in ms) for individual modules
-    --allow-slow-operations <?value>: Allow operations that are usually very slow for more detailed output
+    --thread <?value>:                Use separate threads to send HTTP requests
     --escape-bedrock <?value>:        On Bedrock Linux, whether to escape the bedrock jail
-    --pipe <?value>:                  Disable logo and all escape sequences
+    --wmi-timeout <num>:              Set the timeout (ms) for WMI queries. Windows only. Default is 5000
+    --processing-timeout <num>:       Set the timeout (ms) when waiting for child processes. Default is 1000
+    --ds-force-drm <?value>:          Set if only DRM should be used to detect displays. Default is false. Linux only
 
 Logo options:
-    -l,--logo <logo>:                      Set the logo; if default, the name of a builtin logo or a path to a file
+    -l, --logo <logo>:                     Set the logo; if default, the name of a builtin logo or a path to a file
     --logo-type <type>:                    Set the type of the logo given; must be auto, builtin, file, file-raw, data, data-raw, sixel, kitty, iterm or chafa
     --logo-width <width>:                  Set the width of the logo (in characters), if it is an image. Required for iTerm image protocol
     --logo-height <height>:                Set the height of the logo (in characters), if it is an image. Required for iTerm image protocol
-    --logo-preserve-aspect-radio <?value>: Set if the logo should fill the specified width and height as much as possible without stretching. Supported by iTerm image protocol
+    --logo-preserve-aspect-ratio <?value>: Set if the logo should fill the specified width and height as much as possible without stretching. Supported by iTerm image protocol
     --logo-color-[1-9] <color>:            Overwrite a color in the logo
     --logo-padding <padding>:              Set the padding on the left and the right of the logo
     --logo-padding-left <padding>:         Set the padding on the left of the logo
     --logo-padding-right <padding>:        Set the padding on the right of the logo
     --logo-padding-top <padding>:          Set the padding on the top of the logo
     --logo-print-remaining <?value>:       Whether to print the remaining logo, if it has more lines than modules to display
+    --logo-separate <?value>:              If true, print modules at bottom of the logo
+    --logo-recache <?value>:               If true, regenerate image logo cache
     --file <file>:                         Short for --logo-type file --logo <file>
     --file-raw <file>:                     Short for --logo-type file-raw --logo <file>
     --data <data>:                         Short for --logo-type data --logo <data>
@@ -52,86 +59,128 @@ Logo options:
     --chafa-dither-mode <value>:           Set output dither mode (No effect with 24-bit color). This value maps the int value of enum ChafaDitherMode. See chafa document for detail
 
 Display options:
-    -s,--structure <structure>:  Set the structure of the fetch. Must be a colon separated list of keys. Use "fastfetch --list-modules" to see the ones available.
+    -s,--structure <structure>:  Set the structure of the fetch. Must be a colon separated list of keys. Use `fastfetch --list-modules` to see the ones available.
+    --stat <?value>:             Show time usage (in ms) for individual modules
+    --pipe <?value>:             Disable logo and all escape sequences
     --color-keys <color>:        Set the color of the keys
     --color-title <color>:       Set the color of the title
-    -c,--color <color>:          Set the color of both the keys and title
+    --color <color>:             Set the color of both the keys and title
+    --key-width <num>:           Align the width of keys to <num> characters
+    --bright-color <?value>:     Set if the keys, title and ASCII logo should be printed in bright color. Default is true
     --separator <str>:           Set the separator between key and value. Default is a colon with a space
     --set <key=value>:           Hard set the value of a key
     --set-keyless <key=value>:   Hard set the value of a key, but don't print the key or the separator
     --show-errors <?value>:      Print occurring errors
     --disable-linewrap <?value>: Whether to disable line wrap during the run
     --hide-cursor <?value>:      Whether to hide the cursor during the run
-    --binary-prefix <value>:     Set the binary prefix to used. Must be IEC, SI or JEDEC. Default is IEC.
+    --binary-prefix <value>:     Set the binary prefix to used. Must be IEC, SI or JEDEC. Default is IEC
+    --percent-type <value>:      Set the percentage output type. 1 for percentage number, 2 for bar, 3 for both, 6 for bar only, 9 for colored number. Default is 9
+    --percent-ndigits <value>:   Set the number of digits to keep after the decimal point when formatting percentage numbers. Default is 0
+    --bar-char-elapsed <str>:    Set the character to use in elapsed part. Default is '■'
+    --bar-char-total <str>:      Set the character to use in total part. Default is '-'
+    --bar-width <?num>:          Set the width of the bar, in number of characters. Default is 10
+    --bar-border <?value>:       Whether to show a border around the bar. Default is true
+    --no-buffer <?value>:        Set if the stdout application buffer should be disabled. Default is false
+    --size-ndigits <value>:      Set the number of digits to keep after the decimal point when formatting sizes
+    --size-max-prefix <value>:   Set the largest binary prefix to use when formatting sizes. Default is YB
+    --temperature-unit <value>:  Set the unit of the temperature. Must be one of C, F and K. Default is C
 
 General module options:
-    --<module>-format <format>: Set the format string to use for each specific module.
-                                To see how a format string works, use fastfetch --help format.
-                                To see help about a specific format string, use fastfetch --help <module>-format.
+    --<module>-format <format>:    Set the format string to use for each specific module.
+                                   To see how a format string works, use `fastfetch --help format`.
+                                   To see help about a specific format string, use `fastfetch --help <module>-format`.
 
-    --<module>-key <key>:       Set the key to use for each specific module.
-                                For modules which print multiple lines, the string is parsed as a format string with the index as first character.
+    --<module>-key <key>:          Set the key to use for each specific module.
+                                   For modules which print multiple lines, the string is parsed as a format string with the index as first character.
 
-    --<module>-error <format>:  Set the error format string to use for each specific module.
-                                The error is given as the first and only argument.
-                                Setting this for a module will cause it to appear, even if --show-errors is not given.
+    --<module>-key-color <format>: Override the global `--color-keys` option for each specific module.
+    --<module>-key-width <num>:    Override the global `--key-width` option for each specific module.
 
 Library options: Set the path of a library to load
-    --lib-PCI <path>
-    --lib-vulkan <path>
-    --lib-wayland <path>
-    --lib-xcb-randr <path>
-    --lib-xcb <path>
-    --lib-Xrandr <path>
-    --lib-X11 <path>
-    --lib-gio <path>
-    --lib-DConf <path>
-    --lib-DBus <path>
-    --lib-XFConf <path>
-    --lib-sqlite3 <path>
-    --lib-rpm <path>
-    --lib-imagemagick <path>
-    --lib-z <path>
-    --lib-chafa <path>
-    --lib-egl <path>
-    --lib-glx <path>
-    --lib-osmesa <path>
-    --lib-opencl <path>
-    --lib-cjson <path>
+    --lib-PCI <path>:           GPU output
+    --lib-vulkan <path>:        Vulkan module & fallback for GPU output
+    --lib-wayland <path>:       Better display performance and output in wayland sessions
+    --lib-xcb-randr <path>:     X11 sessions for better display detection and faster WM detection
+    --lib-xcb <path>:           X11 sessions for better display detection and faster WM detection
+    --lib-Xrandr <path>:        X11 sessions for better display detection and faster WM detection
+    --lib-X11 <path>:           X11 sessions for better display detection and faster WM detection
+    --lib-gio <path>:           Needed for values that are only stored GSettings
+    --lib-DConf <path>:         Needed for values that are only stored in DConf + Fallback for GSettings
+    --lib-DBus <path>:          Bluetooth, Player & Media detection
+    --lib-XFConf <path>:        Needed for XFWM theme and XFCE Terminal font
+    --lib-sqlite3 <path>:       Needed for pkg & rpm package count
+    --lib-rpm <path>:           Slower fallback for rpm package count
+    --lib-imagemagick <path>:   Images in terminal using sixel or kitty graphics protocol
+    --lib-z <path>:             Libz. Faster image output when using kitty graphics protocol
+    --lib-chafa <path>:         Image output as ascii art
+    --lib-egl <path>:           Needed by the OpenGL module for gl context creation
+    --lib-glx <path>:           Needed by the OpenGL module for gl context creation
+    --lib-osmesa <path>:        Needed by the OpenGL module for gl context creation
+    --lib-opencl <path>:        OpenCL module
+    --lib-pulse <path>:         Pulseaudio. Used for Sound detection
+    --lib-nm:                   NetworkManager. Used for Wifi detection
+    --lib-freetype <path>:      Used for Termux font detection
+    --lib-ddcutil <path>:       Used for brightness detection of external displays
 
 Module specific options:
-    --title-fqdn <?value>:           Set if the title should use fully qualified domain name. Default is false
-    --separator-string <str>:        Set the string printed by the separator module
-    --os-file <path>:                Set the path to the file containing OS information
-    --shell-version <?value>:        Set if shell version should be detected and printed
-    --terminal-version <?value>:     Set if terminal version should be detected and printed
-    --disk-folders <folders>:        A colon (semicolon on Windows) separated list of folder paths for the disk output. Default is "/:/home" ("C:\\;D:\\ ..." on Windows)
-    --disk-show-removable <?value>:  Set if removable volume should be printed. Default is true
-    --disk-show-hidden <?value>:     Set if hidden volumes should be printed. Default is false
-    --disk-show-subvolumes <?value>: Set if subvolumes should be printed. Default is false
-    --disk-show-unknown <?value>:    Set if unknown (unable to detect sizes) volumes should be printed. Default is false
-    --battery-dir <folder>:          The directory where the battery folders are. Standard: /sys/class/power_supply/
-    --cpu-temp  <?value>:            Detect and display CPU temperature if supported. Default is false
-    --gpu-temp  <?value>:            Detect and display GPU temperature if supported. Default is false
-    --gpu-hide-integrated <?value>:  Hide integrated GPU if supported. Default is false
-    --gpu-hide-discrete <?value>:    Hide discrete GPU if supported. Default is false
-    --battery-temp  <?value>:        Detect and display Battery temperature if supported. Default is false
-    --localip-show-ipv4 <?value>:    Show IPv4 addresses in local ip module. Default is true
-    --localip-show-ipv6 <?value>:    Show IPv6 addresses in local ip module. Default is false
-    --localip-show-loop <?value>:    Show loop back addresses (127.0.0.1) in local ip module. Default is false
-    --localip-name-prefix <str>:     Show IPs with given name prefix only. Default is empty
-    --public-ip-timeout:             Time in milliseconds to wait for the public ip server to respond. Default is disabled (0)
-    --public-ip-url:                 The URL of public IP detection server to be used.
-    --weather-timeout:               Time in milliseconds to wait for the weather server to respond. Default is disabled (0)
-    --weather-output-format:         The output weather format to be used. It must be URI encoded.
-    --player-name:                   The name of the player to use
-    --gl <value>:                    Set the OpenGL context creation library to use. Must be auto, egl, glx or osmesa. Default is auto
-    --percent-type <value>:          Set the percentage output type. 1 for percentage number, 2 for bar, 3 for both, 6 for bar only. Default is 1
-    --command-shell <str>:           Set the shell program to execute the command text. Default is cmd for Windows, csh for FreeBSD, bash for others
-    --command-key <str>:             Set the module key to display, can be specified mulitple times
-    --command-text <str>:            Set the command text to be executed, can be specified mulitple times
+    --title-fqdn <?value>:                   Set if the title should use fully qualified domain name. Default is false
+    --title-color-user <color>:              Set color of the user name (left part). Default is empty (use color of `--color-title`).
+    --title-color-at <color>:                Set color of the @ symbol (middle part). Default is empty (use color of `--color-title`)
+    --title-color-host <color>:              Set color of the host name (right part). Default is empty (use color of `--color-title`)
+    --chassis-use-wmi <?value>:              Set if WMI query should be used on Windows, which detects more information but slower. Default is false
+    --separator-string <str>:                Set the string printed by the separator module
+    --os-file <path>:                        Set the path to the file containing OS information. Linux only
+    --disk-folders <folders>:                A colon (semicolon on Windows) separated list of folder paths for the disk output. Default is "/:/home" ("C:\\;D:\\ ..." on Windows)
+    --disk-show-regular <?value>:            Set if regular volume should be printed. Default is true
+    --disk-show-external <?value>:           Set if external volume should be printed. Default is true
+    --disk-show-hidden <?value>:             Set if hidden volumes should be printed. Default is false
+    --disk-show-subvolumes <?value>:         Set if subvolumes should be printed. Default is false
+    --disk-show-readonly <?value>:           Set if read only volumes should be printed. Default is false
+    --disk-show-unknown <?value>:            Set if unknown (unable to detect sizes) volumes should be printed. Default is false
+    --disk-use-available <?value>:           Use f_bavail (lpFreeBytesAvailableToCaller for Windows) instead of f_bfree to calculate used bytes. Default is false
+    --diskio-name-prefix <str>:              Show disks with given name prefix only. Default is empty
+    --bluetooth-show-disconnected <?value>:  Set if disconnected bluetooth devices should be printed. Default is false
+    --packages-winget <?value>:              Set if winget package count should be detected. Default is false
+    --display-compact-type <?string>:        Set if all displays should be printed in one line. Default is none
+    --display-detect-name <?value>:          Set if display name should be detected and printed (if supported). Default is false
+    --display-precise-refresh-rate <?value>: Set if decimal refresh rates should not be rounded into integers when printing. Default is true
+    --brightness-ddcci-sleep <num>:          Set the sleep times (in ms) when sending DDC/CI requests. See <https://www.ddcutil.com/performance_options/#option-sleep-multiplier> for detail. Default is 10
+    --sound-type <value>:                    Set what type of sound devices should be printed. Should be either main, active or all. Default is main
+    --battery-dir <folder>:                  The directory where the battery folders are. Standard: `/sys/class/power_supply/`. Linux only
+    --battery-use-setup-api <?value>:        Set if `SetupAPI` should be used on Windows to detect battery info, which supports multi batteries, but slower. Windows only
+    --cpu-temp <?value>:                     Detect and display CPU temperature if supported. Default is false
+    --cpu-freq-ndigits <num>:                Set the number of digits to keep after the decimal point when printing CPU frequency. Default is 2
+    --cpuusage-separate <?value>:            Display CPU usage per CPU logical core, instead of an average result. Default is false
+    --de-slow-version-detection <?value>:    Set if DE version should be detected with slow operations. Default is false
+    --gpu-temp <?value>:                     Detect and display GPU temperature if supported. Default is false
+    --gpu-use-nvml <?value>:                 Use nvml (NVIDIA Management Library) to detect more detailed GPU information (memory usage, CUDA core count, etc). Default is false
+    --gpu-force-vulkan <?value>:             Force using vulkan to detect GPUs, which support video memory usage detection with `--allow-slow-operations`. Default is false
+    --gpu-hide-type <?value>:                Specify the type of GPUs should not be printed. Must be `integrated`, `discrete` or `none`. Default is none
+    --battery-temp <?value>:                 Detect and display Battery temperature if supported. Default is false
+    --localip-show-ipv4 <?value>:            Show IPv4 addresses in local ip module. Default is true
+    --localip-show-ipv6 <?value>:            Show IPv6 addresses in local ip module. Default is false
+    --localip-show-mac <?value>:             Show mac addresses in local ip module. Default is false
+    --localip-show-loop <?value>:            Show loop back addresses (127.0.0.1) in local ip module. Default is false
+    --localip-name-prefix <str>:             Show interfaces with given interface name prefix only. Default is empty
+    --localip-default-route-only <?value>:   Show the interface that is used for default routing only. Default is true
+    --localip-compact <?value>:              Show all IPs in one line. Default is false
+    --netio-name-prefix <str>:               Show interfaces with given name prefix only. Default is empty
+    --netio-default-route-only <?value>:     Show the interfac that is used for default routing only. Default is true
+    --publicip-timeout <num>:                Time in milliseconds to wait for the public ip server to respond. Default is disabled (0)
+    --publicip-url <str>:                    The URL of public IP detection server to be used.
+    --weather-location <str>:                Set the location to be used. It must be URI encoded (eg a whitespace must be encoded as `+`).
+    --weather-timeout <num>:                 Time in milliseconds to wait for the weather server to respond. Default is disabled (0)
+    --weather-output-format <str>:           The output weather format to be used. It must be URI encoded.
+    --wm-detect-plugin <?value>:             Set if window manager plugin should be detected on supported platforms. Default is false
+    --player-name <str>:                     The name of the player to use for module Media and Player. Linux only
+    --opengl-library <str>:                  Set the OpenGL context creation library to use. Must be auto, egl, glx or osmesa. Default is auto
+    --command-shell <str>:                   Set the shell program to execute the command text. Default is cmd for Windows, /bin/sh for *nix
+    --command-key <str>:                     Set the module key to display
+    --command-text <str>:                    Set the command text to be executed
+    --colors-symbol <str>:                   Set the symbol to be printed by Colors module. Default is block
+    --colors-padding-left <value>:           Set the number of white spaces to print before the symbol. Default is 0
 
 Parsing is not case sensitive. E.g. "--lib-PCI" is equal to "--Lib-Pci"
 If a value starts with a ?, it is optional. "true" will be used if not set.
 A (+) at the end indicates that more help can be printed with --help <option>
-All options can be made permanent in $XDG_CONFIG_HOME/fastfetch/config.conf
+All options can be made permanent with command `fastfetch <options> --migrate-config`

src/data/help_color.txt

@@ -1,6 +1,6 @@
-usage: fastfetch --color <color>
+Usage: fastfetch --color <color>
 
-<color> must be a color encoding for linux terminals. It is inserted between "ESC[" and "m".
+<color> must be a color encoding as ANSI escape sequences. It is inserted between "ESC[" and "m".
 Infos about them can be found here: https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters.
 Examples:
    --color 35:    sets the color to pink

src/data/help_config.txt

@@ -1,4 +1,4 @@
-usage: fastfetch --load-config <file>
+Usage: fastfetch -c <file>
 
 Loads a config file. A config file contains one flag per line. Empty lines or lines starting with # are ignored.
 If the file is relative it looks in the following order:

src/data/modules.txt

@@ -1,44 +0,0 @@
-Battery
-Bios
-Board
-Break
-Chassis
-Colors
-CPU
-CPUUsage
-Cursor
-Date
-Datetime
-DE
-Disk
-Display
-Font
-GPU
-Host
-Icons
-Kernel
-Locale
-LocalIP
-Media
-Memory
-OpenGL
-OS
-Packages
-Player
-PowerAdapter
-Processes
-PublicIP
-Separator
-Shell
-Swap
-Terminal
-TerminalFont
-Theme
-Time
-Title
-Uptime
-Vulkan
-Weather
-Wifi
-WM
-WMTheme

src/data/structure.txt

@@ -1 +1 @@
-Title:Separator:OS:Host:Kernel:Uptime:Packages:Shell:Display:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Disk:Battery:PowerAdapter:Locale:Break:Colors
+Title:Separator:OS:Host:Kernel:Uptime:Packages:Shell:Display:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Swap:Disk:LocalIp:Battery:PowerAdapter:Locale:Break:Colors

src/detection/battery/battery.h

@@ -7,7 +7,7 @@
 
 #define FF_BATTERY_TEMP_UNSET (0/0.0)
 
-typedef struct BatteryResult
+typedef struct FFBatteryResult
 {
     FFstrbuf manufacturer;
     FFstrbuf modelName;
@@ -15,8 +15,9 @@ typedef struct BatteryResult
     double capacity;
     FFstrbuf status;
     double temperature;
-} BatteryResult;
+    uint32_t cycleCount;
+} FFBatteryResult;
 
-const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results);
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results);
 
 #endif

src/detection/battery/battery_android.c

@@ -4,35 +4,126 @@
 #include "common/processing.h"
 #include "common/properties.h"
 
-const char* ffDetectBatteryImpl(FF_MAYBE_UNUSED FFinstance* instance, FFlist* results)
+#define FF_TERMUX_API_PATH FASTFETCH_TARGET_DIR_ROOT "/libexec/termux-api"
+#define FF_TERMUX_API_PARAM "BatteryStatus"
+
+static inline void wrapYyjsonFree(yyjson_doc** doc)
 {
-    FF_STRBUF_AUTO_DESTROY buffer;
-    ffStrbufInit(&buffer);
+    assert(doc);
+    if (*doc)
+        yyjson_doc_free(*doc);
+}
+
+static const char* parseTermuxApi(FFBatteryOptions* options, FFlist* results)
+{
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
 
     if(ffProcessAppendStdOut(&buffer, (char* const[]){
-        FASTFETCH_TARGET_DIR_ROOT "/libexec/termux-api",
-        "BatteryStatus"
+        FF_TERMUX_API_PATH,
+        FF_TERMUX_API_PARAM,
+        NULL
     }))
-        return "Starting `" FASTFETCH_TARGET_DIR_ROOT "/libexec/termux-api" " BatteryStatus` failed";
+        return "Starting `" FF_TERMUX_API_PATH " " FF_TERMUX_API_PARAM "` failed";
 
-    BatteryResult* battery = ffListAdd(results);
+    yyjson_doc* __attribute__((__cleanup__(wrapYyjsonFree))) doc = yyjson_read_opts(buffer.chars, buffer.length, 0, NULL, NULL);
+    if (!doc)
+        return "Failed to parse battery info";
+
+    yyjson_val* root = yyjson_doc_get_root(doc);
+    if (!yyjson_is_obj(root))
+        return "Battery info result is not a JSON object";
+
+    FFBatteryResult* battery = ffListAdd(results);
+    battery->temperature = FF_BATTERY_TEMP_UNSET;
+    battery->cycleCount = 0;
+    ffStrbufInit(&battery->manufacturer);
+    ffStrbufInit(&battery->modelName);
+    ffStrbufInit(&battery->status);
+    ffStrbufInit(&battery->technology);
+
+    battery->capacity = yyjson_get_num(yyjson_obj_get(root, "percentage"));
+    ffStrbufAppendS(&battery->status, yyjson_get_str(yyjson_obj_get(root, "status")));
+    if(options->temp)
+        battery->temperature = yyjson_get_num(yyjson_obj_get(root, "temperature"));
+
+    return NULL;
+}
+
+static const char* parseDumpsys(FFBatteryOptions* options, FFlist* results)
+{
+    FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
+    if (ffProcessAppendStdOut(&buf, (char* []) {
+        "/system/bin/dumpsys",
+        "battery",
+        NULL,
+    }) != NULL || buf.length == 0)
+        return "Executing `/system/bin/dumpsys battery` failed"; // Only works in `adb shell`, or when rooted
+
+    if (!ffStrbufStartsWithS(&buf, "Current Battery Service state:\n"))
+        return "Invalid `/system/bin/dumpsys battery` result";
+
+    const char* start = buf.chars + strlen("Current Battery Service state:\n");
+
+    FF_STRBUF_AUTO_DESTROY temp = ffStrbufCreate();
+    if (!ffParsePropLines(start, "present: ", &temp) || !ffStrbufEqualS(&temp, "true"))
+        return NULL;
+    ffStrbufClear(&temp);
+
+    FFBatteryResult* battery = ffListAdd(results);
     battery->temperature = FF_BATTERY_TEMP_UNSET;
     ffStrbufInit(&battery->manufacturer);
     ffStrbufInit(&battery->modelName);
     ffStrbufInit(&battery->status);
     ffStrbufInit(&battery->technology);
 
-    if(ffParsePropLines(buffer.chars, "\"percentage\": ", &battery->status))
+    if (ffParsePropLines(start, "AC powered: ", &temp) && ffStrbufEqualS(&temp, "true"))
+        ffStrbufAppendS(&battery->status, "AC powered");
+    ffStrbufClear(&temp);
+
+    if (ffParsePropLines(start, "USB powered: ", &temp) && ffStrbufEqualS(&temp, "true"))
     {
-        battery->capacity = ffStrbufToDouble(&battery->status);
-        ffStrbufClear(&battery->status);
+        if (battery->status.length) ffStrbufAppendS(&battery->status, ", ");
+        ffStrbufAppendS(&battery->status, "USB powered");
+    }
+    ffStrbufClear(&temp);
+
+    if (ffParsePropLines(start, "Wireless powered: ", &temp) && ffStrbufEqualS(&temp, "true"))
+    {
+        if (battery->status.length) ffStrbufAppendS(&battery->status, ", ");
+        ffStrbufAppendS(&battery->status, "Wireless powered");
+    }
+    ffStrbufClear(&temp);
+
+    {
+        double level = 0, scale = 0;
+        if (ffParsePropLines(start, "level: ", &temp))
+            level = ffStrbufToDouble(&temp);
+        ffStrbufClear(&temp);
+
+        if (ffParsePropLines(start, "scale: ", &temp))
+            scale = ffStrbufToDouble(&temp);
+        ffStrbufClear(&temp);
+
+        if (level > 0 && scale > 0)
+            battery->capacity = level * 100 / scale;
     }
 
-    if(ffParsePropLines(buffer.chars, "\"status\": ", &battery->status))
+    if(options->temp)
     {
-        ffStrbufTrimRight(&battery->status, ',');
-        ffStrbufTrim(&battery->status, '"');
+        if (ffParsePropLines(start, "temperature: ", &temp))
+            battery->temperature = ffStrbufToDouble(&temp);
+        ffStrbufClear(&temp);
     }
 
+    ffParsePropLines(start, "technology: ", &battery->technology);
+
     return NULL;
 }
+
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
+{
+    const char* error = parseTermuxApi(options, results);
+    if (error && parseDumpsys(options, results) == NULL)
+        return NULL;
+    return error;
+}

src/detection/battery/battery_apple.c

@@ -5,45 +5,16 @@
 
 #include <IOKit/IOKitLib.h>
 
-static double detectBatteryTemp()
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
-    FF_LIST_AUTO_DESTROY temps;
-    ffListInit(&temps, sizeof(FFTempValue));
-
-    ffDetectCoreTemps(FF_TEMP_BATTERY, &temps);
-
-    if(temps.length == 0)
-        return FF_BATTERY_TEMP_UNSET;
-
-    double result = 0;
-    for(uint32_t i = 0; i < temps.length; ++i)
-    {
-        FFTempValue* tempValue = (FFTempValue*)ffListGet(&temps, i);
-        result += tempValue->value;
-        //TODO: do we really need this?
-        ffStrbufDestroy(&tempValue->name);
-        ffStrbufDestroy(&tempValue->deviceClass);
-    }
-    result /= temps.length;
-    return result;
-}
-
-const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
-{
-    FF_UNUSED(instance);
-
-    CFMutableDictionaryRef matchDict = IOServiceMatching("AppleSmartBattery");
-    if (matchDict == NULL)
-        return "IOServiceMatching(\"AppleSmartBattery\") failed";
-
     io_iterator_t iterator;
-    if(IOServiceGetMatchingServices(MACH_PORT_NULL, matchDict, &iterator) != kIOReturnSuccess)
+    if(IOServiceGetMatchingServices(MACH_PORT_NULL, IOServiceMatching("AppleSmartBattery"), &iterator) != kIOReturnSuccess)
         return "IOServiceGetMatchingServices() failed";
 
     io_registry_entry_t registryEntry;
     while((registryEntry = IOIteratorNext(iterator)) != 0)
     {
-        CFMutableDictionaryRef properties;
+        FF_CFTYPE_AUTO_RELEASE CFMutableDictionaryRef properties = NULL;
         if(IORegistryEntryCreateCFProperties(registryEntry, &properties, kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
         {
             IOObjectRelease(registryEntry);
@@ -53,8 +24,14 @@ const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
         bool boolValue;
         const char* error;
 
-        BatteryResult* battery = ffListAdd(results);
+        FFBatteryResult* battery = ffListAdd(results);
+        battery->temperature = FF_BATTERY_TEMP_UNSET;
+        ffStrbufInit(&battery->manufacturer);
+        ffStrbufInit(&battery->modelName);
+        ffStrbufInit(&battery->technology);
+        ffStrbufInit(&battery->status);
         battery->capacity = 0.0/0.0;
+
         int currentCapacity, maxCapacity;
 
         if ((error = ffCfDictGetInt(properties, CFSTR("MaxCapacity"), &maxCapacity)))
@@ -69,36 +46,38 @@ const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
 
         battery->capacity = currentCapacity * 100.0 / maxCapacity;
 
-        ffStrbufInit(&battery->manufacturer);
-        ffStrbufInit(&battery->modelName);
-        ffStrbufInit(&battery->technology);
+        ffCfDictGetString(properties, CFSTR("DeviceName"), &battery->modelName);
+
         if (!ffCfDictGetBool(properties, CFSTR("built-in"), &boolValue) && boolValue)
         {
             ffStrbufAppendS(&battery->manufacturer, "Apple Inc.");
-            ffStrbufAppendS(&battery->modelName, "Builtin");
             ffStrbufAppendS(&battery->technology, "Lithium");
+            if (!battery->modelName.length)
+                ffStrbufAppendS(&battery->modelName, "Built-in");
         }
+
+        ffCfDictGetInt(properties, CFSTR("CycleCount"), (int32_t*) &battery->cycleCount);
+
+        if (!ffCfDictGetBool(properties, CFSTR("ExternalConnected"), &boolValue) && boolValue)
+            ffStrbufAppendS(&battery->status, "AC connected, ");
         else
+            ffStrbufAppendS(&battery->status, "Discharging, ");
+        if (!ffCfDictGetBool(properties, CFSTR("IsCharging"), &boolValue) && boolValue)
+            ffStrbufAppendS(&battery->status, "Charging, ");
+        if (!ffCfDictGetBool(properties, CFSTR("AtCriticalLevel"), &boolValue) && boolValue)
+            ffStrbufAppendS(&battery->status, "Critical, ");
+        ffStrbufTrimRight(&battery->status, ' ');
+        ffStrbufTrimRight(&battery->status, ',');
+
+        if (options->temp)
         {
-            ffStrbufAppendS(&battery->manufacturer, "Unknown");
-            ffStrbufAppendS(&battery->modelName, "Unknown");
-            ffStrbufAppendS(&battery->technology, "Unknown");
+            int64_t temp;
+            if (!ffCfDictGetInt64(properties, CFSTR("Temperature"), &temp))
+                battery->temperature = (double) temp / 10 - 273.15;
+            else
+                ffDetectCoreTemps(FF_TEMP_BATTERY, &battery->temperature);
         }
 
-        ffStrbufInit(&battery->status);
-        if (!ffCfDictGetBool(properties, CFSTR("FullyCharged"), &boolValue) && boolValue)
-            ffStrbufAppendS(&battery->status, "Fully charged");
-        else if (!ffCfDictGetBool(properties, CFSTR("IsCharging"), &boolValue) && boolValue)
-            ffStrbufAppendS(&battery->status, "Charging");
-        else
-            ffStrbufAppendS(&battery->status, "");
-
-        if(instance->config.batteryTemp)
-            battery->temperature = detectBatteryTemp();
-        else
-            battery->temperature = FF_BATTERY_TEMP_UNSET;
-
-        CFRelease(properties);
         IOObjectRelease(registryEntry);
     }
 

src/detection/battery/battery_bsd.c

@@ -1,4 +1,6 @@
 #include "fastfetch.h"
+#include "common/sysctl.h"
+#include "common/io/io.h"
 #include "battery.h"
 
 #include <dev/acpica/acpiio.h>
@@ -6,41 +8,42 @@
 #include <sys/fcntl.h>
 #include <unistd.h>
 
-const char* ffDetectBatteryImpl(FF_MAYBE_UNUSED FFinstance* instance, FFlist* results)
+const char* ffDetectBattery(FF_MAYBE_UNUSED FFBatteryOptions* options, FFlist* results)
 {
     //https://www.freebsd.org/cgi/man.cgi?acpi_battery(4)
     //https://gitlab.xfce.org/panel-plugins/xfce4-battery-plugin/-/blob/master/panel-plugin/libacpi.c
 
-    int acpifd = open("/dev/acpi", O_RDONLY);
+    int units = ffSysctlGetInt("hw.acpi.battery.units", -100);
+    if (units < 0)
+        return "sysctlbyname(\"hw.acpi.battery.units\") failed";
+
+    if(units == 0)
+        return NULL;
+
+    FF_AUTO_CLOSE_FD int acpifd = open("/dev/acpi", O_RDONLY);
     if(acpifd < 0)
         return "open(\"/dev/acpi\", O_RDONLY) failed";
 
-    int units = ioctl(acpifd, ACPIIO_BATT_GET_UNITS, 0);
-    if(units < 0)
-    {
-        close(acpifd);
-        return "No acpiio battery units found";
-    }
-
     for(int i = 0; i < units; ++i)
     {
         union acpi_battery_ioctl_arg battio;
         battio.unit = i;
 
-        if(ioctl(acpifd, ACPIIO_BATT_GET_BATTINFO, &battio) < 0 || (battio.battinfo.state & ACPI_BATT_STAT_NOT_PRESENT))
+        if(ioctl(acpifd, ACPIIO_BATT_GET_BATTINFO, &battio) < 0 || (battio.battinfo.state == ACPI_BATT_STAT_NOT_PRESENT))
             continue;
 
-        BatteryResult* battery = ffListAdd(results);
+        FFBatteryResult* battery = ffListAdd(results);
         battery->temperature = FF_BATTERY_TEMP_UNSET;
+        battery->cycleCount = 0;
         ffStrbufInit(&battery->manufacturer);
         ffStrbufInit(&battery->modelName);
         ffStrbufInit(&battery->status);
         ffStrbufInit(&battery->technology);
 
         battery->capacity = battio.battinfo.cap;
-        if(battio.battinfo.state & ACPI_BATT_STAT_INVALID)
+        if(battio.battinfo.state == ACPI_BATT_STAT_INVALID)
         {
-            ffStrbufAppendS(&battery->status, "Invalid");
+            ffStrbufAppendS(&battery->status, "Unknown, ");
         }
         else
         {
@@ -49,11 +52,27 @@ const char* ffDetectBatteryImpl(FF_MAYBE_UNUSED FFinstance* instance, FFlist* re
             else if(battio.battinfo.state & ACPI_BATT_STAT_CHARGING)
                 ffStrbufAppendS(&battery->status, "Charging, ");
             if(battio.battinfo.state & ACPI_BATT_STAT_CRITICAL)
-                ffStrbufAppendS(&battery->status, "Ctritical");
+                ffStrbufAppendS(&battery->status, "Ctritical, ");
+        }
+
+        int acadStatus;
+        if (ioctl(acpifd, ACPIIO_ACAD_GET_STATUS, &acadStatus) >= 0 && acadStatus)
+        {
+            ffStrbufAppendS(&battery->status, "AC connected");
+        }
+        else
+        {
             ffStrbufTrimRight(&battery->status, ' ');
             ffStrbufTrimRight(&battery->status, ',');
         }
+
+        battio.unit = i;
+        if (ioctl(acpifd, ACPIIO_BATT_GET_BIX, &battio) >= 0)
+        {
+            ffStrbufAppendS(&battery->manufacturer, battio.bix.oeminfo);
+            ffStrbufAppendS(&battery->modelName, battio.bix.model);
+            ffStrbufAppendS(&battery->technology, battio.bix.type);
+        }
     }
-    close(acpifd);
     return NULL;
 }

src/detection/battery/battery_linux.c

@@ -1,15 +1,15 @@
-#include "fastfetch.h"
-#include "common/io.h"
 #include "battery.h"
+#include "common/io/io.h"
+#include "detection/temps/temps_linux.h"
+#include "util/stringUtils.h"
 
 #include <dirent.h>
 
-static void parseBattery(FFstrbuf* dir, FFlist* results)
+static void parseBattery(FFstrbuf* dir, const char* id, FFBatteryOptions* options, FFlist* results)
 {
     uint32_t dirLength = dir->length;
 
-    FFstrbuf testBatteryBuffer;
-    ffStrbufInit(&testBatteryBuffer);
+    FF_STRBUF_AUTO_DESTROY testBatteryBuffer = ffStrbufCreate();
 
     //type must exist and be "Battery"
     ffStrbufAppendS(dir, "/type");
@@ -17,10 +17,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
     ffStrbufSubstrBefore(dir, dirLength);
 
     if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Battery") != 0)
-    {
-        ffStrbufDestroy(&testBatteryBuffer);
         return;
-    }
 
     //scope may not exist or must not be "Device"
     ffStrbufAppendS(dir, "/scope");
@@ -28,12 +25,9 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
     ffStrbufSubstrBefore(dir, dirLength);
 
     if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Device") == 0)
-    {
-        ffStrbufDestroy(&testBatteryBuffer);
         return;
-    }
 
-    BatteryResult* result = ffListAdd(results);
+    FFBatteryResult* result = ffListAdd(results);
 
     //capacity must exist and be not empty
     ffStrbufAppendS(dir, "/capacity");
@@ -41,7 +35,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
     ffStrbufSubstrBefore(dir, dirLength);
     if(available)
         result->capacity = ffStrbufToDouble(&testBatteryBuffer);
-    ffStrbufDestroy(&testBatteryBuffer);
+
     if(!available)
     {
         result->capacity = 0.0/0.0;
@@ -71,15 +65,35 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
     ffReadFileBuffer(dir->chars, &result->status);
     ffStrbufSubstrBefore(dir, dirLength);
 
+    ffStrbufAppendS(dir, "/cycle_count");
+    ffReadFileBuffer(dir->chars, &testBatteryBuffer);
+    ffStrbufSubstrBefore(dir, dirLength);
+    if(dir->length)
+        result->cycleCount = (uint32_t) ffStrbufToUInt(&testBatteryBuffer, 0);
+
     result->temperature = FF_BATTERY_TEMP_UNSET;
+    if (options->temp)
+    {
+        const FFlist* tempsResult = ffDetectTemps();
+
+        FF_LIST_FOR_EACH(FFTempValue, value, *tempsResult)
+        {
+            if (ffStrbufEqualS(&value->name, id))
+            {
+                result->temperature = value->value;
+                break;
+            }
+        }
+    }
 }
 
-const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
-    FFstrbuf baseDir;
-    ffStrbufInitA(&baseDir, 64);
-    if(instance->config.batteryDir.length > 0)
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
+{
+    FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
+
+    if(options->dir.length > 0)
     {
-        ffStrbufAppend(&baseDir, &instance->config.batteryDir);
+        ffStrbufAppend(&baseDir, &options->dir);
         ffStrbufEnsureEndsWithC(&baseDir, '/');
     }
     else
@@ -89,31 +103,23 @@ const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
 
     uint32_t baseDirLength = baseDir.length;
 
-    DIR* dirp = opendir(baseDir.chars);
+    FF_AUTO_CLOSE_DIR DIR* dirp = opendir(baseDir.chars);
     if(dirp == NULL)
-    {
-        ffStrbufDestroy(&baseDir);
         return "opendir(batteryDir) == NULL";
-    }
 
     struct dirent* entry;
     while((entry = readdir(dirp)) != NULL)
     {
-        if(strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+        if(ffStrEquals(entry->d_name, ".") || ffStrEquals(entry->d_name, ".."))
             continue;
 
         ffStrbufAppendS(&baseDir, entry->d_name);
-        parseBattery(&baseDir, results);
+        parseBattery(&baseDir, entry->d_name, options, results);
         ffStrbufSubstrBefore(&baseDir, baseDirLength);
     }
 
-    closedir(dirp);
-
-    if(results->length == 0) {
-        ffStrbufDestroy(&baseDir);
+    if(results->length == 0)
         return "batteryDir doesn't contain any battery folder";
-    }
 
-    ffStrbufDestroy(&baseDir);
     return NULL;
 }

src/detection/battery/battery_nosupport.c

@@ -1,8 +1,8 @@
 #include "fastfetch.h"
 #include "battery.h"
 
-const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
-    FF_UNUSED(instance, results)
+    FF_UNUSED(options, results)
     return "Not supported on this platform";
 }

src/detection/battery/battery_windows.c

@@ -2,11 +2,22 @@
 #include "util/windows/unicode.h"
 #include "util/mallocHelper.h"
 
+#undef WIN32_LEAN_AND_MEAN
+#include <windows.h>
 #include <setupapi.h>
 #include <batclass.h>
 #include <devguid.h>
 #include <winternl.h>
-#include <powrprof.h>
+
+NTSYSCALLAPI
+NTSTATUS
+NTAPI
+NtPowerInformation(
+    IN POWER_INFORMATION_LEVEL InformationLevel,
+    IN PVOID InputBuffer OPTIONAL,
+    IN ULONG InputBufferLength,
+    OUT PVOID OutputBuffer OPTIONAL,
+    IN ULONG OutputBufferLength);
 
 static inline void wrapCloseHandle(HANDLE* handle)
 {
@@ -19,140 +30,146 @@ static inline void wrapSetupDiDestroyDeviceInfoList(HDEVINFO* hdev)
         SetupDiDestroyDeviceInfoList(*hdev);
 }
 
-const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
+static const char* detectWithSetupApi(FFBatteryOptions* options, FFlist* results)
 {
-    if(instance->config.allowSlowOperations)
+    //https://learn.microsoft.com/en-us/windows/win32/power/enumerating-battery-devices
+    HDEVINFO hdev __attribute__((__cleanup__(wrapSetupDiDestroyDeviceInfoList))) =
+        SetupDiGetClassDevsW(&GUID_DEVCLASS_BATTERY, 0, 0, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+    if(hdev == INVALID_HANDLE_VALUE)
+        return "SetupDiGetClassDevsW(&GUID_DEVCLASS_BATTERY) failed";
+
+    SP_DEVICE_INTERFACE_DATA did = { .cbSize = sizeof(did) };
+    for(DWORD idev = 0; SetupDiEnumDeviceInterfaces(hdev, NULL, &GUID_DEVCLASS_BATTERY, idev, &did); idev++)
     {
-        //https://learn.microsoft.com/en-us/windows/win32/power/enumerating-battery-devices
-        HDEVINFO hdev __attribute__((__cleanup__(wrapSetupDiDestroyDeviceInfoList))) =
-            SetupDiGetClassDevs(&GUID_DEVCLASS_BATTERY, 0, 0, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
-        if(hdev == INVALID_HANDLE_VALUE)
-            return "SetupDiGetClassDevs(&GUID_DEVCLASS_BATTERY) failed";
+        DWORD cbRequired = 0;
+        SetupDiGetDeviceInterfaceDetailW(hdev, &did, NULL, 0, &cbRequired, NULL); //Fail with not enough buffer
+        SP_DEVICE_INTERFACE_DETAIL_DATA_W* FF_AUTO_FREE pdidd = (SP_DEVICE_INTERFACE_DETAIL_DATA_W*)malloc(cbRequired);
+        if(!pdidd)
+            break; //Out of memory
+
+        pdidd->cbSize = sizeof(*pdidd);
+        if(!SetupDiGetDeviceInterfaceDetailW(hdev, &did, pdidd, cbRequired, &cbRequired, NULL))
+            continue;
+
+        HANDLE __attribute__((__cleanup__(wrapCloseHandle))) hBattery =
+            CreateFileW(pdidd->DevicePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+        if(hBattery == INVALID_HANDLE_VALUE)
+            continue;
+
+        BATTERY_QUERY_INFORMATION bqi = { .InformationLevel = BatteryInformation };
+
+        DWORD dwWait = 0;
+        DWORD dwOut;
+
+        if(!DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_TAG, &dwWait, sizeof(dwWait), &bqi.BatteryTag, sizeof(bqi.BatteryTag), &dwOut, NULL) && bqi.BatteryTag)
+            continue;
+
+        BATTERY_INFORMATION bi = {0};
+        if(!DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), &bi, sizeof(bi), &dwOut, NULL))
+            continue;
+
+        if(!(bi.Capabilities & BATTERY_SYSTEM_BATTERY))
+            continue;
+
+        FFBatteryResult* battery = (FFBatteryResult*)ffListAdd(results);
+
+        if(memcmp(bi.Chemistry, "PbAc", 4) == 0)
+            ffStrbufInitS(&battery->technology, "Lead Acid");
+        else if(memcmp(bi.Chemistry, "LION", 4) == 0 || memcmp(bi.Chemistry, "Li-I", 4) == 0)
+            ffStrbufInitS(&battery->technology, "Lithium Ion");
+        else if(memcmp(bi.Chemistry, "NiCd", 4) == 0)
+            ffStrbufInitS(&battery->technology, "Nickel Cadmium");
+        else if(memcmp(bi.Chemistry, "NiMH", 4) == 0)
+            ffStrbufInitS(&battery->technology, "Nickel Metal Hydride");
+        else if(memcmp(bi.Chemistry, "NiZn", 4) == 0)
+            ffStrbufInitS(&battery->technology, "Nickel Zinc");
+        else if(memcmp(bi.Chemistry, "RAM\0", 4) == 0)
+            ffStrbufInitS(&battery->technology, "Rechargeable Alkaline-Manganese");
+        else
+            ffStrbufInitS(&battery->technology, "Unknown");
 
-        for(DWORD idev = 0;; idev++)
         {
-            SP_DEVICE_INTERFACE_DATA did = { .cbSize = sizeof(did) };
-            if(!SetupDiEnumDeviceInterfaces(hdev, NULL, &GUID_DEVCLASS_BATTERY, idev, &did))
-                break;
-
-            DWORD cbRequired = 0;
-            SetupDiGetDeviceInterfaceDetailW(hdev, &did, NULL, 0, &cbRequired, NULL); //Fail with not enough buffer
-            SP_DEVICE_INTERFACE_DETAIL_DATA_W* FF_AUTO_FREE pdidd = (SP_DEVICE_INTERFACE_DETAIL_DATA_W*)malloc(cbRequired);
-            if(!pdidd)
-                break; //Out of memory
-
-            pdidd->cbSize = sizeof(*pdidd);
-            if(!SetupDiGetDeviceInterfaceDetailW(hdev, &did, pdidd, cbRequired, &cbRequired, NULL))
-                continue;
-
-            HANDLE __attribute__((__cleanup__(wrapCloseHandle))) hBattery =
-                CreateFileW(pdidd->DevicePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-
-            if(hBattery == INVALID_HANDLE_VALUE)
-                continue;
-
-            BATTERY_QUERY_INFORMATION bqi = { .InformationLevel = BatteryInformation };
-
-            DWORD dwWait = 0;
-            DWORD dwOut;
-
-            if(!DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_TAG, &dwWait, sizeof(dwWait), &bqi.BatteryTag, sizeof(bqi.BatteryTag), &dwOut, NULL) && bqi.BatteryTag)
-                continue;
-
-            BATTERY_INFORMATION bi = {0};
-            if(!DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), &bi, sizeof(bi), &dwOut, NULL))
-                continue;
-
-            if(!(bi.Capabilities & BATTERY_SYSTEM_BATTERY))
-                continue;
-
-            BatteryResult* battery = (BatteryResult*)ffListAdd(results);
-
-            if(memcmp(bi.Chemistry, "PbAc", 4) == 0)
-                ffStrbufInitS(&battery->technology, "Lead Acid");
-            else if(memcmp(bi.Chemistry, "LION", 4) == 0 || memcmp(bi.Chemistry, "Li-I", 4) == 0)
-                ffStrbufInitS(&battery->technology, "Lithium Ion");
-            else if(memcmp(bi.Chemistry, "NiCd", 4) == 0)
-                ffStrbufInitS(&battery->technology, "Nickel Cadmium");
-            else if(memcmp(bi.Chemistry, "NiMH", 4) == 0)
-                ffStrbufInitS(&battery->technology, "Nickel Metal Hydride");
-            else if(memcmp(bi.Chemistry, "NiZn", 4) == 0)
-                ffStrbufInitS(&battery->technology, "Nickel Zinc");
-            else if(memcmp(bi.Chemistry, "RAM\0", 4) == 0)
-                ffStrbufInitS(&battery->technology, "Rechargeable Alkaline-Manganese");
-            else
-                ffStrbufInitS(&battery->technology, "Unknown");
-
-            {
-                ffStrbufInit(&battery->modelName);
-                bqi.InformationLevel = BatteryDeviceName;
-                wchar_t name[64];
-                if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), name, sizeof(name), &dwOut, NULL))
-                    ffStrbufSetWS(&battery->modelName, name);
-            }
-
-            {
-                ffStrbufInit(&battery->manufacturer);
-                bqi.InformationLevel = BatteryManufactureName;
-                wchar_t name[64];
-                if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), name, sizeof(name), &dwOut, NULL))
-                    ffStrbufSetWS(&battery->manufacturer, name);
-            }
-
-            battery->temperature = 0.0/0.0;
-            if(instance->config.batteryTemp)
-            {
-                bqi.InformationLevel = BatteryTemperature;
-                ULONG temp;
-                if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), &temp, sizeof(temp), &dwOut, NULL))
-                    battery->temperature = temp;
-            }
-
-            {
-                BATTERY_STATUS bs;
-                BATTERY_WAIT_STATUS bws = { .BatteryTag = bqi.BatteryTag };
-                if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_STATUS, &bws, sizeof(bws), &bs, sizeof(bs), &dwOut, NULL) && bs.Capacity != BATTERY_UNKNOWN_CAPACITY)
-                    battery->capacity = bs.Capacity * 100.0 / bi.FullChargedCapacity;
-                else
-                    battery->capacity = 0;
-
-                ffStrbufInit(&battery->status);
-                if(bs.PowerState & BATTERY_POWER_ON_LINE)
-                    ffStrbufAppendS(&battery->status, "AC Connected, ");
-                if(bs.PowerState & BATTERY_DISCHARGING)
-                    ffStrbufAppendS(&battery->status, "Discharging, ");
-                if(bs.PowerState & BATTERY_CHARGING)
-                    ffStrbufAppendS(&battery->status, "Charging");
-                if(bs.PowerState & BATTERY_CRITICAL)
-                    ffStrbufAppendS(&battery->status, "Critical, ");
-                ffStrbufTrimRight(&battery->status, ' ');
-                ffStrbufTrimRight(&battery->status, ',');
-            }
-        }
-    }
-    else
-    {
-        SYSTEM_BATTERY_STATE info;
-        if (NT_SUCCESS(CallNtPowerInformation(SystemBatteryState, NULL, 0, &info, sizeof(info))) && info.BatteryPresent)
-        {
-            BatteryResult* battery = (BatteryResult*)ffListAdd(results);
             ffStrbufInit(&battery->modelName);
-            ffStrbufInit(&battery->manufacturer);
-            ffStrbufInit(&battery->technology);
-            ffStrbufInit(&battery->status);
-            battery->temperature = 0.0/0.0;
+            bqi.InformationLevel = BatteryDeviceName;
+            wchar_t name[64];
+            if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), name, sizeof(name), &dwOut, NULL))
+                ffStrbufSetWS(&battery->modelName, name);
+        }
 
-            battery->capacity = info.RemainingCapacity * 100.0 / info.MaxCapacity;
-            if(info.AcOnLine)
-            {
-                ffStrbufAppendS(&battery->status, "AC Connected");
-                if(info.Charging)
-                    ffStrbufAppendS(&battery->status, ", Charging");
-            }
-            else if(info.Discharging)
-                ffStrbufAppendS(&battery->status, "Discharging");
+        {
+            ffStrbufInit(&battery->manufacturer);
+            bqi.InformationLevel = BatteryManufactureName;
+            wchar_t name[64];
+            if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), name, sizeof(name), &dwOut, NULL))
+                ffStrbufSetWS(&battery->manufacturer, name);
+        }
+
+        battery->cycleCount = bi.CycleCount;
+
+        battery->temperature = 0.0/0.0;
+        if(options->temp)
+        {
+            bqi.InformationLevel = BatteryTemperature;
+            ULONG temp;
+            if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), &temp, sizeof(temp), &dwOut, NULL))
+                battery->temperature = temp;
+        }
+
+        {
+            BATTERY_STATUS bs;
+            BATTERY_WAIT_STATUS bws = { .BatteryTag = bqi.BatteryTag };
+            if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_STATUS, &bws, sizeof(bws), &bs, sizeof(bs), &dwOut, NULL) && bs.Capacity != BATTERY_UNKNOWN_CAPACITY)
+                battery->capacity = bs.Capacity * 100.0 / bi.FullChargedCapacity;
+            else
+                battery->capacity = 0;
+
+            ffStrbufInit(&battery->status);
+            if(bs.PowerState & BATTERY_POWER_ON_LINE)
+                ffStrbufAppendS(&battery->status, "AC Connected, ");
+            if(bs.PowerState & BATTERY_DISCHARGING)
+                ffStrbufAppendS(&battery->status, "Discharging, ");
+            if(bs.PowerState & BATTERY_CHARGING)
+                ffStrbufAppendS(&battery->status, "Charging, ");
+            if(bs.PowerState & BATTERY_CRITICAL)
+                ffStrbufAppendS(&battery->status, "Critical, ");
+            ffStrbufTrimRight(&battery->status, ' ');
+            ffStrbufTrimRight(&battery->status, ',');
         }
     }
-
     return NULL;
 }
+
+static const char* detectWithNtApi(FF_MAYBE_UNUSED FFBatteryOptions* options, FFlist* results)
+{
+    SYSTEM_BATTERY_STATE info;
+    if (NT_SUCCESS(NtPowerInformation(SystemBatteryState, NULL, 0, &info, sizeof(info))) && info.BatteryPresent)
+    {
+        FFBatteryResult* battery = (FFBatteryResult*)ffListAdd(results);
+        ffStrbufInit(&battery->modelName);
+        ffStrbufInit(&battery->manufacturer);
+        ffStrbufInit(&battery->technology);
+        ffStrbufInit(&battery->status);
+        battery->temperature = 0.0/0.0;
+        battery->cycleCount = 0;
+
+        battery->capacity = info.RemainingCapacity * 100.0 / info.MaxCapacity;
+        if(info.AcOnLine)
+        {
+            ffStrbufAppendS(&battery->status, "AC Connected");
+            if(info.Charging)
+                ffStrbufAppendS(&battery->status, ", Charging");
+        }
+        else if(info.Discharging)
+            ffStrbufAppendS(&battery->status, "Discharging");
+        return NULL;
+    }
+    return "NtPowerInformation(SystemBatteryState) failed";
+}
+
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
+{
+    return true
+        ? detectWithSetupApi(options, results)
+        : detectWithNtApi(options, results);
+}