Release 1.11.2 before merging #432

Also change `--*-ip-*` to `--*ip-*` to be consistant to my config branch

.editorconfig

@@ -10,7 +10,7 @@ trim_trailing_whitespace = true
 [*.{md,fflogo}]
 trim_trailing_whitespace = false
 
-[*.{txt,fflogo}]
+[*.{fflogo}]
 insert_final_newline = false
 
 [*.yml]

.github/FUNDING.yml

@@ -1 +1 @@
-custom: paypal.me/linusdierheimer
+github: [LinusDierheimer, CarterLi]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,6 +7,13 @@ assignees: ''
 
 ---
 
+# General description of bug:
+
+
+# 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]
+
 Output of `fastfetch --version`:
 ```
 //paste here
@@ -18,6 +25,9 @@ Output of `fastfetch --load-config devinfo`:
 ```
 
 Output of `fastfetch --load-config devinfo-verbose`:
+<!--
+Note that this output will contain you public IP. If it is not relevant for the issue, feel free to remove it before uploading.
+-->
 ```
 //paste here
 ```
@@ -27,9 +37,7 @@ 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 to much work) for you, post the output of `fastfetch --show-errors --recache --multithreading false --disable-linewrap false`.
-
-Often helpful questions:
-* Does the issue occur across multiple terminal emulators?
-* Does the issue occur across multiple shells? (bash, zsh, fish, etc)
+If this isn't possible (or too much work) for you, post the output of `fastfetch --show-errors --multithreading false --disable-linewrap false`. 
+-->

.github/ISSUE_TEMPLATE/logo_request.md

@@ -0,0 +1,18 @@
+---
+name: Logo request
+about: Request a new logo
+title: ''
+labels: logo request
+assignees: ''
+
+---
+
+# OS
+```
+paste content of /etc/os-release here. If this file doesn't exist, describe a way to identify the distro.
+```
+
+# Ascii
+```
+paste ascii art here. If you leave this empty, i will try to find the logo myself.
+```

.github/workflows/pull_request.yml

@@ -1,37 +0,0 @@
-name: manage pull requests
-
-on: pull_request
-
-jobs:
-  check:
-    name: manage pull request
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v2
-
-      - 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 rpm librpm-dev libzstd-dev
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
-
-      - name: configure project
-        run: cmake -DBUILD_TESTS=On .
-
-      - name: build project
-        run: cmake --build . -j$(nproc) --target package
-
-      - name: run fastfetch
-        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
-
-      - name: run flashfetch
-        run: ./flashfetch
-
-      - name: run tests
-        run: ctest
-
-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v1

.github/workflows/push.yml

@@ -1,49 +1,304 @@
 name: manage pushes
 
 on:
-  push:
-    branches: [ master ]
+  - push
+  - pull_request
 
 jobs:
-  manage:
-    name: manage push
-    runs-on: ubuntu-latest
+  linux-buildtest:
+    name: Linux build test
     permissions:
-      contents: write
-      security-events: write
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, ubuntu-20.04]
+        compiler: [gcc, clang]
+        enableFeatures: [ON, OFF]
+    runs-on: ${{ matrix.os }}
     steps:
       - name: checkout repository
-        uses: actions/checkout@v2
+        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 rpm librpm-dev libzstd-dev
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
+        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 libcjson-dev
 
       - name: configure project
-        # We reuse the build binary only for the releases.
-        # We set tweak version to off, because it is wrong, as git tag will happen after this step. Releases don't have a tweak, so this is ok.
-        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+        env:
+          CC: ${{ matrix.compiler }}
+        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_JSONC=${{ matrix.enableFeatures }} .
 
       - name: build project
-        run: cmake --build . -j$(nproc) --target package
-
-      - name: run fastfetch
-        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
-
-      - name: run flashfetch
-        run: ./flashfetch
+        run: cmake --build .
 
       - name: run tests
         run: ctest
 
+      - name: run fastfetch
+        run: ./fastfetch --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
+
+      - name: run flashfetch
+        run: ./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@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 libnm-dev libpulse-dev libcjson-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@v1
+        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: get_version_fastfetch
-        run: echo "::set-output name=release::$(./fastfetch --version-raw)"
+        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-*.*
+
+  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@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-vulkan-loader mingw-w64-clang-x86_64-opencl-icd mingw-w64-clang-x86_64-cjson
+
+      - 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=/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,OpenCL,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)-Win64.zip *.dll fastfetch.exe flashfetch.exe
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-win64
+          path: ./fastfetch-*-Win64.zip
+
+  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@v3
+
+      - name: setup-msys2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: CLANG32
+          update: true
+          install: git zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-opencl-icd mingw-w64-clang-i686-cjson
+
+      - 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 .
+
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v2
+
+      - name: copy necessary dlls
+        run: cp /clang32/bin/{libcjson,OpenCL,vulkan-1}.dll .
+
+      - 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)-Win32.zip *.dll fastfetch.exe flashfetch.exe
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-win32
+          path: ./fastfetch-*-Win32.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
+      - win64
+      - win32
+    permissions:
+      contents: write
+    steps:
+      - name: download artifacts
+        uses: actions/download-artifact@v3
 
       - name: get latest release version
         id: get_version_release
@@ -52,9 +307,10 @@ jobs:
           repository: ${{ github.repository }}
 
       - name: create release
-        if: steps.get_version_fastfetch.outputs.release != steps.get_version_release.outputs.release
+        if: needs.linux.outputs.ffversion != steps.get_version_release.outputs.release
         uses: ncipollo/release-action@v1
         with:
-          tag: ${{ steps.get_version_fastfetch.outputs.release }}
+          tag: ${{ needs.linux.outputs.ffversion }}
           commit: ${{ github.sha }}
-          artifacts: ./fastfetch-*.*
+          artifactErrorsFailBuild: true
+          artifacts: fastfetch-linux/*,fastfetch-macos/*,fastfetch-freebsd/*,fastfetch-win64/*,fastfetch-win32/*

.gitignore

@@ -2,8 +2,8 @@
 **/.vscode/
 **/.cache/
 **/.kdev4/
+**/.DS_Store
+/.vs
 cscope.*
 tags
 fastfetch.kdev4
-**/*.deb
-packaging/deb/fastfetch

CHANGELOG.md

@@ -0,0 +1,406 @@
+# 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:
+
+* Fix builds on s390x (@jonathanspw, #402)
+* Fix zero refresh rate on some monitors (macOS)
+* Fix default formatting of Wifi module
+
+# 1.9.0
+
+Notable Changes:
+* fastfetch no longer creates a sample config file silently. Use `--gen-config` to generate one.
+* fastfetch now search for user config file in the order of `fastfetch --list-config-paths`
+* Unknown disks are hidden by default.
+* `Resolution` module is renamed to `Display`. (#393)
+
+Features:
+* `--logo-padding-top` option (@CarterLi, #372)
+* Raw image file as logo support (@CarterLi)
+* Look for config files in `$APPDATA` ([RoamingAppData](https://superuser.com/questions/21458/why-are-there-directories-called-local-locallow-and-roaming-under-users-user#answer-21462)) (Windows)
+* Look for config files in `~/Library/Preferences` (macOS)
+* Add `--list-config-paths` option which list search paths of config files
+* Add `--list-data-paths` option which list search paths for presets and logos
+* Add `Brightness` module support
+* Add `Battery` module support for FreeBSD
+* Add `--disk-show-unknown` option for Disk module
+* Add `--disk-show-subvolumes` option for Disk module
+* Add `--gpu-hide-integrated` option (#379)
+* Add `--gpu-hide-discrete` option (#379)
+* Detect terminal version when available
+* Support `WezTerm` terminal font detection (requires [`wezterm` executable](https://wezfurlong.org/wezterm/cli/general.html) being available)
+* Add `--shell-version` and `--terminal-version` options to disable shell / terminal version detection
+* Enhance `--percent-type` to allow hiding other texts (#387)
+* Add Wifi module support for Linux
+* Detect scaled resolutions (Windows, macOS)
+* Optimise font module printing (Windows)
+* Detect pacman package count inside MSYS2 environment (Windows)
+* Add Wifi / Battery module support for Android
+* Disk name support for Linux
+
+Logos:
+* Raspbian (@IamNoRobot, #373)
+
+Bugfixes:
+* `--logo-type` now does accept `iterm` too (@CarterLi, #374)
+* Fix mintty terminal font detection (Windows)
+* Fix bug that line buffering doesn't work properly (Windows)
+* Fix rpm package count detection (Linux)
+* Fix cpu temp detection (Linux)
+
+Other:
+* Fixed a Typo in iterm error message (@jessebot, #376)
+* Don't try to load config file in `/etc` (Windows)
+
+# 1.8.2
+
+Bugfixes:
+
+* Fix memleaks Users module (Windows)
+* Fix shell detection when installed with scoop (Windows)
+* Don't use libcJSON as wlanapi's dll name (Windows)
+* Align artifact names to other platforms (Windows)
+
+# 1.8.1
+
+Notable Changes:
+
+* `Song` was used as an alias to `Media` module. It's removed to avoid confusion. All song related flags (`--song-key`, etc) should change to media (`--media-key`, etc). (@CarterLi)
+
+Bugfixes:
+
+* Mountpoint paths on linux get decoded correctly (#364)
+* Color parsing once again works (@IanManske, #365)
+* Using a custom key with a placeholder for the local ip module now does work correctly if multiple interfaces are present (#368)
+
+# 1.8.0
+
+This release introduces Windows support! Fastfetch now fully support all major desktop OSes (Linux, macOS, Windows and FreeBSD)
+
+Notable Changes:
+* Bios / Board / Chassis modules are splitted against Host module for performance reasons
+* Caching is removed. Option `--nocache` is removed accordingly
+
+Features:
+* Windows (7 and newer) is officially and fully supported
+* FreeBSD support is improved greatly (Bios, Cpu Temp, Cpu Usage, Disk, Host, Processes, Swap, Terminal / Shell, Uptime)
+* Adds a new flag `--stat`, which prints time usage for individual modules
+* Adds Wifi module which supports Windows and macOS
+* Adds data source option for logo printing
+* Detects Homebrew Cellar and Cask seperately
+* Detects WSL version
+* Detects disk based on mount point
+* Exposes more chafa configs
+* Improves performance for Cpu Usage, Public IP, Weather modules
+* Improves performance for Kitty image protocol when both image width / height specified
+* Improves performance for large file loading
+* Improves performance for macOS WM and Host detection
+* Improves shell and terminal detection on macOS
+* Supports Deepin Terminal terminal font
+* Supports GPU detection on Android
+* Supports Kitty Terminal terminal font
+* Supports bar output for percentage values
+* Supports Bios module on macOS
+* Supports eopkg package manager detection
+* Supports iTerm image logo protocol
+* Supports image logo printing on macOS
+* Supports tcsh version detection
+* Vulkan module on macOS no longer requires vulkan-loader to work
+
+Logos:
+* Alpine
+* CRUX
+* EndeavourOS
+* Enso
+* Garuda small
+* Nobara
+* OpenMandriva
+* Parabola GNU/Linux-libre
+* Rocky
+* Rosa
+* Solus
+* Univalent
+* Vanilla OS
+
+Bugfixes:
+* Fixes disk size detection on 32bit Linux (#337)
+* Fixes cpu freq detection in WSL
+* Fixes internal bug of FFstrbuf
+* Fixes some memory leaks
+* Fixes segfault if 0 is given as argument index
+* Lots of code refactors
+
+# 1.7.5
+
+Fixes a crash on linux that could happen when getting zsh version (#285)
+
+# 1.7.4
+
+The last element in the default structure (currently the color blocks) is now printed again (#283)
+
+# 1.7.3
+
+A lot of small improvements for MacOS & BSD platforms.
+
+Features:
+* BSD is now officially supported (#228)
+* MacPorts package manager support (@SladeGetz, #234)
+* Battery support for MacOS (@CarterLi, #235)
+* Processes, swap & terminal font support for MacOS(@CarterLi, #237)
+* Media support for MacOS (@CarterLi, #242)
+* Player support for MacOS (@CarterLi, #245)
+* WM theme support for MacOS (@CarterLi, #246)
+* CPU usage support for MacOS (@CarterLi, #247)
+* Power Adapter module (@CarterLi, #249)
+* Windows terminal font for WSL (@CarterLi, #254)
+* Temps & Font support for MacOS (@CarterLi, #258)
+* Terminal font support for Termux (@CarterLi, #263)
+* Weather module (@CarterLi, #266)
+
+Logos
+* Crystal linux (@AloneER0, #239)
+* FreeBSD (@draumaz, #244)
+* New Ubuntu (@AloneER0, #259)
+
+Bugfixes:
+* Don't segfault in GPU code on Intel Macs (@CarterLi, #236)
+* Don't use hardcoded size units in presets (@dr460nf1r3, #255)
+* Don't crash with some format strings (#252)
+* --logo none keeps key color now (#264)
+
+# 1.7.2
+
+Fixes the bash completions
+
+# 1.7.1
+
+This release brings a lot of bug fixes and improvements for MacOS. Big thanks to @CarterLi for the help on this!
+
+Features:
+* The color of the title and the keys can now be configured individually, using `--color-keys` and `--color-title` respectively. Some distros have different defaults now, similar to neofetch
+* Swap module, similar to the Memory module, but for swap. Add `Swap` to your structure to enable it (#225)
+
+Logos:
+* Slackware (#227)
+
+Bugfixes:
+* Used disk space is now calculated much more accurately
+* On Linux, GPU names are no longer truncated, if they are longer than 32 characters (#224)
+* On Linux, NVIDIA GPUs once again have a proper name
+
+* On M1 platforms, showing the GPU name no longer crashes the program (#222)
+* Brew package count does now work on M1 platforms too
+* The Vulkan module now does work on MacOS too
+* The OpenGL and OpenCL modules now work on MacOS too (@CarterLi, #226)
+* The LocalIp module now works on MacOS too (@CarterLi, #232)
+* Detecting custom WMs on MacOS does now work
+
+Other:
+* GitHub actions now builds a dmg file for MacOS, as you can see in the release page
+
+# 1.7.0
+
+This release brings support for MacOS!
+The basics things are working, but it is far from feature parity with Linux.
+I developed this in a VM, so bugs on real hardware are likely.
+If you have a Mac and no idea what to do with your free time, i am very happy to accept pull requests / work on issues.
+
+A lot of things were changed under the hood to make this possible, which should bring better performance and stability on all platforms.
+
+Besides that, the following things have changed:
+
+Features:
+* The binary prefix used can now be configured, and is used consistently across all modules. Set `--binary-prefix` to `iec` (default), `si` or `jedec`.
+* AMD GPUs now have a much better name, if the file `/usr/share/libdrm/amdgpu.ids` exists. For example my dedicated GPU, which was displayed as `AMD/ATI Radeon RX 5600 OEM/5600 XT / 5700/5700 XT`, is now `AMD Radeon RX 5600M`.
+
+Logos:
+* MacOS
+* CachyOS small (@sirlucjan, #220)
+* MSYS2 (#219)
+
+Bugfixes:
+* the `--file` option, which can be used to display the contents of a file as the logo, is now working again.
+
+# 1.6.5
+
+Fixes parsing quoted values in config files
+
+# 1.6.4
+
+Releasing this, so fedora can package fastfetch. Thanks to @jonathanspw for doing that!
+
+Features:
+* --set-keyless option (#215)
+* Replace `\n`, `\t`, `\e` and `\\` in user provided strings, just like c would do it (#215)
+* APK (Alpine Package Keeper) support (@mxkrsv, #216)
+
+Logos:
+* Alma Linux (@jonathanspw, #214)
+
+Bugfixes:
+* replace deprecated gethostbyname call with getaddrinfo (#217)
+
+# 1.6.3
+
+Fixes installing presets in their own directory (@ceamac, #212)
+
+# 1.6.2
+
+Releasing this, so void linux can package fastfetch.
+
+Logos:
+* Rosa linux (#206)
+* KISS linux (@draumaz, #207)
+* LangitKetujuh (@hervyqa, #208)
+
+Bugfixes:
+* Using musl as libc does work now (#210)
+* XBPS packages are once again printed (#209)
+* configured target dirs are applied to install directories too
+* empty XDG_* env vars don't cause a crash anymore
+
+# 1.6.1
+
+Fixes build on android (#205)
+
+# 1.6.0
+
+Features:
+* Detect QT on more DEs than just KDE Plasma. The [Plasma] category was therefore renamed to [QT]
+* Alacritty font detection
+* Load `/etc/fastfetch/config.conf` before user config
+* Disk: print one decimal point if size < 100GB
+* `--title-fqdn` option, to print fully qualified domain name instead of host name in title
+
+Logos:
+* updated old NixOS logo
+
+Bugfixes:
+* Correctly detect GTK on DEs that store their settings in dconf
+* Correctly detect NixOS packages
+* Mutter WM detected once again
+* Show full NixOS version in OS output
+* Don't segfault if an invalid structure is given
+* WSL doesn't output GPU anymore, as the name is always meaningless

DEVELOPMENT.md

@@ -11,12 +11,6 @@ Here i just add things that are easy to forget.
   - `libffdetect`: contains all the detection stuff. To be used by anything that needs system information
   - `libffprint`: contains the printing functions, logos, format etc
   - `fastfetch` and `flashfetch`: Executables, that initialize the config of libffprint. Fist one at runtime, second one at compile time
-- [ ] Support for printing images as ascii art logos (using imlib2 and libcaca probably)
-- [ ] Better OS output for all possible combinations of /etc/os-release variables.
-- [ ] Expose temperatures to CPU format string
-- [ ] Expose temperatures to GPU format string
-- [ ] Fallback GPU detection using GL (multi GPU suport somehow possible?)
-- [ ] Find wayland compositor by looking at \${XDG_RUNTIME_DIR}/${WAYLAND_DISPLAY:-wayland-0}
 - [ ] Make LocalIP module more configurable
 - [ ] Automatic migrate old config files to newer versions
 - [ ] ZSH completions

README.md

@@ -1,103 +1,163 @@
-# fastfetch
+# Fastfetch
 
-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 in c to achieve much better performance, in return only Linux and Android are supported. It also uses mechanisms like multithreading and caching to finish as fast as possible.  
-  
-The output on my personal machine with default configurations looks like this:
-<img src="screenshots/example.png" alt="example output" width="100%"/>  
+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" />
+<img src="https://upload.wikimedia.org/wikipedia/commons/2/24/Transparent_Square_Tiles_Texture.png" width="49%" height="16px" align="left" />
+<img src="screenshots/example4.png" width="49%" align="left" />
+<img src="https://upload.wikimedia.org/wikipedia/commons/2/24/Transparent_Square_Tiles_Texture.png" width="49%" height="16px" align="left" />
+<img src="screenshots/example2.png" width="48%" align="top" />
+<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)
 
 ## Customization
 
-With customization and speed being two competing goals, this project actually builds two executables.  
-The main one being `fastfetch`, which can be very greatly configured via flags. These flags can be made persistent in `~/.config/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).  
-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 presets defined for fastfech in [`presets`](presets), you can can load them with `--load-config`. They may also serve as a good example for format arguments.
+With customization and speed being two competing goals, this project actually builds two executables.
+
+* 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).
+
+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. Therefore its only hard dependencies are `libc` (any implementation of the c standard library), `libdl` and `libpthread`. They are all shipped with [`glibc`](https://www.gnu.org/software/libc/), which is already installed on most linux distributions, so you probably don't have to worry about it.  
+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:
-*  [`libpci`](https://github.com/pciutils/pciutils): GPU output.
-*  [`libvulkan`](https://www.vulkan.org/): 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 resolution 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 resolution 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.
-*  [`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.
-*  [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
-*  [`librpm`](http://rpm.org/): Needed for rpm package count.
+
+### 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): Bluetooth, Player & Media detection.
+* [`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.
+* [`libpulse`](https://freedesktop.org/software/pulseaudio/doxygen/): Used for Sound detection.
+
+### 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)
+* [`libsqlite3`](https://www.sqlite.org/index.html): Used for fast wallpaper detection ( fallback to AppleScript )
+
+For the image logo, iTerm with iterm image protocol should work. Apple Terminal is not supported.
+
+### 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)
+
+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.
+
+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.
+
+### Android
+
+* [`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)
 
 ## Support status
 All categories not listed here should work without needing a specific implementation.
 
 ##### Available Modules
 ```
-Title, Separator, OS, Host, Kernel, Uptime, Processes, Packages, Shell, Resolution, DE, WM, WMTheme, Theme, Icons, Font, Cursor, Terminal, Terminal Font, CPU, CPUUsage, GPU, Memory, Disk, Battery, Player, Song, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
+Battery, Bios, Bluetooth, Board, Break, Brightness, Colors, Command, CPU, CPUUsage, Cursor, Custom, Date, DateTime, DE, Disk, Display, Font, Gamepad, GPU, Host, Icons, Kernel, Locale, LocalIP, Media, Memory, OpenCL, OpenGL, Packages, Player, Power Adapter, Processes, PublicIP, Separator, OS, Shell, Sound, Swap, Terminal, Terminal Font, Theme, Time, Title, Uptime, Vulkan, Wallpaper, Wifi, WM, WMTheme
 ```
 
-##### Logos
+##### Builtin logos
 ```
-Android, Arch, Arco, Artix, CachyOS, CentOS, Debian, Endeavour, Fedora, Garuda, Gentoo, KDE Neon, Linux, Manjaro, Mint, NixOS, OpenSUSE, OpenSUSE Tumbleweed, OpenSUSE LEAP, Pop!_OS, RebornOS, Ubuntu, Void, Zorin
+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, SteamOS, Ubuntu, Vanilla, Void, Windows, Windows 11, Windows 8, Zorin
 ```
-* Most of the logos have a small variant. Access it by appending _small to the logo name.
-* Some logos have an old variant. Access it by appending _old to the logo name.
-* Unknown/unsupported logos will be replaced with a generic linux logo when running fastfetch.
-* Get a list of all available logos with `fastfetch --print-logos`.
-* Printing images as logo is supported using Sixel or Kitty graphics protocol.
 
 ##### Package managers
 ```
-Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap
+apk, brew, Chocolatey, dpkg, emerge, eopkg, Flatpak, MacPorts, nix, Pacman, pkg, rpm, scoop, Snap, xbps
 ```
 
 ##### WM themes
 ```
-KWin, Mutter, Muffin, Marco, XFWM, Openbox (LXDE, LXQT & without DE)
+DWM (Windows), KWin, Marco, Muffin, Mutter, Openbox (LXDE, LXQT & without DE), Quartz Compositor (macOS), XFWM
 ```
 
 ##### DE versions
 ```
-KDE Plasma, Gnome, Cinnamon, Mate, XFCE4, LXQt
+Budgie, Cinnamon, Gnome, KDE Plasma, LXQt, Mate, XFCE4
 ```
 
 ##### Terminal fonts
 ```
-konsole, gnome-terminal-server, tilix, xfce4-terminal, lxterminal, TTY
+Alacritty, Apple Terminal, ConEmu, Deepin Terminal, foot, Gnome Terminal, iTerm2, Kitty, Konsole, LXTerminal, mintty, Tabby, Terminator, Termux, Tilix, TTY, Warp, WezTerm, Windows Terminal, XFCE4 Terminal
 ```
 
 ## Building
 
-fastfetch uses [`cmake`](https://cmake.org/) and [`pkg-config`](https://www.freedesktop.org/wiki/Software/pkg-config/) for building. The simplest steps to build the fastfetch and flashfetch binaries are:  
+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 . -j$(nproc) --target fastfetch --target flashfetch
+cmake --build . --target fastfetch --target flashfetch
 ```
 
-If pkg-config 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.
+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
 
-* [AUR](https://aur.archlinux.org/packages/fastfetch-git/): Packaged by me. Will install the fastfetch binary, bash completion and the presets. Git version
-* [Manjaro Repositories](https://gitlab.manjaro.org/packages/community/fastfetch): Packaged by a manjaro maintainer. Usually a bit outdated.
-* [Gentoo (Guru)](https://github.com/gentoo/guru/tree/master/app-misc/fastfetch): Packed by some other guy. May be out of date some times.
-* DEB / RPM: Run `cmake -B build && cmake --build build --target package` to build the packages in build.
-* Manually:
-    * Build: Follow the [build instructions](#building).
-    * Install: `sudo cmake --install build --prefix /usr/local`
+### Repositories
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/fastfetch.svg?header=)](https://repology.org/project/fastfetch/versions)
+
+### Manual
+
+* DEB / RPM package: `cmake --build . --target package`
+* Install directly: `cmake --install . --prefix /usr/local`
 
 ## FAQ
 
 Q: Why do you need a very performant version of neofetch?
-> I like putting neofetch in my ~/.bashrc to have a system overwiew whenever i use the terminal, but the slow speed annoyed me, so i created this. Also neofetch didn't output everything correctly (e.g Font is displayed as "[Plasma], Noto Sans, 10 [GTK2/3]") and writing my own tool gave me the possibility to fine tune it to run perfectly on at least my configuration.
+> I like putting neofetch in my ~/.bashrc to have a system overwiew whenever I use the terminal, but the slow speed annoyed me, so I created this. Also neofetch didn't output everything correctly (e.g Font is displayed as "[Plasma], Noto Sans, 10 [GTK2/3]") and writing my own tool gave me the possibility to fine tune it to run perfectly on at least my configuration.
 
-Q: It does not display [*] correctly for me, what can i do?
-> This is most likely because your system is not implemented (yet). At the moment i am focusing more on making the core app better, than adding more configurations. Feel free to open a pull request if you want to add support for your configuration
+Q: It does not display [*] correctly for me, what can I do?
+> This is most likely because your system is not implemented (yet). At the moment I am focusing more on making the core app better, than adding more configurations. Feel free to open a pull request if you want to add support for your configuration

completions/bash

@@ -9,28 +9,40 @@ __fastfetch_complete_help()
         "os-format"
         "host-format"
         "kernel-format"
+        "uptime-format"
+        "processes-format"
         "packages-format"
         "shell-format"
-        "resolution-format"
+        "display-format"
         "de-format"
         "wm-format"
+        "wm-theme-format"
         "theme-format"
         "icons-format"
         "font-format"
+        "cursor-format"
         "terminal-format"
         "terminal-font-format"
         "cpu-format"
         "cpu-usage-format"
         "gpu-format"
         "memory-format"
+        "swap-format"
         "disk-format"
         "battery-format"
+        "poweradapter-format"
         "locale-format"
-        "local-ip-format"
-        "public-ip-format"
+        "localip-format"
+        "publicip-format"
+        "player-format"
+        "media-format"
         "datetime-format"
         "date-format"
         "time-format"
+        "vulkan-format"
+        "opengl-format"
+        "opencl-format"
+        "bluetooth-format"
     )
     COMPREPLY=($(compgen -W "${__ff_helps[*]}" -- "$CURRENT_WORD"))
 }
@@ -57,6 +69,41 @@ __fastfetch_complete_logo()
     COMPREPLY=($(compgen -W "$(fastfetch --list-logos-autocompletion)" -- "$CURRENT_WORD"))
 }
 
+__fastfetch_complete_logo_type()
+{
+    local __ff_logo_types=(
+        "auto"
+        "builtin"
+        "file"
+        "raw"
+        "sixel"
+        "kitty"
+        "chafa"
+    )
+    COMPREPLY=($(compgen -W "${__ff_logo_types[*]}" -- "$CURRENT_WORD"))
+}
+
+__fastfetch_complete_binary_prefix()
+{
+    local __ff_binary_prefixes=(
+        "iec"
+        "si"
+        "jedec"
+    )
+    COMPREPLY=($(compgen -W "${__ff_binary_prefixes[*]}" -- "$CURRENT_WORD"))
+}
+
+__fastfetch_complete_gl()
+{
+    local __ff_gl_types=(
+        "auto"
+        "egl"
+        "glx"
+        "osmesa"
+    )
+    COMPREPLY=($(compgen -W "${__ff_gl_types[*]}" -- "$CURRENT_WORD"))
+}
+
 __fastfetch_complete_option()
 {
     local FF_OPTIONS_ALL=(
@@ -64,6 +111,9 @@ __fastfetch_complete_option()
         "${FF_OPTIONS_STRING[@]}"
         "${FF_OPTIONS_PATH[@]}"
         "${FF_OPTIONS_LOGO[@]}"
+        "${FF_OPTIONS_LOGO_TYPE[@]}"
+        "${FF_OPTIONS_BINARY_PREFIX[@]}"
+        "${FF_OPTIONS_GL[@]}"
     )
 
     if [[ $WORD_COUND -lt 3 ]]; then
@@ -108,8 +158,11 @@ __fastfetch_completion()
         "--list-presets"
         "--list-features"
         "--print-logos"
-        "--print-config"
+        "--print-config-system"
+        "--print-config-user"
         "--print-structure"
+        "--gen-config"
+        "--gen-config-force"
     )
 
     local FF_OPTIONS_HELP=(
@@ -119,17 +172,38 @@ __fastfetch_completion()
 
     local FF_OPTIONS_BOOL=(
         "-r"
-        "--recache"
-        "--nocache"
         "--show-errors"
         "--logo-print-remaining"
         "--multithreading"
+        "--stat"
         "--allow-slow-operations"
         "--disable-linewrap"
         "--hide-cursor"
+        "--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-hidden"
+        "--disk-show-subvolumes"
+        "--gpu-hide-integrated"
+        "--gpu-hide-discrete"
+        "--gpu-force-vulkan"
+        "--disk-show-unknown"
+        "--bluetooth-show-disconnected"
     )
 
     local FF_OPTIONS_STRING=(
@@ -137,6 +211,7 @@ __fastfetch_completion()
         "--logo-padding"
         "--logo-padding-left"
         "--logo-padding-right"
+        "--logo-padding-top"
         "--logo-color-1"
         "--logo-color-2"
         "--logo-color-3"
@@ -145,97 +220,172 @@ __fastfetch_completion()
         "--logo-color-6"
         "--logo-color-7"
         "--logo-color-8"
+        "--logo-width"
+        "--logo-height"
         "--logo-color-9"
         "-c"
         "--color"
+        "--color-keys"
+        "--color-title"
+        "--display-compact-type"
         "--separator"
         "-s"
         "--structure"
         "--set"
-        "--os-format"
+        "--set-keyless"
+        "--player-name"
+        "--percent-type"
+        "--publicip-url"
+        "--publicip-timeout"
+        "--weather-output-format"
+        "--weather-timeout"
         "--os-key"
-        "--host-format"
+        "--os-format"
+        "--os-error"
         "--host-key"
-        "--kernel-format"
+        "--host-format"
+        "--host-error"
         "--kernel-key"
-        "--uptime-format"
+        "--kernel-format"
+        "--kernel-error"
         "--uptime-key"
-        "--processes-format"
+        "--uptime-format"
+        "--uptime-error"
         "--processes-key"
-        "--packages-format"
+        "--processes-format"
+        "--processes-error"
         "--packages-key"
-        "--shell-format"
+        "--packages-format"
+        "--packages-error"
         "--shell-key"
-        "--resolution-format"
-        "--resolution-key"
-        "--de-format"
+        "--shell-format"
+        "--shell-error"
+        "--display-key"
+        "--display-format"
+        "--display-error"
         "--de-key"
-        "--wm-format"
+        "--de-format"
+        "--de-error"
         "--wm-key"
-        "--wm-theme-format"
+        "--wm-format"
+        "--wm-error"
         "--wm-theme-key"
-        "--theme-format"
+        "--wm-theme-format"
+        "--wm-theme-error"
         "--theme-key"
-        "--icons-format"
+        "--theme-format"
+        "--theme-error"
         "--icons-key"
-        "--font-format"
+        "--icons-format"
+        "--icons-error"
         "--font-key"
-        "--cursor-format"
+        "--font-format"
+        "--font-error"
         "--cursor-key"
-        "--terminal-format"
+        "--cursor-format"
+        "--cursor-error"
         "--terminal-key"
-        "--terminal-font-format"
+        "--terminal-format"
+        "--terminal-error"
         "--terminal-font-key"
-        "--cpu-format"
+        "--terminal-font-format"
+        "--terminal-font-error"
         "--cpu-key"
-        "--cpu-usage-format"
-        "--cpu-usage-key"
-        "--gpu-format"
+        "--cpu-format"
+        "--cpu-error"
+        "--cpu-useage-key"
+        "--cpu-useage-format"
+        "--cpu-useage-error"
         "--gpu-key"
-        "--memory-format"
+        "--gpu-format"
+        "--gpu-error"
         "--memory-key"
+        "--memory-format"
+        "--memory-error"
+        "--swap-key"
+        "--swap-format"
+        "--swap-error"
+        "--disk-key"
         "--disk-format"
-        "--disk-key"
-        "--battery-format"
+        "--disk-error"
         "--battery-key"
-        "--locale-format"
+        "--battery-format"
+        "--battery-error"
+        "--poweradapter-key"
+        "--poweradapter-format"
+        "--poweradapter-error"
         "--locale-key"
-        "--disk-folders"
-        "--disk-key"
-        "--local-ip-format"
-        "--local-ip-key"
-        "--public-ip-format"
-        "--public-ip-key"
-        "--player-format"
+        "--locale-format"
+        "--locale-error"
+        "--localip-key"
+        "--localip-format"
+        "--localip-error"
+        "--publicip-key"
+        "--publicip-format"
+        "--publicip-error"
+        "--wifi-key"
+        "--wifi-format"
+        "--wifi-error"
+        "--weather-key"
+        "--weather-format"
+        "--weather-error"
         "--player-key"
-        "--song-format"
-        "--song-key"
+        "--player-format"
+        "--player-error"
+        "--media-key"
+        "--media-format"
+        "--media-error"
         "--datetime-key"
         "--datetime-format"
-        "--date-format"
+        "--datetime-error"
         "--date-key"
-        "--time-format"
+        "--date-format"
+        "--date-error"
         "--time-key"
+        "--time-format"
+        "--time-error"
+        "--vulkan-key"
+        "--vulkan-format"
+        "--vulkan-error"
+        "--opengl-key"
+        "--opengl-format"
+        "--opengl-error"
+        "--opencl-key"
+        "--opencl-format"
+        "--opencl-error"
+        "--users-key"
+        "--users-format"
+        "--users-error"
+        "--bluetooth-key"
+        "--bluetooth-format"
+        "--bluetooth-error"
     )
 
     local FF_OPTIONS_PATH=(
+        "--load-config"
         "--os-file"
-        "--lib-PCI"
+        "--lib-pci"
         "--lib-vulkan"
         "--lib-wayland"
         "--lib-xcb-randr"
         "--lib-xcb"
-        "--lib-Xrandr"
+        "--lib-xrandr"
         "--lib-X11"
         "--lib-gio"
-        "--lib-DConf"
-        "--lib-DBus"
-        "--lib-XFConf"
-        "--lib-RPM"
+        "--lib-dconf"
+        "--lib-dbus"
+        "--lib-xfconf"
+        "--lib-sqlite3"
+        "--lib-rpm"
         "--lib-imagemagick"
         "--lib-z"
+        "--lib-chafa"
+        "--lib-egl"
+        "--lib-glx"
+        "--lib-osmesa"
+        "--lib-opencl"
+        "--lib-pulse"
         "--battery-dir"
-        "--load-config"
     )
 
     local FF_OPTIONS_LOGO=(
@@ -243,6 +393,18 @@ __fastfetch_completion()
         "--logo"
     )
 
+    local FF_OPTIONS_LOGO_TYPE=(
+        "--logo-type"
+    )
+
+    local FF_OPTIONS_BINARY_PREFIX=(
+        "--binary-prefix"
+    )
+
+    local FF_OPTIONS_GL=(
+        "--gl"
+    )
+
     if __fastfetch_previous_matches "${FF_OPTIONS_SINGLE[@]}"; then
         return
     elif [[ $WORD_COUND -gt 3 && ( ${COMP_WORDS[$COMP_CWORD - 2]} == "--help" || ${COMP_WORDS[$COMP_CWORD - 2]} == "-h" ) ]]; then
@@ -259,6 +421,12 @@ __fastfetch_completion()
         __fastfetch_complete_path
     elif __fastfetch_previous_matches "${FF_OPTIONS_LOGO[@]}"; then
         __fastfetch_complete_logo
+    elif __fastfetch_previous_matches "${FF_OPTIONS_LOGO_TYPE[@]}"; then
+        __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
+        __fastfetch_complete_gl
     else
         __fastfetch_complete_option
     fi

doc/logo.md

@@ -0,0 +1,116 @@
+# 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:Kernel:Uptime:Processes:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Disk:Battery:Player:Song:PublicIP:LocalIP:DateTime:Locale:Break:Colors
+--structure Title:Separator:OS:Host:Bios:Board:Chassis:Kernel:Uptime:Processes:Packages:Shell:Display:Brightness:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Wallpaper:Terminal:TerminalFont:CPU:CPUUsage:GPU:Memory:Swap:Disk:Battery:PowerAdapter:Player:Media:PublicIP:LocalIP:Wifi:DateTime:Locale:Vulkan:OpenGL:OpenCL:Users:Bluetooth:Sound:Gamepad:Weather:Break:Colors

presets/devinfo

@@ -1,4 +1,3 @@
 --disable-linewrap false
 --multithreading false
---show-errors true
---recache
+--show-errors

presets/devinfo-verbose

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

presets/examples/1

@@ -0,0 +1 @@
+# Load with --load-config examples/1

presets/examples/2

@@ -0,0 +1,24 @@
+# Load with --load-config examples/2
+# Note that you must replace the image path to an existing image to display it.
+
+--kitty /home/linus/Bilder/Gentoo.png
+--logo-width 28
+
+--separator "  "
+
+--set-keyless HardwareStart=┌───────── \e[1mHardware Information\e[0m ─────────┐
+--set-keyless SoftwareStart=├───────── \e[1mSoftware Information\e[0m ─────────┤
+--set-keyless InformationEnd=└────────────────────────────────────────┘
+--set-keyless Colors=    \e[38m \e[37m \e[36m \e[35m \e[34m \e[33m \e[32m \e[31m
+--structure HardwareStart:Host:CPU:GPU:SoftwareStart:OS:Kernel:WM:Shell:Terminal:TerminalFont:Packages:InformationEnd:Colors
+
+--host-key "  "
+--cpu-key "  "
+--gpu-key "  ﬙"
+--os-key "  "
+--kernel-key "  "
+--wm-key "  "
+--shell-key "  "
+--terminal-key "  "
+--terminal-font-key "  "
+--packages-key "  "

presets/examples/3

@@ -0,0 +1,7 @@
+# Load with --load-config example/3
+
+--logo debian_small
+--structure Vulkan:OpenGL:OpenCL:Memory:Disk:LocalIP
+--binary-prefix si
+--localip-show-loop false
+--disk-folders /:/home:/boot:/efi

presets/examples/4

@@ -0,0 +1,7 @@
+# Load with --load-config examples/4
+
+--color blue
+--logo arch_small
+--logo-padding-right 1
+--separator "  "
+--structure Date:Time:Break:Player:Media

presets/examples/5

@@ -0,0 +1,11 @@
+# Load with --load-config examples/5
+
+--logo none
+--color reset_magenta
+--structure Theme:Icons:Font:Cursor
+--theme-key T
+--theme-format {7}
+--icons-key I
+--icons-format {5}
+--font-key F
+--cursor-key C

presets/hardware

@@ -1,4 +1,4 @@
---structure Host:Resolution:CPU:GPU:Memory:Disk:Battery
---memory-format "{?2}{2}MiB{?}"
---disk-format "{?2}{2}GB{?}"
+--structure Host:Display:CPU:GPU:Memory:Disk:Battery
+--memory-format "{?2}{2}{?}"
+--disk-format "{?2}{2}{?}"
 --battery-format "{?1}{1} {?}{?2}{2} {?}{?3}({3}){?}"

presets/neofetch

@@ -1,10 +1,10 @@
---structure "Title:Separator:OS:Host:Kernel:Uptime:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Terminal:TerminalFont:CPU:GPU:Memory:Break:Colors"
+--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}"
---resolution-format "{}x{}"
+--display-format "{}x{}"
 --de-format "{2} {3}"
 --theme-format "{?1}{1}{?3} {3}{?} [Plasma], {?}{7}"
 --terminal-font-format "{/2}{-}{/}{2}{?3} {3}{?}"
---memory-format "{/1}{-}{/}{/2}{-}{/}{}MiB / {}MiB"
+--memory-format "{/1}{-}{/}{/2}{-}{/}{} / {}"
 --gpu-key "GPU"
---resolution-key "Resolution"
+--display-key "Display"

presets/paleofetch

@@ -1,5 +1,5 @@
---structure Title:Separator:OS:Host:Kernel:Uptime:Battery:Break:Packages:Shell:Resolution:Terminal:Break:CPU:GPU:Memory:Break:Colors
+--structure Title:Separator:OS:Host:Kernel:Uptime:Battery:Break:Packages:Shell:Display:Terminal:Break:CPU:GPU:Memory:Break:Colors
 --host-format "{/2}{-}{/}{2}{?3} {3}{?}"
 --battery-format "{/4}{-}{/}{4}%{?5} [{5}]{?}"
---resolution-key "Resolution"
+--display-key "Display"
 --gpu-key "GPU"

presets/verbose

@@ -1,28 +1,31 @@
---load-config all
-
---os-format "System: {}; Name: {}; Pretty name: {}; ID: {}; ID like: {}; Variant: {}; Variant ID: {}; Version: {}; Version ID: {}; Version codename: {}; Build ID: {}; Architecture: {}"
---host-format "Family: {}; Name: {}; Version: {}"
---kernel-format "Sysname: {}; Release: {}; Version: {}"
---uptime-format "Days: {}; Hours: {}; Minutes: {}; Seconds: {}"
---processes-format "Count: {}"
---packages-format "All: {}; pacman: {}; pacman branch: {}; dpkg: {}; rpm: {}; emerge: {}; xbps: {}; flatpak: {}; snap: {}"
---shell-format "Process name: {}; Process path: {}; Process exe: {}; Process version: {}; User path: {}; User exe: {}; User version: {}"
---resolution-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 "Plasma raw: {}; Plasma name: {}; Plasma size: {}; Plasma styles: {}; Plasma pretty: {}; GTK2 raw: {}; GTK2 name: {}; GTK2 size: {}; GTK2 styles: {}; GTK2 pretty: {}; GTK3 raw: {}; GTK3 name: {}; GTK3 size: {}; GTK3 styles: {}; GTK3 pretty: {}; GTK4 raw: {}; GTK4 name: {}; GTK4 size: {}; GTK4 styles: {}; GTK4 pretty: {}; GTK: {}"
---cursor-format "Theme: {}; Size: {}"
---terminal-format "Process: {}; Path: {}; Exe: {}"
---terminal-font-format "Raw: {}; Name: {}; Size: {}; Styles: {}; Pretty: {}"
---cpu-format "Name: {}; Pretty: {}; Vendor: {}; Logical online: {}; Logical configured: {}; Physical: {}; Cores: {}; bios: {}; scaling max: {}; scaling min: {}; info max: {}; info min: {}; cpuinfo: {}; frequency: {}"
---cpu-usage-format "Percentage: {}"
---gpu-format "Vendor: {}; Vendor pretty: {}; Name: {}; Name pretty: {}; Driver: {}"
---memory-format "Used: {}; Total: {}; Percentage: {}"
---disk-format "Used: {}; Total: {}; Files: {}; Percentage: {}"
---battery-format "Manufactor: {}; Model: {}; Technology: {}; Capacaty: {}; Status: {}"
---player-format "Name: {}"
---song-format "Song: {}; Artist: {}; Album: {}"
---datetime-format "year: {}; yearShort: {}; month: {}; monthPretty: {}; monthName: {}; monthNameShort: {}; weekNumber: {}; weekday: {}; weekdayShort: {}; dayInYear: {}; dayInMonth: {}; dayInWeek: {}; hour: {}; hourPretty: {}; hour12: {}; hour12Pretty: {}; minute: {}; minutePretty: {}; second: {}; secondPretty: {}"
+--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-system: {}; flatpak-user: {}; 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: {}; ScaledWith: {}; ScaledHeight: {}
+--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: {}; Type: {}
+--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: {}
+--bluetooth-format Name: {}; Address: {}; Type: {}; Battery: {}

run.sh

@@ -1,6 +1,22 @@
-#!/bin/env sh
+#!/usr/bin/env sh
+
+set -e
+
 mkdir -p build/
 cd build/
-cmake ..
-cmake --build . --target fastfetch -j$(nproc)
+
+if [ -z "${CMAKE_BUILD_TYPE}" ]; then
+    CMAKE_BUILD_TYPE=Release
+fi
+cmake "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}" ..
+
+if [ -z "$OSTYPE" ] || [ "$OSTYPE" = "linux-gnu" ]; then
+    cmake_build_args="-j$(nproc)"
+elif [ "$OSTYPE" = "darwin" ]; then
+    cmake_build_args="-j$(sysctl -n hw.ncpu)"
+else
+    cmake_build_args=""
+fi
+cmake --build . --target fastfetch ${cmake_build_args}
+
 ./fastfetch "$@"

src/common/bar.c

@@ -0,0 +1,99 @@
+#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)
+{
+    assert(green <= 10 && yellow <= 10 && red <= 10);
+
+    // [ 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);
+
+    if(!instance->config.pipe)
+        ffStrbufAppendS(buffer, "\033[97m[ ");
+    else
+        ffStrbufAppendS(buffer, "[ ");
+
+    for (uint8_t i = 0; i < percent; ++i)
+    {
+        if(!instance->config.pipe)
+        {
+            if (i == green)
+                ffStrbufAppendS(buffer, "\033[32m");
+            else if (i == yellow)
+                ffStrbufAppendS(buffer, "\033[93m");
+            else if (i == red)
+                ffStrbufAppendS(buffer, "\033[91m");
+        }
+        ffStrbufAppendS(buffer, "■");
+    }
+
+    if (percent < 10)
+    {
+        if(!instance->config.pipe)
+            ffStrbufAppendS(buffer, "\033[97m");
+        for (uint8_t i = percent; i < 10; ++i)
+            ffStrbufAppendS(buffer, "-");
+    }
+
+    if(!instance->config.pipe)
+        ffStrbufAppendS(buffer, "\033[97m ]" FASTFETCH_TEXT_MODIFIER_RESET);
+    else
+        ffStrbufAppendS(buffer, " ]");
+}
+
+// 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(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses)
+{
+    assert(green <= 100 && yellow <= 100);
+
+    bool colored = !!(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
+
+    if (parentheses)
+        ffStrbufAppendC(buffer, '(');
+
+    if (colored && !instance->config.pipe)
+    {
+        if(green < yellow)
+        {
+            if (percent <= green)
+                ffStrbufAppendS(buffer, "\033[32m");
+            else if (percent <= yellow)
+                ffStrbufAppendS(buffer, "\033[93m");
+            else
+                ffStrbufAppendS(buffer, "\033[91m");
+        }
+        else
+        {
+            if (percent >= green)
+                ffStrbufAppendS(buffer, "\033[32m");
+            else if (percent >= yellow)
+                ffStrbufAppendS(buffer, "\033[93m");
+            else
+                ffStrbufAppendS(buffer, "\033[91m");
+        }
+    }
+    ffStrbufAppendF(buffer, "%u%%", (unsigned) percent);
+
+    if (colored && !instance->config.pipe)
+    {
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+    }
+
+    if (parentheses)
+        ffStrbufAppendC(buffer, ')');
+}

src/common/bar.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_bar
+#define FF_INCLUDED_common_bar
+
+#include "fastfetch.h"
+
+enum
+{
+    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 ffAppendPercentNum(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses);
+
+#endif

src/common/caching.c

@@ -1,203 +0,0 @@
-#include "fastfetch.h"
-
-#define FF_CACHE_VALUE_EXTENSION "ffcv"
-#define FF_CACHE_SPLIT_EXTENSION "ffcs"
-
-static void getCacheFilePath(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
-{
-    ffStrbufAppend(buffer, &instance->state.cacheDir);
-    ffStrbufAppendS(buffer, moduleName);
-
-    if(extension != NULL)
-    {
-        ffStrbufAppendC(buffer, '.');
-        ffStrbufAppendS(buffer, extension);
-    }
-}
-
-static void readCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
-{
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    getCacheFilePath(instance, moduleName, extension, &path);
-    ffAppendFileContent(path.chars, buffer);
-    ffStrbufDestroy(&path);
-}
-
-static void writeCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* content)
-{
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    getCacheFilePath(instance, moduleName, extension, &path);
-    ffWriteFileContent(path.chars, content);
-    ffStrbufDestroy(&path);
-}
-
-void ffCacheValidate(FFinstance* instance)
-{
-    if(instance->config.recache)
-        return;
-
-    FFstrbuf content;
-    ffStrbufInit(&content);
-    readCacheFile(instance, "cacheversion", "ffv", &content);
-
-    bool isSameVersion = ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0;
-    ffStrbufDestroy(&content);
-    if(isSameVersion)
-        return;
-
-    instance->config.recache = true;
-
-    FFstrbuf version;
-    ffStrbufInitA(&version, sizeof(FASTFETCH_PROJECT_VERSION));
-    ffStrbufAppendS(&version, FASTFETCH_PROJECT_VERSION);
-    writeCacheFile(instance, "cacheversion", "ffv", &version);
-    ffStrbufDestroy(&version);
-}
-
-void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache)
-{
-    FFstrbuf cacheFileValue;
-    ffStrbufInitA(&cacheFileValue, 64);
-    getCacheFilePath(instance, moduleName, FF_CACHE_VALUE_EXTENSION, &cacheFileValue);
-    cache->value = fopen(cacheFileValue.chars, "w");
-    ffStrbufDestroy(&cacheFileValue);
-
-    FFstrbuf cacheFileSplit;
-    ffStrbufInitA(&cacheFileSplit, 64);
-    getCacheFilePath(instance, moduleName, FF_CACHE_SPLIT_EXTENSION, &cacheFileSplit);
-    cache->split = fopen(cacheFileSplit.chars, "w");
-    ffStrbufDestroy(&cacheFileSplit);
-}
-
-void ffCacheClose(FFcache* cache)
-{
-    if(cache->value != NULL)
-        fclose(cache->value);
-
-    if(cache->split != NULL)
-        fclose(cache->split);
-}
-
-static bool printCachedValue(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat)
-{
-    FFstrbuf content;
-    ffStrbufInitA(&content, 512);
-    readCacheFile(instance, moduleName, FF_CACHE_VALUE_EXTENSION, &content);
-
-    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
-
-    if(content.length == 0)
-        return false;
-
-    uint8_t moduleCounter = 1;
-
-    uint32_t startIndex = 0;
-    while(startIndex < content.length)
-    {
-        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
-        uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        puts(content.chars + startIndex);
-        startIndex = nullByteIndex + 1;
-        ++moduleCounter;
-    }
-
-    ffStrbufDestroy(&content);
-
-    return moduleCounter > 1;
-}
-
-static bool printCachedFormat(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
-{
-    FFstrbuf content;
-    ffStrbufInitA(&content, 512);
-    readCacheFile(instance, moduleName, FF_CACHE_SPLIT_EXTENSION, &content);
-
-    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
-
-    if(content.length == 0)
-        return false;
-
-    uint8_t moduleCounter = 1;
-
-    FFformatarg* arguments = calloc(numArgs, sizeof(FFformatarg));
-    uint32_t argumentCounter = 0;
-
-    uint32_t startIndex = 0;
-    while(startIndex < content.length)
-    {
-        arguments[argumentCounter].type = FF_FORMAT_ARG_TYPE_STRING;
-        arguments[argumentCounter].value = &content.chars[startIndex];
-        ++argumentCounter;
-
-        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
-
-        if(argumentCounter == numArgs)
-        {
-            uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-            ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
-            ++moduleCounter;
-            argumentCounter = 0;
-        }
-
-        startIndex = nullByteIndex + 1;
-    }
-
-    free(arguments);
-    ffStrbufDestroy(&content);
-
-    return moduleCounter > 1;
-}
-
-bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
-{
-    if(instance->config.recache)
-        return false;
-
-    if(formatString == NULL || formatString->length == 0)
-        return printCachedValue(instance, moduleName, customKeyFormat);
-    else
-        return printCachedFormat(instance, moduleName, customKeyFormat, formatString, numArgs);
-}
-
-void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, FFcache* cache, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments)
-{
-    if(formatString == NULL || formatString->length == 0)
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffStrbufPutTo(value, stdout);
-    }
-    else
-    {
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
-    }
-
-    if(cache->value != NULL)
-    {
-        ffStrbufWriteTo(value, cache->value);
-        fputc('\0', cache->value);
-    }
-
-    if(cache->split == NULL)
-        return;
-
-    for(uint32_t i = 0; i < numArgs; i++)
-    {
-        FFstrbuf buffer;
-        ffStrbufInitA(&buffer, 64);
-        ffFormatAppendFormatArg(&buffer, &arguments[i]);
-        ffStrbufWriteTo(&buffer, cache->split);
-        ffStrbufDestroy(&buffer);
-        fputc('\0', cache->split);
-    }
-}
-
-void ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments)
-{
-    FFcache cache;
-    ffCacheOpenWrite(instance, moduleName, &cache);
-    ffPrintAndAppendToCache(instance, moduleName, 0, customKeyFormat, &cache, value, formatString, numArgs, arguments);
-    ffCacheClose(&cache);
-}

src/common/dbus.c

@@ -0,0 +1,206 @@
+#include "dbus.h"
+
+#ifdef FF_HAVE_DBUS
+
+#include "common/thread.h"
+#include "util/stringUtils.h"
+
+static bool loadLibSymbols(const FFinstance* instance, FFDBusLibrary* lib)
+{
+    FF_LIBRARY_LOAD(dbus, &instance->config.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(const FFinstance* instance)
+{
+    static FFDBusLibrary lib;
+    static bool loaded = false;
+    static bool loadSuccess = false;
+    static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
+
+    ffThreadMutexLock(&mutex);
+
+    if(!loaded)
+    {
+        loaded = true;
+        loadSuccess = loadLibSymbols(instance, &lib);
+    }
+
+    ffThreadMutexUnlock(&mutex);
+    return loadSuccess ? &lib : NULL;
+}
+
+const char* ffDBusLoadData(const FFinstance* instance, DBusBusType busType, FFDBusData* data)
+{
+    data->lib = loadLib(instance);
+    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(const FFinstance* instance, 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

@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "common/font.h"
 
 #include <string.h>
 
@@ -188,10 +189,35 @@ void ffFontInitPango(FFfont* font, const char* data)
     fontInitPretty(font);
 }
 
-void ffFontInitCopy(FFfont* font, const char* name)
+void ffFontInitValues(FFfont* font, const char* name, const char* size)
 {
     fontInit(font);
+
     ffStrbufAppendS(&font->name, name);
+    ffStrbufAppendS(&font->size, size);
+
+    fontInitPretty(font);
+}
+
+void ffFontInitCopy(FFfont* font, const char* name)
+{
+    ffFontInitValues(font, name, NULL);
+}
+
+void ffFontInitWithSpace(FFfont* font, const char* rawName)
+{
+    const char* pspace = strrchr(rawName, ' ');
+    if(pspace == NULL)
+    {
+        ffFontInitCopy(font, rawName);
+        return;
+    }
+
+    fontInit(font);
+
+    ffStrbufAppendNS(&font->name, (uint32_t)(pspace - rawName), rawName);
+    ffStrbufAppendS(&font->size, pspace + 1);
+
     fontInitPretty(font);
 }
 

src/common/font.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_font
+#define FF_INCLUDED_common_font
+
+#include "util/FFstrbuf.h"
+#include "util/FFlist.h"
+
+typedef struct FFfont
+{
+    FFstrbuf pretty;
+    FFstrbuf name;
+    FFstrbuf size;
+    FFlist styles;
+} FFfont;
+
+void ffFontInitQt(FFfont* font, const char* data);
+void ffFontInitPango(FFfont* font, const char* data);
+void ffFontInitCopy(FFfont* font, const char* name);
+void ffFontInitValues(FFfont* font, const char* name, const char* size);
+void ffFontInitWithSpace(FFfont* font, const char* rawName);
+void ffFontDestroy(FFfont* font);
+
+#endif

src/common/format.c

@@ -1,21 +1,31 @@
 #include "fastfetch.h"
+#include "common/format.h"
+#include "common/parsing.h"
+#include "util/textModifier.h"
+#include "util/stringUtils.h"
+
+#include <inttypes.h>
 
 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
 {
     if(formatarg->type == FF_FORMAT_ARG_TYPE_INT)
         ffStrbufAppendF(buffer, "%i", *(int*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT)
-        ffStrbufAppendF(buffer, "%u", *(uint32_t*)formatarg->value);
+        ffStrbufAppendF(buffer, "%" PRIu32, *(uint32_t*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT16)
-        ffStrbufAppendF(buffer, "%hu", *(uint16_t*)formatarg->value);
+        ffStrbufAppendF(buffer, "%" PRIu16, *(uint16_t*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT8)
-        ffStrbufAppendF(buffer, "%hhu", *(uint8_t*)formatarg->value);
+        ffStrbufAppendF(buffer, "%" PRIu8, *(uint8_t*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_STRING)
         ffStrbufAppendS(buffer, (const char*)formatarg->value);
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_STRBUF)
         ffStrbufAppend(buffer, (FFstrbuf*)formatarg->value);
+    else if(formatarg->type == FF_FORMAT_ARG_TYPE_FLOAT)
+        ffStrbufAppendF(buffer, "%f", *(float*)formatarg->value);
     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");
     else if(formatarg->type == FF_FORMAT_ARG_TYPE_LIST)
     {
         const FFlist* list = formatarg->value;
@@ -32,15 +42,14 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
     }
 }
 
-static inline bool placeholderValueIsForError(const FFstrbuf* placeholderValue)
-{
-    return
-        ffStrbufIgnCaseCompS(placeholderValue, "e") == 0 ||
-        ffStrbufIgnCaseCompS(placeholderValue, "error") == 0 ||
-        ffStrbufIgnCaseCompS(placeholderValue, "0") == 0
-    ;
-}
-
+/**
+ * @brief parses a string to a uint32_t
+ *
+ * If the string can't be parsed, or is < 1, uint32_t max is returned.
+ *
+ * @param placeholderValue the string to parse
+ * @return uint32_t the parsed value
+ */
 static inline uint32_t getArgumentIndex(const FFstrbuf* placeholderValue)
 {
     uint32_t result = UINT32_MAX;
@@ -48,7 +57,7 @@ static inline uint32_t getArgumentIndex(const FFstrbuf* placeholderValue)
     if(placeholderValue->chars[0] != '-')
         sscanf(placeholderValue->chars, "%u", &result);
 
-    return result;
+    return result == 0 ? UINT32_MAX : result;
 }
 
 static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start, const FFstrbuf* placeholderValue, uint32_t index, uint32_t formatStringLength)
@@ -62,26 +71,29 @@ static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start,
 
 static inline void appendEmptyPlaceholder(FFstrbuf* buffer, const char* placeholder, uint32_t* argCounter, uint32_t numArgs, const FFformatarg* arguments)
 {
-    if(*argCounter > numArgs)
+    if(*argCounter >= numArgs)
         ffStrbufAppendS(buffer, placeholder);
     else
-        ffFormatAppendFormatArg(buffer, &arguments[(*argCounter)++]);
+        ffFormatAppendFormatArg(buffer, arguments + *argCounter);
+
+    (*argCounter)++;
 }
 
 static inline bool formatArgSet(const FFformatarg* arg)
 {
     return arg->value != NULL && (
-        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0) ||
+        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0.0) || //Also is false for NaN
         (arg->type == FF_FORMAT_ARG_TYPE_INT && *(int*)arg->value > 0) ||
         (arg->type == FF_FORMAT_ARG_TYPE_STRBUF && ((FFstrbuf*)arg->value)->length > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_STRING && *(const char*)arg->value != '\0') ||
+        (arg->type == FF_FORMAT_ARG_TYPE_STRING && ffStrSet(arg->value)) ||
         (arg->type == FF_FORMAT_ARG_TYPE_UINT8 && *(uint8_t*)arg->value > 0) ||
         (arg->type == FF_FORMAT_ARG_TYPE_UINT16 && *(uint16_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_UINT && *(uint32_t*)arg->value > 0)
+        (arg->type == FF_FORMAT_ARG_TYPE_UINT && *(uint32_t*)arg->value > 0) ||
+        (arg->type == FF_FORMAT_ARG_TYPE_BOOL && arg->value != NULL)
     );
 }
 
-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments)
+void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments)
 {
     uint32_t argCounter = 0;
 
@@ -128,13 +140,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         while(i < formatstr->length && formatstr->chars[i] != '}')
             ffStrbufAppendC(&placeholderValue, formatstr->chars[i++]);
 
-        // test for error, if so print it
-        if(placeholderValueIsForError(&placeholderValue)) {
-            ffStrbufAppend(buffer, error);
-            ffStrbufDestroy(&placeholderValue);
-            continue;
-        }
-
          // test if for stop, if so break the loop
         if(placeholderValue.length == 1 && placeholderValue.chars[0] == '-')
         {
@@ -186,14 +191,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            // continue if an error is set
-            if(placeholderValueIsForError(&placeholderValue) && error != NULL && error->length > 0)
-            {
-                ++numOpenIfs;
-                ffStrbufDestroy(&placeholderValue);
-                continue;
-            }
-
             uint32_t index = getArgumentIndex(&placeholderValue);
 
             // testing for an invalid index
@@ -223,14 +220,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            //continue if an error os not set
-            if(placeholderValueIsForError(&placeholderValue) && (error == NULL || error->length == 0))
-            {
-                ++numOpenNotIfs;
-                ffStrbufDestroy(&placeholderValue);
-                continue;
-            }
-
             uint32_t index = getArgumentIndex(&placeholderValue);
 
             // testing for an invalid index

src/common/format.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_format
+#define FF_INCLUDED_common_format
+
+typedef enum FFformatargtype
+{
+    FF_FORMAT_ARG_TYPE_NULL = 0,
+    FF_FORMAT_ARG_TYPE_UINT,
+    FF_FORMAT_ARG_TYPE_UINT16,
+    FF_FORMAT_ARG_TYPE_UINT8,
+    FF_FORMAT_ARG_TYPE_INT,
+    FF_FORMAT_ARG_TYPE_STRING,
+    FF_FORMAT_ARG_TYPE_STRBUF,
+    FF_FORMAT_ARG_TYPE_FLOAT,
+    FF_FORMAT_ARG_TYPE_DOUBLE,
+    FF_FORMAT_ARG_TYPE_LIST,
+    FF_FORMAT_ARG_TYPE_BOOL
+} FFformatargtype;
+
+typedef struct FFformatarg
+{
+    FFformatargtype type;
+    const void* value;
+} 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,191 +1,121 @@
 #include "fastfetch.h"
+#include "common/parsing.h"
+#include "common/thread.h"
+#include "detection/displayserver/displayserver.h"
+#include "util/textModifier.h"
 
+#include <stdlib.h>
 #include <unistd.h>
 #include <sys/stat.h>
-#include <signal.h>
-
-static bool strbufEqualsAdapter(const void* first, const void* second)
-{
-    return ffStrbufComp(second, first) == 0;
-}
-
-static void initConfigDirs(FFstate* state)
-{
-    ffListInit(&state->configDirs, sizeof(FFstrbuf));
-
-    const char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
-    if(xdgConfigHome != NULL)
-    {
-        FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
-        ffStrbufInitA(buffer, 64);
-        ffStrbufAppendS(buffer, xdgConfigHome);
-        ffStrbufTrimRight(buffer, '/');
-    }
-
-    FFstrbuf xdgConfigDirs;
-    ffStrbufInitA(&xdgConfigDirs, 64);
-    ffStrbufAppendS(&xdgConfigDirs, getenv("XDG_CONFIG_DIRS"));
-
-    #define FF_ENSURE_ONLY_ONCE_IN_LIST(element) \
-        if(ffListFirstIndexComp(&state->configDirs, element, strbufEqualsAdapter) < state->configDirs.length - 1) \
-            --state->configDirs.length;
-
-    FFstrbuf* userConfigHome = ffListAdd(&state->configDirs);
-    ffStrbufInitA(userConfigHome, 64);
-    ffStrbufAppendS(userConfigHome, state->passwd->pw_dir);
-    ffStrbufAppendS(userConfigHome, "/.config");
-    FF_ENSURE_ONLY_ONCE_IN_LIST(userConfigHome)
-
-    FFstrbuf* userHome = ffListAdd(&state->configDirs);
-    ffStrbufInitA(userHome, 64);
-    ffStrbufAppendS(userHome, state->passwd->pw_dir);
-    FF_ENSURE_ONLY_ONCE_IN_LIST(userHome)
-
-    uint32_t startIndex = 0;
-    while (startIndex < xdgConfigDirs.length)
-    {
-        uint32_t colonIndex = ffStrbufNextIndexC(&xdgConfigDirs, startIndex, ':');
-        xdgConfigDirs.chars[colonIndex] = '\0';
-
-        FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
-        ffStrbufInitA(buffer, 64);
-        ffStrbufAppendS(buffer, xdgConfigDirs.chars + startIndex);
-        ffStrbufTrimRight(buffer, '/');
-        FF_ENSURE_ONLY_ONCE_IN_LIST(buffer);
-
-        startIndex = colonIndex + 1;
-    }
-
-    FFstrbuf* systemConfigHome = ffListAdd(&state->configDirs);
-    ffStrbufInitA(systemConfigHome, 64);
-    ffStrbufAppendS(systemConfigHome, FASTFETCH_TARGET_DIR_ROOT"/etc/xdg");
-    FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfigHome)
-
-    FFstrbuf* systemConfig = ffListAdd(&state->configDirs);
-    ffStrbufInitA(systemConfig, 64);
-    ffStrbufAppendS(systemConfig, FASTFETCH_TARGET_DIR_ROOT"/etc");
-    FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfig)
-
-    #undef FF_ENSURE_ONLY_ONCE_IN_LIST
-}
-
-static void initCacheDir(FFstate* state)
-{
-    ffStrbufInitA(&state->cacheDir, 64);
-
-    ffStrbufAppendS(&state->cacheDir, getenv("XDG_CACHE_HOME"));
-
-    if(state->cacheDir.length == 0)
-    {
-        ffStrbufAppendS(&state->cacheDir, state->passwd->pw_dir);
-        ffStrbufAppendS(&state->cacheDir, "/.cache/");
-    }
-    else if(!ffStrbufEndsWithC(&state->cacheDir, '/'))
-        ffStrbufAppendC(&state->cacheDir, '/');
-
-    mkdir(state->cacheDir.chars, S_IRWXU | S_IXGRP | S_IRGRP | S_IXOTH | S_IROTH); //I hope everybody has a cache folder, but who knows
-
-    ffStrbufAppendS(&state->cacheDir, "fastfetch/");
-    mkdir(state->cacheDir.chars, S_IRWXU | S_IRGRP | S_IROTH);
-}
+#ifdef _WIN32
+    #include <windows.h>
+    #include <locale.h>
+    #include "util/windows/unicode.h"
+#else
+    #include <signal.h>
+#endif
 
 static void initState(FFstate* state)
 {
     state->logoWidth = 0;
     state->logoHeight = 0;
     state->keysHeight = 0;
-    state->passwd = getpwuid(getuid());
-    uname(&state->utsname);
-    sysinfo(&state->sysinfo);
 
-    initConfigDirs(state);
-    initCacheDir(state);
+    ffPlatformInit(&state->platform);
+}
+
+static void initModuleArg(FFModuleArgs* args)
+{
+    ffStrbufInit(&args->key);
+    ffStrbufInit(&args->outputFormat);
+    ffStrbufInit(&args->errorFormat);
 }
 
 static void defaultConfig(FFinstance* instance)
 {
-    ffStrbufInit(&instance->config.logoSource);
-    instance->config.logoType = FF_LOGO_TYPE_AUTO;
+    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.logoColors[i]);
-    instance->config.logoWidth = 65;
-    instance->config.logoPaddingLeft = 0;
-    instance->config.logoPaddingRight = 4;
-    instance->config.logoPrintRemaining = true;
+        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.mainColor);
     ffStrbufInit(&instance->config.separator);
     ffStrbufAppendS(&instance->config.separator, ": ");
 
     instance->config.showErrors = false;
     instance->config.recache = false;
-    instance->config.cacheSave = true;
     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;
 
-    ffStrbufInitA(&instance->config.osFormat, 0);
-    ffStrbufInitA(&instance->config.osKey, 0);
-    ffStrbufInitA(&instance->config.hostFormat, 0);
-    ffStrbufInitA(&instance->config.hostKey, 0);
-    ffStrbufInitA(&instance->config.kernelFormat, 0);
-    ffStrbufInitA(&instance->config.kernelKey, 0);
-    ffStrbufInitA(&instance->config.uptimeFormat, 0);
-    ffStrbufInitA(&instance->config.uptimeKey, 0);
-    ffStrbufInitA(&instance->config.processesFormat, 0);
-    ffStrbufInitA(&instance->config.processesKey, 0);
-    ffStrbufInitA(&instance->config.packagesFormat, 0);
-    ffStrbufInitA(&instance->config.packagesKey, 0);
-    ffStrbufInitA(&instance->config.shellFormat, 0);
-    ffStrbufInitA(&instance->config.shellKey, 0);
-    ffStrbufInitA(&instance->config.resolutionFormat, 0);
-    ffStrbufInitA(&instance->config.resolutionKey, 0);
-    ffStrbufInitA(&instance->config.deFormat, 0);
-    ffStrbufInitA(&instance->config.deKey, 0);
-    ffStrbufInitA(&instance->config.wmFormat, 0);
-    ffStrbufInitA(&instance->config.wmKey, 0);
-    ffStrbufInitA(&instance->config.wmThemeFormat, 0);
-    ffStrbufInitA(&instance->config.wmThemeKey, 0);
-    ffStrbufInitA(&instance->config.themeFormat, 0);
-    ffStrbufInitA(&instance->config.themeKey, 0);
-    ffStrbufInitA(&instance->config.iconsFormat, 0);
-    ffStrbufInitA(&instance->config.iconsKey, 0);
-    ffStrbufInitA(&instance->config.fontFormat, 0);
-    ffStrbufInitA(&instance->config.fontKey, 0);
-    ffStrbufInitA(&instance->config.cursorKey, 0);
-    ffStrbufInitA(&instance->config.cursorFormat, 0);
-    ffStrbufInitA(&instance->config.terminalFormat, 0);
-    ffStrbufInitA(&instance->config.terminalKey, 0);
-    ffStrbufInitA(&instance->config.termFontFormat, 0);
-    ffStrbufInitA(&instance->config.termFontKey, 0);
-    ffStrbufInitA(&instance->config.cpuFormat, 0);
-    ffStrbufInitA(&instance->config.cpuKey, 0);
-    ffStrbufInitA(&instance->config.cpuUsageFormat, 0);
-    ffStrbufInitA(&instance->config.cpuUsageKey, 0);
-    ffStrbufInitA(&instance->config.gpuFormat, 0);
-    ffStrbufInitA(&instance->config.gpuKey, 0);
-    ffStrbufInitA(&instance->config.memoryFormat, 0);
-    ffStrbufInitA(&instance->config.memoryKey, 0);
-    ffStrbufInitA(&instance->config.diskFormat, 0);
-    ffStrbufInitA(&instance->config.diskKey, 0);
-    ffStrbufInitA(&instance->config.batteryFormat, 0);
-    ffStrbufInitA(&instance->config.batteryKey, 0);
-    ffStrbufInitA(&instance->config.localeFormat, 0);
-    ffStrbufInitA(&instance->config.localeKey, 0);
-    ffStrbufInitA(&instance->config.localIpKey, 0);
-    ffStrbufInitA(&instance->config.localIpFormat, 0);
-    ffStrbufInitA(&instance->config.publicIpKey, 0);
-    ffStrbufInitA(&instance->config.publicIpFormat, 0);
-    ffStrbufInitA(&instance->config.playerKey, 0);
-    ffStrbufInitA(&instance->config.playerFormat, 0);
-    ffStrbufInitA(&instance->config.songKey, 0);
-    ffStrbufInitA(&instance->config.songFormat, 0);
-    ffStrbufInitA(&instance->config.dateTimeKey, 0);
-    ffStrbufInitA(&instance->config.dateTimeFormat, 0);
-    ffStrbufInitA(&instance->config.dateKey, 0);
-    ffStrbufInitA(&instance->config.dateFormat, 0);
-    ffStrbufInitA(&instance->config.timeKey, 0);
-    ffStrbufInitA(&instance->config.timeFormat, 0);
+    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.wallpaper);
+    initModuleArg(&instance->config.openGL);
+    initModuleArg(&instance->config.openCL);
+    initModuleArg(&instance->config.users);
+    initModuleArg(&instance->config.bluetooth);
+    initModuleArg(&instance->config.sound);
+    initModuleArg(&instance->config.gamepad);
 
     ffStrbufInitA(&instance->config.libPCI, 0);
     ffStrbufInitA(&instance->config.libVulkan, 0);
@@ -198,89 +128,320 @@ static void defaultConfig(FFinstance* instance)
     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.libPulse);
+    ffStrbufInit(&instance->config.libwlanapi);
+    ffStrbufInit(&instance->config.libnm);
+
+    instance->config.cpuTemp = false;
+    instance->config.gpuTemp = false;
+    instance->config.gpuForceVulkan = 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.diskShowTypes = FF_DISK_TYPE_REGULAR_BIT | FF_DISK_TYPE_EXTERNAL_BIT;
+
+    instance->config.displayCompactType = FF_DISPLAY_COMPACT_TYPE_NONE;
+    instance->config.displayDetectName = false;
+    instance->config.displayPreciseRefreshRate = false;
+
+    instance->config.bluetoothShowDisconnected = false;
+
+    instance->config.soundType = FF_SOUND_TYPE_MAIN;
 
     ffStrbufInitA(&instance->config.batteryDir, 0);
 
     ffStrbufInitA(&instance->config.separatorString, 0);
 
-    instance->config.localIpShowIpV4 = true;
-    instance->config.localIpShowIpV6 = false;
-    instance->config.localIpShowLoop = false;
+    instance->config.localIpShowType = FF_LOCALIP_TYPE_IPV4_BIT;
+    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)
 {
+    #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);
 }
 
-static void resetConsole(bool disableLinewrap, bool hideCursor)
-{
-    if(disableLinewrap)
-        fputs("\033[?7h", stdout);
+#if defined(FF_HAVE_THREADS) && !(defined(__APPLE__) || defined(_WIN32) || defined(__ANDROID__))
 
-    if(hideCursor)
-        fputs("\033[?25h", stdout);
+#include "detection/gtk_qt/gtk_qt.h"
+
+#define FF_START_DETECTION_THREADS
+
+FF_THREAD_ENTRY_DECL_WRAPPER(ffConnectDisplayServer, FFinstance*)
+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*)
+
+void startDetectionThreads(FFinstance* instance)
+{
+    ffThreadDetach(ffThreadCreate(ffConnectDisplayServerThreadMain, instance));
+    ffThreadDetach(ffThreadCreate(ffDetectQtThreadMain, instance));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK2ThreadMain, instance));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK3ThreadMain, instance));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK4ThreadMain, instance));
 }
 
+#endif //FF_HAVE_THREADS
+
 static volatile bool ffDisableLinewrap = true;
 static volatile bool ffHideCursor = true;
 
+static void resetConsole()
+{
+    if(ffDisableLinewrap)
+        fputs("\033[?7h", stdout);
+
+    if(ffHideCursor)
+        fputs("\033[?25h", stdout);
+
+    #if defined(_WIN32) && defined(FF_ENABLE_BUFFER)
+        fflush(stdout);
+    #endif
+}
+
+#ifdef _WIN32
+BOOL WINAPI consoleHandler(DWORD signal)
+{
+    FF_UNUSED(signal);
+    resetConsole();
+    exit(0);
+}
+#else
 static void exitSignalHandler(int signal)
 {
     FF_UNUSED(signal);
-    resetConsole(ffDisableLinewrap, ffHideCursor);
+    resetConsole();
     exit(0);
 }
+#endif
 
 void ffStart(FFinstance* instance)
 {
-    ffDisableLinewrap = instance->config.disableLinewrap;
-    ffHideCursor = instance->config.hideCursor;
+    #ifdef FF_START_DETECTION_THREADS
+        if(instance->config.multithreading)
+            startDetectionThreads(instance);
+    #endif
 
-    struct sigaction action = {};
-    action.sa_handler = exitSignalHandler;
+    ffDisableLinewrap = instance->config.disableLinewrap && !instance->config.pipe;
+    ffHideCursor = instance->config.hideCursor && !instance->config.pipe;
 
+    #ifdef _WIN32
+    #ifdef FF_ENABLE_BUFFER
+        setvbuf(stdout, NULL, _IOFBF, 4096);
+    #endif
+    SetConsoleCtrlHandler(consoleHandler, TRUE);
+    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+    DWORD mode = 0;
+    GetConsoleMode(hStdout, &mode);
+    SetConsoleMode(hStdout, mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
+    SetConsoleOutputCP(CP_UTF8);
+    #else
+    #ifndef FF_ENABLE_BUFFER
+        setvbuf(stdout, NULL, _IONBF, 0);
+    #endif
+    struct sigaction action = { .sa_handler = exitSignalHandler };
     sigaction(SIGINT, &action, NULL);
     sigaction(SIGTERM, &action, NULL);
     sigaction(SIGQUIT, &action, NULL);
-
-    //We do the cache validation here, so we can skip it if --recache is given
-    ffCacheValidate(instance);
+    #endif
 
     //reset everything to default before we start printing
-    fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
-    if(instance->config.hideCursor)
+    if(ffHideCursor)
         fputs("\033[?25l", stdout);
 
-    if(instance->config.disableLinewrap)
+    if(ffDisableLinewrap)
         fputs("\033[?7l", stdout);
 
-    ffPrintLogo(instance);
+    ffLogoPrint(instance);
 }
 
 void ffFinish(FFinstance* instance)
 {
-    ffPrintRemainingLogo(instance);
-    resetConsole(instance->config.disableLinewrap, instance->config.hideCursor);
+    if(instance->config.logo.printRemaining)
+        ffLogoPrintRemaining(instance);
+
+    resetConsole();
+}
+
+static void destroyModuleArg(FFModuleArgs* args)
+{
+    ffStrbufDestroy(&args->key);
+    ffStrbufDestroy(&args->outputFormat);
+    ffStrbufDestroy(&args->errorFormat);
+}
+
+static void destroyConfig(FFinstance* instance)
+{
+    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.chassis);
+    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.wallpaper);
+    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);
+    destroyModuleArg(&instance->config.bluetooth);
+    destroyModuleArg(&instance->config.sound);
+    destroyModuleArg(&instance->config.gamepad);
+
+    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.libPulse);
+    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);
+}
+
+static void destroyState(FFinstance* instance)
+{
+    ffPlatformDestroy(&instance->state.platform);
+}
+
+void ffDestroyInstance(FFinstance* instance)
+{
+    destroyConfig(instance);
+    destroyState(instance);
 }
 
 //Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
 void ffListFeatures()
 {
     fputs(
+        #ifdef FF_HAVE_THREADS
+            "threads\n"
+        #endif
         #ifdef FF_HAVE_LIBPCI
             "libpci\n"
         #endif
@@ -317,14 +478,44 @@ void ffListFeatures()
         #ifdef FF_HAVE_IMAGEMAGICK6
             "imagemagick6\n"
         #endif
+        #ifdef FF_HAVE_CHAFA
+            "chafa\n"
+        #endif
         #ifdef FF_HAVE_ZLIB
             "zlib\n"
         #endif
         #ifdef FF_HAVE_XFCONF
             "xfconf\n"
         #endif
+        #ifdef FF_HAVE_SQLITE3
+            "sqlite3\n"
+        #endif
         #ifdef FF_HAVE_RPM
-            "librpm\n"
+            "rpm\n"
+        #endif
+        #ifdef FF_HAVE_EGL
+            "egl\n"
+        #endif
+        #ifdef FF_HAVE_GLX
+            "glx\n"
+        #endif
+        #ifdef FF_HAVE_OSMESA
+            "osmesa\n"
+        #endif
+        #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
         ""
     , stdout);

src/common/io.c

@@ -1,161 +0,0 @@
-#include "fastfetch.h"
-
-#include <stdio.h>
-#include <malloc.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdarg.h>
-#include <termios.h>
-
-bool ffWriteFDContent(int fd, const FFstrbuf* content)
-{
-    return write(fd, content->chars, content->length) != -1;
-}
-
-static void createSubfolders(const char* fileName)
-{
-    FFstrbuf path;
-    ffStrbufInit(&path);
-
-    while(*fileName != '\0')
-    {
-        ffStrbufAppendC(&path, *fileName);
-        if(*fileName == '/')
-            mkdir(path.chars, S_IRWXU | S_IRGRP | S_IROTH);
-        ++fileName;
-    }
-
-    ffStrbufDestroy(&path);
-}
-
-bool ffWriteFileContent(const char* fileName, const FFstrbuf* content)
-{
-    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 = ffWriteFDContent(fd, content);
-
-    close(fd);
-
-    return ret;
-}
-
-void ffAppendFDContent(int fd, FFstrbuf* buffer)
-{
-    ssize_t readed = 0;
-
-    ffStrbufEnsureFree(buffer, 31); // 32 - 1 for the null terminator
-    uint32_t free = ffStrbufGetFree(buffer);
-
-    while(
-        (readed = read(fd, buffer->chars + buffer->length, free)) > 0 &&
-        (uint32_t) readed == free
-    ) {
-        buffer->length += (uint32_t) readed;
-        ffStrbufEnsureCapacity(buffer, (buffer->allocated * 2) - 1); // -1 for null terminator
-        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, ' ');
-}
-
-bool ffAppendFileContent(const char* fileName, FFstrbuf* buffer)
-{
-    int fd = open(fileName, O_RDONLY);
-    if(fd == -1)
-        return false;
-
-    ffAppendFDContent(fd, buffer);
-
-    close(fd);
-    return true;
-}
-
-bool ffGetFileContent(const char* fileName, FFstrbuf* buffer)
-{
-    ffStrbufClear(buffer);
-    return ffAppendFileContent(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, char end, const char* format, ...)
-{
-    struct termios oldTerm, newTerm;
-    tcgetattr(STDIN_FILENO, &oldTerm);
-
-    newTerm = oldTerm;
-    newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
-    tcsetattr(STDIN_FILENO, TCSANOW, &newTerm);
-
-    fputs(request, stdout);
-
-    char buffer[512];
-    int pos = 0;
-    while((size_t) pos < sizeof(buffer) - 1)
-    {
-        char c = (char) getc(stdin);
-        if(c == '\0')
-            break;
-        buffer[pos++] = c;
-        if(c == end)
-            break;
-    }
-    buffer[pos] = '\0';
-
-    tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
-
-    va_list args;
-    va_start(args, format);
-    vsscanf(buffer, format, args);
-    va_end(args);
-}

src/common/io/io.h

@@ -0,0 +1,134 @@
+#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>
+    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);
+
+#ifndef _WIN32
+    FF_C_SCANF(2, 3)
+    void ffGetTerminalResponse(const char* request, const char* format, ...);
+#endif
+
+// 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)))
+
+#endif // FF_INCLUDED_common_io_io

src/common/io/io_unix.c

@@ -0,0 +1,226 @@
+#include "io.h"
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <termios.h>
+#include <poll.h>
+#include <dirent.h>
+
+static void createSubfolders(const char* fileName)
+{
+    FFstrbuf path;
+    ffStrbufInit(&path);
+
+    while(*fileName != '\0')
+    {
+        ffStrbufAppendC(&path, *fileName);
+        if(*fileName == '/')
+            mkdir(path.chars, S_IRWXU | S_IRGRP | S_IROTH);
+        ++fileName;
+    }
+
+    ffStrbufDestroy(&path);
+}
+
+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 &&
+        (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)
+{
+    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;
+}
+
+void ffGetTerminalResponse(const char* request, const char* format, ...)
+{
+    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);
+}
+
+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(strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+                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)
+{
+    FFstrbuf folder;
+    ffStrbufInitS(&folder, path);
+    ffStrbufEnsureEndsWithC(&folder, '/');
+    listFilesRecursively(&folder, 0, NULL);
+    ffStrbufDestroy(&folder);
+}

src/common/io/io_windows.c

@@ -0,0 +1,149 @@
+#include "io.h"
+
+static void createSubfolders(const char* fileName)
+{
+    FF_STRBUF_AUTO_DESTROY path;
+    ffStrbufInit(&path);
+
+    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)) &&
+        (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;
+}
+
+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 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(strcmp(entry.cFileName, ".") == 0 || strcmp(entry.cFileName, "..") == 0)
+                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)
+{
+    FFstrbuf folder;
+    ffStrbufInitS(&folder, path);
+    ffStrbufEnsureEndsWithC(&folder, '/');
+    listFilesRecursively(&folder, 0, NULL);
+    ffStrbufDestroy(&folder);
+}

src/common/library.c

@@ -1,11 +1,35 @@
 #include "fastfetch.h"
+#include "common/library.h"
 
 #include <stdarg.h>
 
+//Clang doesn't define __SANITIZE_ADDRESS__ but defines __has_feature(address_sanitizer)
+#if defined(__has_feature)
+    #if __has_feature(address_sanitizer)
+        #define __SANITIZE_ADDRESS__
+    #endif
+#endif
+
+#ifndef FF_DLOPEN_FLAGS
+    #ifdef __SANITIZE_ADDRESS__
+        #define FF_DLOPEN_FLAGS RTLD_LAZY | RTLD_NODELETE
+    #else
+        #define FF_DLOPEN_FLAGS RTLD_LAZY
+    #endif
+#endif
+
 static void* libraryLoad(const char* path, int maxVersion)
 {
-    void* result = dlopen(path, RTLD_LAZY);
-    if(result != NULL)
+    void* result = dlopen(path, FF_DLOPEN_FLAGS);
+
+    #ifdef _WIN32
+
+    // libX.dll.1 never exists on Windows, while libX-1.dll may exist
+    FF_UNUSED(maxVersion)
+
+    #else
+
+    if(result != NULL || maxVersion < 0)
         return result;
 
     FFstrbuf pathbuf;
@@ -18,7 +42,7 @@ static void* libraryLoad(const char* path, int maxVersion)
         uint32_t originalLength = pathbuf.length;
         ffStrbufAppendF(&pathbuf, "%i", i);
 
-        result = dlopen(pathbuf.chars, RTLD_LAZY);
+        result = dlopen(pathbuf.chars, FF_DLOPEN_FLAGS);
         if(result != NULL)
             break;
 
@@ -26,13 +50,16 @@ static void* libraryLoad(const char* path, int maxVersion)
     }
 
     ffStrbufDestroy(&pathbuf);
+
+    #endif
+
     return result;
 }
 
 void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)
 {
-    if(userProvidedName->length > 0)
-        return dlopen(userProvidedName->chars, RTLD_LAZY);
+    if(userProvidedName != NULL && userProvidedName->length > 0)
+        return dlopen(userProvidedName->chars, FF_DLOPEN_FLAGS);
 
     va_list defaultNames;
     va_start(defaultNames, userProvidedName);

src/common/library.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_library
+#define FF_INCLUDED_common_library
+
+#include "fastfetch.h"
+#include "util/FFcheckmacros.h"
+
+#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); }
+    static inline int dlclose(void* handle) { return !FreeLibrary((HMODULE)handle); }
+#else
+    #include <dlfcn.h>
+#endif
+
+#ifdef _WIN32
+    #define FF_LIBRARY_EXTENSION ".dll"
+#elif defined(__APPLE__)
+    #define FF_LIBRARY_EXTENSION ".dylib"
+#else
+    #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* __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); \
+    if(symbolMapping == NULL) \
+        return returnValue;
+
+#define FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, symbolMapping, symbolName, alternateName, returnValue) \
+    symbolMapping = dlsym(library, #symbolName); \
+    if(symbolMapping == NULL && !(symbolMapping = 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);
+
+#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);
+
+#define FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(library, varName, symbolName) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName.ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(library, varName, symbolName, alternateName) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, varName.ff ## symbolName, symbolName, alternateName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_PTR(library, varName, symbolName, returnValue) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName->ff ## symbolName, symbolName, returnValue);
+
+void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
+
+#endif

src/common/networking.c

@@ -1,69 +0,0 @@
-#include "fastfetch.h"
-
-#include <sys/types.h>
-#include <unistd.h>
-#include <sys/socket.h>
-#include <netdb.h>
-
-void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, FFstrbuf* buffer)
-{
-    struct addrinfo hints = {0};
-    hints.ai_family = AF_INET;
-    hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = 0;
-
-    struct addrinfo* addr;
-
-    if(getaddrinfo(host, "80", &hints, &addr) != 0)
-        return;
-
-    int sock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
-    if(sock == -1)
-    {
-        freeaddrinfo(addr);
-        return;
-    }
-
-    if(timeout > 0)
-    {
-        struct timeval timev;
-        timev.tv_sec = 0;
-        timev.tv_usec = timeout * 1000; //milliseconds to microseconds
-        setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
-    }
-
-    if(connect(sock, addr->ai_addr, addr->ai_addrlen) == -1)
-    {
-        close(sock);
-        freeaddrinfo(addr);
-        return;
-    }
-
-    freeaddrinfo(addr);
-
-    FFstrbuf command;
-    ffStrbufInitA(&command, 64);
-    ffStrbufAppendS(&command, "GET ");
-    ffStrbufAppendS(&command, path);
-    ffStrbufAppendS(&command, " HTTP/1.1\nHost: ");
-    ffStrbufAppendS(&command, host);
-    ffStrbufAppendS(&command, "\r\n\r\n");
-
-    if(send(sock, command.chars, command.length, 0) == -1)
-    {
-        ffStrbufDestroy(&command);
-        close(sock);
-        return;
-    }
-
-    ssize_t received = recv(sock, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);
-
-    if(received > 0)
-    {
-        buffer->length += (uint32_t) received;
-        buffer->chars[buffer->length] = '\0';
-    }
-
-    ffStrbufDestroy(&command);
-    close(sock);
-}

src/common/networking.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_networking
+#define FF_INCLUDED_common_networking
+
+#include "common/thread.h"
+#include "util/FFstrbuf.h"
+
+#ifdef _WIN32
+    #include <minwindef.h>
+#endif
+
+typedef struct FFNetworkingState {
+    #ifdef _WIN32
+        uintptr_t sockfd;
+        OVERLAPPED overlapped;
+    #else
+        int sockfd;
+        FFstrbuf host;
+        FFstrbuf command;
+
+        #ifdef FF_HAVE_THREADS
+            FFThreadType thread;
+        #endif
+    #endif
+} FFNetworkingState;
+
+bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers);
+bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout);
+
+static inline bool ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, const char* headers, FFstrbuf* buffer)
+{
+    FFNetworkingState state;
+    if(ffNetworkingSendHttpRequest(&state, host, path, headers))
+        return ffNetworkingRecvHttpResponse(&state, buffer, timeout);
+    return false;
+}
+
+#endif

src/common/networking_linux.c

@@ -0,0 +1,103 @@
+#include "fastfetch.h"
+#include "common/networking.h"
+
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netdb.h>
+
+static void connectAndSend(FFNetworkingState* state)
+{
+    struct addrinfo hints = {
+        .ai_family = AF_INET,
+        .ai_socktype = SOCK_STREAM,
+    };
+
+    struct addrinfo* addr;
+
+    if(getaddrinfo(state->host.chars, "80", &hints, &addr) != 0)
+        goto error;
+
+    state->sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+    if(state->sockfd == -1)
+    {
+        freeaddrinfo(addr);
+        goto error;
+    }
+
+    if(connect(state->sockfd, addr->ai_addr, addr->ai_addrlen) == -1)
+    {
+        close(state->sockfd);
+        freeaddrinfo(addr);
+        goto error;
+    }
+
+    freeaddrinfo(addr);
+
+    if(send(state->sockfd, state->command.chars, state->command.length, 0) < 0)
+    {
+        close(state->sockfd);
+        goto error;
+    }
+
+    goto exit;
+
+error:
+    state->sockfd = -1;
+
+exit:
+    ffStrbufDestroy(&state->host);
+    ffStrbufDestroy(&state->command);
+}
+
+FF_THREAD_ENTRY_DECL_WRAPPER(connectAndSend, FFNetworkingState*);
+
+bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
+{
+    ffStrbufInitS(&state->host, host);
+
+    ffStrbufInitA(&state->command, 64);
+    ffStrbufAppendS(&state->command, "GET ");
+    ffStrbufAppendS(&state->command, path);
+    ffStrbufAppendS(&state->command, " HTTP/1.1\nHost: ");
+    ffStrbufAppendS(&state->command, host);
+    ffStrbufAppendS(&state->command, "\r\n");
+    ffStrbufAppendS(&state->command, headers);
+    ffStrbufAppendS(&state->command, "\r\n");
+
+    #ifdef FF_HAVE_THREADS
+        state->thread = ffThreadCreate(connectAndSendThreadMain, state);
+        return !!state->thread;
+    #else
+        connectAndSend(state);
+        return state->sockfd != -1;
+    #endif
+}
+
+bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout)
+{
+    #ifdef FF_HAVE_THREADS
+        ffThreadJoin(state->thread);
+    #endif
+    if(state->sockfd == -1)
+        return false;
+
+    if(timeout > 0)
+    {
+        struct timeval timev;
+        timev.tv_sec = 0;
+        timev.tv_usec = (__typeof__(timev.tv_usec)) (timeout * 1000); //milliseconds to microseconds
+        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
+    }
+
+    ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);
+
+    if(received > 0)
+    {
+        buffer->length += (uint32_t) received;
+        buffer->chars[buffer->length] = '\0';
+    }
+
+    close(state->sockfd);
+    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n");
+}

src/common/networking_windows.c

@@ -0,0 +1,125 @@
+#include <mswsock.h>
+#include <ws2tcpip.h>
+
+//Must be included after <mswsock.h>
+#include "fastfetch.h"
+#include "common/networking.h"
+
+static LPFN_CONNECTEX ConnectEx;
+
+static BOOL WINAPI initWsaData(PINIT_ONCE once, PVOID param, PVOID* context)
+{
+    (void)once;
+    (void)param;
+    static WSADATA wsaData;
+    *context = &wsaData;
+    if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
+        return FALSE;
+
+    if(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
+        return FALSE;
+
+    //Dummy socket needed for WSAIoctl
+    SOCKET sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    if(sockfd == INVALID_SOCKET)
+        return FALSE;
+
+    DWORD dwBytes;
+    GUID guid = WSAID_CONNECTEX;
+    if(WSAIoctl(sockfd, SIO_GET_EXTENSION_FUNCTION_POINTER,
+                    &guid, sizeof(guid),
+                    &ConnectEx, sizeof(ConnectEx),
+                    &dwBytes, NULL, NULL) != 0)
+        return FALSE;
+
+    return closesocket(sockfd) == 0;
+}
+
+bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
+{
+    static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
+    WSADATA* pData;
+    if(!InitOnceExecuteOnce(&once, initWsaData, NULL, (LPVOID*) &pData))
+        return false;
+
+    memset(state, 0, sizeof(*state));
+
+    struct addrinfo hints = {
+        .ai_family = AF_INET,
+        .ai_socktype = SOCK_STREAM,
+    };
+
+    struct addrinfo* addr;
+
+    if(getaddrinfo(host, "80", &hints, &addr) != 0)
+        return false;
+
+    state->sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+    if(state->sockfd == INVALID_SOCKET)
+    {
+        freeaddrinfo(addr);
+        return false;
+    }
+
+    {
+        //ConnectEx requires the socket to be initially bound
+        struct sockaddr_in addr = {
+            .sin_family = AF_INET,
+            .sin_addr.s_addr = INADDR_ANY,
+            .sin_port = 0,
+        };
+        if(bind(state->sockfd, (SOCKADDR *)&addr, sizeof(addr)) != 0)
+        {
+            printf("bind %d\n", WSAGetLastError());
+            return false;
+        }
+    }
+
+    FF_STRBUF_AUTO_DESTROY command;
+    ffStrbufInitA(&command, 64);
+    ffStrbufAppendS(&command, "GET ");
+    ffStrbufAppendS(&command, path);
+    ffStrbufAppendS(&command, " HTTP/1.1\nHost: ");
+    ffStrbufAppendS(&command, host);
+    ffStrbufAppendS(&command, "\r\n");
+    ffStrbufAppendS(&command, headers);
+    ffStrbufAppendS(&command, "\r\n");
+
+    BOOL result = ConnectEx(state->sockfd, addr->ai_addr, (int)addr->ai_addrlen, command.chars, command.length, NULL, &state->overlapped);
+    freeaddrinfo(addr);
+
+    if(!result && WSAGetLastError() != WSA_IO_PENDING)
+    {
+        closesocket(state->sockfd);
+        return false;
+    }
+
+    return true;
+}
+
+bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout)
+{
+    DWORD transfer, flags;
+    if (!WSAGetOverlappedResult(state->sockfd, &state->overlapped, &transfer, TRUE, &flags))
+    {
+        closesocket(state->sockfd);
+        return false;
+    }
+
+    if(timeout > 0)
+    {
+        //https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-setsockopt
+        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
+    }
+
+    ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, (int)ffStrbufGetFree(buffer), 0);
+
+    if(received > 0)
+    {
+        buffer->length += (uint32_t) received;
+        buffer->chars[buffer->length] = '\0';
+    }
+
+    closesocket(state->sockfd);
+    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n");
+}

src/common/parsing.c

@@ -1,18 +1,13 @@
 #include "fastfetch.h"
+#include "common/parsing.h"
 
-bool ffStrSet(const char* str)
-{
-    if(str == NULL)
-        return false;
+#include <ctype.h>
+#include <inttypes.h>
 
-    while(*str != '\0')
-    {
-        if(*str != ' ' && *str != '\t' && *str != '\n' && *str != '\r')
-            return true;
-    }
-
-    return false;
-}
+#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)
 {
@@ -39,6 +34,63 @@ void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* mino
     ffStrbufAppend(buffer, patch);
 }
 
+int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2)
+{
+    if(version1->major != version2->major)
+        return version1->major > version2->major ? 1 : -1;
+
+    if(version1->minor != version2->minor)
+        return version1->minor > version2->minor ? 1 : -1;
+
+    if(version1->patch != version2->patch)
+        return version1->patch > version2->patch ? 1 : -1;
+
+    return 0;
+}
+
+void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty)
+{
+    if(version->major > 0 || version->minor > 0 || version->patch > 0)
+        ffStrbufAppendF(pretty, "%u", version->major);
+
+    if(version->minor > 0 || version->patch > 0)
+        ffStrbufAppendF(pretty, ".%u", version->minor);
+
+    if(version->patch > 0)
+        ffStrbufAppendF(pretty, ".%u", version->patch);
+}
+
+static void parseSize(FFstrbuf* result, uint64_t bytes, uint32_t base, uint8_t prefixesLength, const char** prefixes)
+{
+    long double size = (long double) bytes;
+    uint8_t counter = 0;
+
+    while(size >= base && counter < prefixesLength - 1)
+    {
+        size /= base;
+        counter++;
+    }
+
+    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]);
+}
+
+void ffParseSize(uint64_t bytes, FFBinaryPrefixType binaryPrefix, 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"});
+}
+
 void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
 {
     if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)
@@ -118,3 +170,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

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef FF_INCLUDED_parsing_h
+#define FF_INCLUDED_parsing_h
+
+#include "fastfetch.h"
+
+#include <stdint.h>
+
+typedef struct FFVersion
+{
+    uint32_t major;
+    uint32_t minor;
+    uint32_t patch;
+} FFVersion;
+
+#define FF_VERSION_INIT ((FFVersion) {0})
+
+void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch);
+void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4);
+
+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);
+
+#endif

src/common/printing.c

@@ -1,55 +1,128 @@
 #include "fastfetch.h"
+#include "common/printing.h"
+#include "util/textModifier.h"
 
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numFormatArgs, const char* message, ...)
+void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
 {
-    if(!instance->config.showErrors)
+    ffLogoPrintLine(instance);
+
+    //This is used by --set-keyless, in this case we wan't neither the module name nor the separator
+    if(moduleName == NULL)
         return;
 
-    va_list arguments;
-    va_start(arguments, message);
-
-    if(formatString == NULL || formatString->length == 0)
+    if(!instance->config.pipe)
     {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
-        vprintf(message, arguments);
-        puts(FASTFETCH_TEXT_MODIFIER_RESET);
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
+        ffPrintColor(&instance->config.colorKeys);
+    }
+
+    //NULL check is required for modules with custom keys, e.g. disk with the folder path
+    if(customKeyFormat == NULL || customKeyFormat->length == 0)
+    {
+        fputs(moduleName, stdout);
+
+        if(moduleIndex > 0)
+            printf(" %hhu", moduleIndex);
     }
     else
     {
-        FF_STRBUF_CREATE(error);
-        ffStrbufAppendVF(&error, message, arguments);
-
-        // calloc sets all to 0 and FF_FORMAT_ARG_TYPE_NULL also has value 0 so we don't need to explictly set it
-        FFformatarg* nullArgs = calloc(numFormatArgs, sizeof(FFformatarg));
-
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, &error, numFormatArgs, nullArgs);
-
-        free(nullArgs);
-        ffStrbufDestroy(&error);
+        FFstrbuf key;
+        ffStrbufInit(&key);
+        ffParseFormatString(&key, customKeyFormat, 1, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
+        });
+        ffPrintUserString(key.chars);
+        ffStrbufDestroy(&key);
     }
 
-    va_end(arguments);
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+    ffStrbufWriteTo(&instance->config.separator, stdout);
+
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 }
 
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
 {
     FFstrbuf buffer;
     ffStrbufInitA(&buffer, 256);
 
-    ffParseFormatString(&buffer, formatString, error, numArgs, arguments);
+    ffParseFormatString(&buffer, format, numArgs, arguments);
 
     if(buffer.length > 0)
     {
         ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffStrbufPutTo(&buffer, stdout);
+        ffPrintUserString(buffer.chars);
+        putchar('\n');
     }
 
     ffStrbufDestroy(&buffer);
 }
 
+void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* 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)
+        return;
+
+    if(hasCustomErrorFormat)
+    {
+        FFstrbuf error;
+        ffStrbufInit(&error);
+        ffStrbufAppendVF(&error, message, arguments);
+
+        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, 1, (FFformatarg[]) {
+            {FF_FORMAT_ARG_TYPE_STRBUF, &error}
+        });
+
+        ffStrbufDestroy(&error);
+    }
+    else
+    {
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+
+        if(!instance->config.pipe)
+            fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
+
+        vprintf(message, arguments);
+
+        if(!instance->config.pipe)
+            fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+        putchar('\n');
+    }
+}
+
+void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...)
+{
+    va_list arguments;
+    va_start(arguments, message);
+    printError(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, message, arguments);
+    va_end(arguments);
+}
+
+void ffPrintError(FFinstance* instance, 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);
+    va_end(arguments);
+}
+
 void ffPrintColor(const FFstrbuf* colorValue)
 {
+    //If the color is not set, this would reset in \033[m, which resets everything.
+    //So we only print it, if the main color is at least one char.
+    if(colorValue->length == 0)
+        return;
+
     fputs("\033[", stdout);
     ffStrbufWriteTo(colorValue, stdout);
     fputc('m', stdout);
@@ -57,6 +130,45 @@ void ffPrintColor(const FFstrbuf* colorValue)
 
 void ffPrintCharTimes(char c, uint32_t times)
 {
-    for(uint32_t i = 0; i < times; i++)
-        putchar(c);
+    if(times == 0)
+        return;
+
+    char str[32];
+    memset(str, c, sizeof(str)); //2 instructions when compiling with AVX2 enabled
+    for(uint32_t i = sizeof(str); i <= times; i += (uint32_t)sizeof(str))
+        fwrite(str, 1, sizeof(str), stdout);
+    uint32_t remaining = times % sizeof(str);
+    if(remaining > 0)
+        fwrite(str, 1, remaining, stdout);
+}
+
+void ffPrintUserString(const char* value)
+{
+    while(*value != '\0')
+    {
+        if(*value != '\\')
+        {
+            putchar(*value);
+            ++value;
+            continue;
+        }
+
+        ++value;
+
+        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;
+    }
 }

src/common/printing.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_printing
+#define FF_INCLUDED_common_printing
+
+#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, ...);
+void ffPrintColor(const FFstrbuf* colorValue);
+void ffPrintCharTimes(char c, uint32_t times);
+void ffPrintUserString(const char* str);
+
+#endif

src/common/processing.c

@@ -1,34 +0,0 @@
-#include "fastfetch.h"
-
-#include <sys/types.h>
-#include <unistd.h>
-#include <sys/wait.h>
-
-void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
-{
-    int pipes[2];
-
-    if(pipe(pipes) == -1)
-        return;
-
-    pid_t childPid = fork();
-    if(childPid == -1)
-        return;
-
-    //Child
-    if(childPid == 0)
-    {
-        dup2(pipes[1], STDOUT_FILENO);
-        close(pipes[0]);
-        close(pipes[1]);
-        close(STDERR_FILENO);
-        execvp(argv[0], argv);
-        exit(901);
-    }
-
-    //Parent
-    close(pipes[1]);
-    waitpid(childPid, NULL, 0);
-    ffAppendFDContent(pipes[0], buffer);
-    close(pipes[0]);
-}

src/common/processing.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_processing
+#define FF_INCLUDED_common_processing
+
+#include "util/FFstrbuf.h"
+
+const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
+
+#endif

src/common/processing_linux.c

@@ -0,0 +1,49 @@
+#include "fastfetch.h"
+#include "common/processing.h"
+#include "common/io/io.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
+{
+    int pipes[2];
+
+    if(pipe(pipes) == -1)
+        return "pipe() failed";
+
+    pid_t childPid = fork();
+    if(childPid == -1)
+        return "fork() failed";
+
+    //Child
+    if(childPid == 0)
+    {
+        dup2(pipes[1], STDOUT_FILENO);
+        close(pipes[0]);
+        close(pipes[1]);
+        close(STDERR_FILENO);
+        execvp(argv[0], argv);
+        exit(901);
+    }
+
+    //Parent
+    close(pipes[1]);
+
+    int FF_AUTO_CLOSE_FD childPipeFd = pipes[0];
+    int status = -1;
+    if(waitpid(childPid, &status, 0) < 0)
+        return "waitpid(childPid, &status, 0) failed";
+
+    if (!WIFEXITED(status))
+        return "WIFEXITED(status) == false";
+
+    if(WEXITSTATUS(status) == 901)
+        return "WEXITSTATUS(status) == 901 ( execvp failed )";
+
+    if(!ffAppendFDBuffer(childPipeFd, buffer))
+        return "ffAppendFDBuffer(childPipeFd, buffer) failed";
+
+    return NULL;
+}

src/common/processing_windows.c

@@ -0,0 +1,67 @@
+#include "fastfetch.h"
+#include "common/processing.h"
+
+#include <Windows.h>
+
+const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
+{
+    SECURITY_ATTRIBUTES saAttr = {
+        .nLength = sizeof(SECURITY_ATTRIBUTES),
+        .lpSecurityDescriptor = NULL,
+        .bInheritHandle = TRUE,
+    };
+
+    HANDLE hChildStdoutRead, hChildStdoutWrite;
+    if (!CreatePipe(&hChildStdoutRead, &hChildStdoutWrite, &saAttr, 0))
+        return "CreatePipe() failed";
+
+    if (!SetHandleInformation(hChildStdoutRead, HANDLE_FLAG_INHERIT, 0))
+        return "SetHandleInformation(hChildStdoutRead) 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]);
+        for(char* const* parg = &argv[1]; *parg; ++parg)
+        {
+            ffStrbufAppendC(&cmdline, ' ');
+            ffStrbufAppendS(&cmdline, *parg);
+        }
+
+        success = CreateProcessA(
+            NULL,          // application name
+            cmdline.chars, // command line
+            NULL,          // process security attributes
+            NULL,          // primary thread security attributes
+            TRUE,          // handles are inherited
+            0,             // creation flags
+            NULL,          // use parent's environment
+            NULL,          // use parent's current directory
+            &siStartInfo,  // STARTUPINFO pointer
+            &piProcInfo    // receives PROCESS_INFORMATION
+        );
+    }
+
+    CloseHandle(hChildStdoutWrite);
+    if(!success)
+    {
+        CloseHandle(hChildStdoutRead);
+        return "CreateProcessA() failed";
+    }
+
+    char str[1024];
+    DWORD nRead;
+    while(ReadFile(hChildStdoutRead, str, sizeof(str), &nRead, NULL) && nRead > 0)
+        ffStrbufAppendNS(buffer, nRead, str);
+
+    CloseHandle(hChildStdoutRead);
+    return NULL;
+}

src/common/properties.c

@@ -1,4 +1,10 @@
 #include "fastfetch.h"
+#include "common/properties.h"
+
+#include <stdlib.h>
+#ifdef _WIN32
+    #include "util/windows/getline.h"
+#endif
 
 static bool parsePropLinePointer(const char** line, const char* start, FFstrbuf* buffer)
 {
@@ -86,27 +92,30 @@ bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer)
 // The following functions return true if the file was found, independently if start was found
 // Buffers which already contain content are not overwritten
 // The last occurence of start in the first file will be the one used
-// The *Values methods always return true, if all properties were already found before, without testing if the file exists
 
 bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries)
 {
-    bool* searchedValues = malloc(sizeof(bool) * numQueries);
+    FILE* file = fopen(filename, "r");
+    if(file == NULL)
+        return false;
+
+    bool valueStorage[4];
+    bool* unsetValues;
+
+    if(numQueries > sizeof(valueStorage) / sizeof(valueStorage[0]))
+        unsetValues = malloc(sizeof(bool) * numQueries);
+    else
+        unsetValues = valueStorage;
+
     bool allSet = true;
     for(uint32_t i = 0; i < numQueries; i++)
     {
-        if((searchedValues[i] = queries[i].buffer->length == 0))
+        if((unsetValues[i] = queries[i].buffer->length == 0))
             allSet = false;
     }
 
     if(allSet)
-    {
-        free(searchedValues);
-        return true;
-    }
-
-    FILE* file = fopen(filename, "r");
-    if(file == NULL)
-        return false;
+        goto done;
 
     char* line = NULL;
     size_t len = 0;
@@ -115,7 +124,7 @@ bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquer
     {
         for(uint32_t i = 0; i < numQueries; i++)
         {
-            if(!searchedValues[i])
+            if(!unsetValues[i])
                 continue;
 
             uint32_t currentLength = queries[i].buffer->length;
@@ -125,26 +134,21 @@ bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquer
         }
     }
 
-    free(searchedValues);
-
     if(line != NULL)
         free(line);
 
+done:
     fclose(file);
-
+    if(unsetValues != valueStorage)
+        free(unsetValues);
     return true;
 }
 
-bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
-}
-
 bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
     FFstrbuf absolutePath;
     ffStrbufInitA(&absolutePath, 64);
-    ffStrbufAppendS(&absolutePath, instance->state.passwd->pw_dir);
+    ffStrbufAppend(&absolutePath, &instance->state.platform.homeDir);
     ffStrbufAppendC(&absolutePath, '/');
     ffStrbufAppendS(&absolutePath, relativeFile);
 
@@ -155,30 +159,22 @@ bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeF
     return result;
 }
 
-bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
-}
-
-bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
     bool foundAFile = false;
 
-    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
+
+    FF_LIST_FOR_EACH(FFstrbuf, dirPrefix, *list)
     {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-        uint32_t baseDirLength = baseDir->length;
+        //We need to copy the dir each time, because it used by multiple threads, so we can't directly write to it.
+        ffStrbufSet(&baseDir, dirPrefix);
+        ffStrbufAppendS(&baseDir, relativeFile);
 
-        if(*relativeFile != '/')
-            ffStrbufAppendC(baseDir, '/');
-
-        ffStrbufAppendS(baseDir, relativeFile);
-
-        if(ffParsePropFileValues(baseDir->chars, numQueries, queries))
+        if(ffParsePropFileValues(baseDir.chars, numQueries, queries))
             foundAFile = true;
 
-        ffStrbufSubstrBefore(baseDir, baseDirLength);
-
         bool allSet = true;
         for(uint32_t k = 0; k < numQueries; k++)
         {
@@ -193,10 +189,7 @@ bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativ
             break;
     }
 
+    ffStrbufDestroy(&baseDir);
+
     return foundAFile;
 }
-
-bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
-}

src/common/properties.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_properties
+#define FF_INCLUDED_common_properties
+
+#include "fastfetch.h"
+
+typedef struct FFpropquery
+{
+    const char* start;
+    FFstrbuf* buffer;
+} FFpropquery;
+
+bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer);
+bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFileHomeValues(const FFinstance* instance, 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)
+{
+    return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
+}
+
+static inline bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}
+
+static inline bool ffParsePropFileList(const FFlist* list, const char* relativeFile, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileListValues(list, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}
+
+static inline bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* 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)
+{
+    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}
+
+static inline bool ffParsePropFileDataValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* 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)
+{
+    return ffParsePropFileDataValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}
+
+#endif

src/common/settings.c

@@ -1,21 +1,32 @@
 #include "fastfetch.h"
+#include "common/settings.h"
+#include "common/library.h"
+#include "common/thread.h"
+#include "common/io/io.h"
 
-#include <pthread.h>
+#include <string.h>
+
+typedef enum FFInitState
+{
+    FF_INITSTATE_UNINITIALIZED = 0,
+    FF_INITSTATE_SUCCESSFUL = 1,
+    FF_INITSTATE_FAILED = 2
+} FFInitState;
 
 #define FF_LIBRARY_DATA_LOAD_INIT(dataObject, userLibraryName, ...) \
     static dataObject data; \
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \
+    static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER; \
     static FFInitState initState = FF_INITSTATE_UNINITIALIZED; \
-    pthread_mutex_lock(&mutex); \
+    ffThreadMutexLock(&mutex); \
     if(initState != FF_INITSTATE_UNINITIALIZED) {\
-        pthread_mutex_unlock(&mutex); \
+        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; \
-        pthread_mutex_unlock(&mutex); \
+        ffThreadMutexUnlock(&mutex); \
         return NULL; \
     } \
 
@@ -24,20 +35,20 @@
     if(data.ff ## symbolName == NULL) { \
         dlclose(libraryHandle); \
         initState = FF_INITSTATE_FAILED; \
-        pthread_mutex_unlock(&mutex); \
+        ffThreadMutexUnlock(&mutex); \
         return NULL; \
     }
 
 #define FF_LIBRARY_DATA_LOAD_RETURN \
     initState = FF_INITSTATE_SUCCESSFUL; \
-    pthread_mutex_unlock(&mutex); \
+    ffThreadMutexUnlock(&mutex); \
     return &data;
 
 #define FF_LIBRARY_DATA_LOAD_ERROR \
     { \
         dlclose(libraryHandle); \
         initState = FF_INITSTATE_FAILED; \
-        pthread_mutex_unlock(&mutex); \
+        ffThreadMutexUnlock(&mutex); \
         return NULL; \
     }
 
@@ -46,23 +57,31 @@
 
 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
@@ -78,9 +97,9 @@ typedef struct GSettingsData
     GVariantGetters variantGetters;
 } GSettingsData;
 
-static const GSettingsData* getGSettingsData(FFinstance* instance)
+static const GSettingsData* getGSettingsData(const FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0.so", 1);
+    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.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)
@@ -91,9 +110,10 @@ static const GSettingsData* getGSettingsData(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();
@@ -103,7 +123,7 @@ static const GSettingsData* getGSettingsData(FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
     const GSettingsData* data = getGSettingsData(instance);
     if(data == NULL)
@@ -132,7 +152,7 @@ FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, c
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_GIO
-FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
     FF_UNUSED(instance, schemaName, path, key, type)
     return FF_VARIANT_NULL;
@@ -150,15 +170,15 @@ typedef struct DConfData
     DConfClient* client;
 } DConfData;
 
-static const DConfData* getDConfData(FFinstance* instance)
+static const DConfData* getDConfData(const FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf.so", 2);
+    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.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)
     #undef data
@@ -170,7 +190,7 @@ static const DConfData* getDConfData(FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
 {
     const DConfData* data = getDConfData(instance);
     if(data == NULL)
@@ -188,14 +208,14 @@ FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttyp
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_DCONF
-FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
 {
     FF_UNUSED(instance, key, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_DCONF
 
-FFvariant ffSettingsGet(FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
+FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
 {
     FFvariant gsettings = ffSettingsGetGSettings(instance, gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
 
@@ -220,9 +240,9 @@ typedef struct XFConfData
     FF_LIBRARY_SYMBOL(xfconf_init)
 } XFConfData;
 
-static const XFConfData* getXFConfData(FFinstance* instance)
+static const XFConfData* getXFConfData(const FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0.so", 4);
+    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get)
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_has_property)
@@ -237,7 +257,7 @@ static const XFConfData* getXFConfData(FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
 {
     const XFConfData* data = getXFConfData(instance);
     if(data == NULL)
@@ -260,19 +280,131 @@ FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, con
     return FF_VARIANT_NULL;
 }
 #else //FF_HAVE_XFCONF
-FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
 {
     FF_UNUSED(instance, channelName, propertyName, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_XFCONF
 
+#ifdef FF_HAVE_SQLITE3
+#include <sqlite3.h>
+
+typedef struct SQLiteData
+{
+    FF_LIBRARY_SYMBOL(sqlite3_open_v2)
+    FF_LIBRARY_SYMBOL(sqlite3_prepare_v2)
+    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)
+{
+    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance->config.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)
+{
+    if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
+        return 0;
+
+    const SQLiteData* data = getSQLiteData(instance);
+    if(data == NULL)
+        return 0;
+
+    sqlite3* db;
+    if(data->ffsqlite3_open_v2(dbPath, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
+        return 0;
+
+    sqlite3_stmt* stmt;
+    if(data->ffsqlite3_prepare_v2(db, query, (int) strlen(query), &stmt, NULL) != SQLITE_OK)
+    {
+        data->ffsqlite3_close(db);
+        return 0;
+    }
+
+    if(data->ffsqlite3_step(stmt) != SQLITE_ROW || data->ffsqlite3_data_count(stmt) < 1)
+    {
+        data->ffsqlite3_finalize(stmt);
+        data->ffsqlite3_close(db);
+        return 0;
+    }
+
+    int result = data->ffsqlite3_column_int(stmt, 0);
+
+    data->ffsqlite3_finalize(stmt);
+    data->ffsqlite3_close(db);
+
+    return result;
+}
+
+bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result)
+{
+    if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
+        return false;
+
+    const SQLiteData* data = getSQLiteData(instance);
+    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 FFinstance* instance, const char* dbPath, const char* query)
+{
+    FF_UNUSED(instance, dbPath, query)
+    return 0;
+}
+bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result)
+{
+    FF_UNUSED(instance, dbPath, query, result)
+    return false;
+}
+#endif //FF_HAVE_SQLITE3
+
 #ifdef __ANDROID__
 #include <sys/system_properties.h>
-bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
-    uint32_t originalLength = result->length;
+void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
     ffStrbufEnsureFree(result, PROP_VALUE_MAX);
     result->length += (uint32_t) __system_property_get(propName, result->chars + result->length);
-    return result->length > originalLength;
+    result->chars[result->length] = '\0';
 }
-#endif
+#endif //__ANDROID__

src/common/settings.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_settings
+#define FF_INCLUDED_common_settings
+
+#include "fastfetch.h"
+
+typedef enum FFvarianttype
+{
+    FF_VARIANT_TYPE_STRING,
+    FF_VARIANT_TYPE_BOOL,
+    FF_VARIANT_TYPE_INT
+} FFvarianttype;
+
+typedef union FFvariant
+{
+    const char* strValue;
+    int32_t intValue;
+    struct
+    {
+        bool boolValueSet;
+        bool boolValue;
+    };
+} 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);
+
+int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query);
+bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result);
+
+#ifdef __ANDROID__
+void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
+#endif
+
+#endif

src/common/sysctl.c

@@ -0,0 +1,55 @@
+#include "sysctl.h"
+
+#include <stdlib.h>
+
+const char* ffSysctlGetString(const char* propName, FFstrbuf* result)
+{
+    size_t neededLength;
+    if(sysctlbyname(propName, NULL, &neededLength, NULL, 0) != 0 || neededLength == 1) //neededLength is 1 for empty strings, because of the null terminator
+        return "sysctlbyname() failed";
+
+    ffStrbufEnsureFree(result, (uint32_t) neededLength - 1);
+
+    if(sysctlbyname(propName, result->chars + result->length, &neededLength, NULL, 0) == 0)
+        result->length += (uint32_t) neededLength - 1;
+
+    result->chars[result->length] = '\0';
+
+    return NULL;
+}
+
+int ffSysctlGetInt(const char* propName, int defaultValue)
+{
+    int result;
+    size_t neededLength = sizeof(result);
+    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
+        return defaultValue;
+    return result;
+}
+
+int64_t ffSysctlGetInt64(const char* propName, int64_t defaultValue)
+{
+    int64_t result;
+    size_t neededLength = sizeof(result);
+    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
+        return defaultValue;
+    return result;
+}
+
+void* ffSysctlGetData(int* request, u_int requestLength, size_t* resultLength)
+{
+    if(sysctl(request, requestLength, NULL, resultLength, NULL, 0) != 0)
+        return NULL;
+
+    void* data = malloc(*resultLength);
+    if(data == NULL)
+        return NULL;
+
+    if(sysctl(request, requestLength, data, resultLength, NULL, 0) != 0)
+    {
+        free(data);
+        return NULL;
+    }
+
+    return data;
+}

src/common/sysctl.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_sysctl
+#define FF_INCLUDED_common_sysctl
+
+#include "fastfetch.h"
+#include "util/FFcheckmacros.h"
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+const char* ffSysctlGetString(const char* propName, FFstrbuf* result);
+FF_C_NODISCARD int ffSysctlGetInt(const char* propName, int defaultValue);
+FF_C_NODISCARD int64_t ffSysctlGetInt64(const char* propName, int64_t defaultValue);
+FF_C_NODISCARD void* ffSysctlGetData(int* request, u_int requestLength, size_t* resultLength);
+
+#endif

src/common/thread.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_thread
+#define FF_INCLUDED_common_thread
+
+#include "fastfetch.h"
+
+#ifdef FF_HAVE_THREADS
+    #if defined(_WIN32)
+        #include <handleapi.h>
+        #include <synchapi.h>
+        #include <process.h>
+        #define FF_THREAD_MUTEX_INITIALIZER SRWLOCK_INIT
+        typedef SRWLOCK FFThreadMutex;
+        typedef HANDLE FFThreadType;
+        static inline void ffThreadMutexLock(FFThreadMutex* mutex) { AcquireSRWLockExclusive(mutex); }
+        static inline void ffThreadMutexUnlock(FFThreadMutex* mutex) { ReleaseSRWLockExclusive(mutex); }
+        static inline FFThreadType ffThreadCreate(unsigned (__stdcall* func)(void*), void* data) {
+            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; }
+        static inline void ffThreadDetach(FFThreadType thread) { CloseHandle(thread); }
+        static inline void ffThreadJoin(FFThreadType thread) { WaitForSingleObject(thread, 0xffffffff /*INFINITE*/); }
+    #else
+        #include <pthread.h>
+        #define FF_THREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+        typedef pthread_mutex_t FFThreadMutex;
+        typedef pthread_t FFThreadType;
+        static inline void ffThreadMutexLock(FFThreadMutex* mutex) { pthread_mutex_lock(mutex); }
+        static inline void ffThreadMutexUnlock(FFThreadMutex* mutex) { pthread_mutex_unlock(mutex); }
+        static inline FFThreadType ffThreadCreate(void* (* func)(void*), void* data) {
+            FFThreadType newThread = 0;
+            pthread_create(&newThread, NULL, func, data);
+            return newThread;
+        }
+        #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType) static void* fn ## ThreadMain (void* data) { fn((paramType)data); return NULL; }
+        static inline void ffThreadDetach(FFThreadType thread) { pthread_detach(thread); }
+        static inline void ffThreadJoin(FFThreadType thread) { pthread_join(thread, NULL); }
+    #endif
+#else //FF_HAVE_THREADS
+    #define FF_THREAD_MUTEX_INITIALIZER 0
+    typedef char FFThreadMutex;
+    static inline void ffThreadMutexLock(FFThreadMutex* mutex) { FF_UNUSED(mutex) }
+    static inline void ffThreadMutexUnlock(FFThreadMutex* mutex) { FF_UNUSED(mutex) }
+    #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType)
+#endif //FF_HAVE_THREADS
+
+#endif

src/common/threading.c

@@ -1,72 +0,0 @@
-#include "fastfetch.h"
-
-#include <pthread.h>
-
-static inline void* detectPlasmaThreadMain(void* instance)
-{
-    ffDetectPlasma((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK2ThreadMain(void* instance)
-{
-    ffDetectGTK2((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK3ThreadMain(void* instance)
-{
-    ffDetectGTK3((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK4ThreadMain(void* instance)
-{
-    ffDetectGTK4((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* connectDisplayServerThreadMain(void* instance)
-{
-    ffConnectDisplayServer((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* startThreadsThreadMain(void* instance)
-{
-    pthread_t dsThread;
-    pthread_create(&dsThread, NULL, connectDisplayServerThreadMain, instance);
-    pthread_detach(dsThread);
-
-    pthread_t gtk2Thread;
-    pthread_create(&gtk2Thread, NULL, detectGTK2ThreadMain, instance);
-    pthread_detach(gtk2Thread);
-
-    pthread_t gtk3Thread;
-    pthread_create(&gtk3Thread, NULL, detectGTK3ThreadMain, instance);
-    pthread_detach(gtk3Thread);
-
-    pthread_t gtk4Thread;
-    pthread_create(&gtk4Thread, NULL, detectGTK4ThreadMain, instance);
-    pthread_detach(gtk4Thread);
-
-    pthread_t plasmaThread;
-    pthread_create(&plasmaThread, NULL, detectPlasmaThreadMain, instance);
-    pthread_detach(plasmaThread);
-
-    return NULL;
-}
-
-void ffStartDetectionThreads(FFinstance* instance)
-{
-    //Android needs none of the things that are detected here
-    //And using gsettings sometimes hangs the program in android for some unknown reason,
-    //and since we don't need it we just never call it.
-    #ifdef __ANDROID__
-        return;
-    #endif
-
-    pthread_t startThreadsThread;
-    pthread_create(&startThreadsThread, NULL, startThreadsThreadMain, instance);
-    pthread_detach(startThreadsThread);
-}

src/common/time.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_time
+#define FF_INCLUDED_common_time
+
+#include <stdint.h>
+#ifdef _WIN32
+    #include <synchapi.h>
+    #include <profileapi.h>
+#else
+    #include <time.h>
+#endif
+
+static inline uint64_t ffTimeGetTick() //In msec
+{
+    #ifdef _WIN32
+        LARGE_INTEGER frequency;
+        QueryPerformanceFrequency(&frequency);
+        LARGE_INTEGER start;
+        QueryPerformanceCounter(&start);
+        return (uint64_t)(start.QuadPart * 1000 / frequency.QuadPart);
+    #else
+        struct timespec timeNow;
+        clock_gettime(CLOCK_MONOTONIC, &timeNow);
+        return (uint64_t)((timeNow.tv_sec * 1000) + (timeNow.tv_nsec / 1000000));
+    #endif
+}
+
+static inline void ffTimeSleep(uint32_t msec)
+{
+    #ifdef _WIN32
+        SleepEx(msec, TRUE);
+    #else
+        nanosleep(&(struct timespec){ msec / 1000, (msec % 1000) * 1000000 }, NULL);
+    #endif
+}
+
+#endif

src/data/config.txt

@@ -1,232 +0,0 @@
-# Fastfetch configuration
-# Write every argument in different lines.
-# Direct arguments will overwrite the corresponding ones in this file.
-# Argument keys are not case sensitive.
-# Whitespaces are trimmed at the beginning and the end.
-# Empty lines or lines starting with # are ignored.
-
-# This file was shipped with $"FASTFETCH_PROJECT_VERSION$".
-# Use fastfetch --print-config > ~/.config/fastfetch/config.conf to overwrite this with the current defaults
-
-# Below some often usefull options are listed. Uncomment and modify them so they take affect.
-# Note that there are a lot more options than the ones listed here, take a look at "fastfetch --help".
-# Of course all of them can be made persistent here too.
-
-# Config option:
-# Load additional config files.
-# Some are shipped with fastfetch, list them with "fastfetch --list-presets".
-# Must be a path to a config file or the name of a shipped preset.
-# The config file is completly loaded before continuing in the current file, so the placement of this option matters, as later options overwrite already set ones.
-# Can be used multiple times to load multiple config files / presets.
-#--load-config /path/to/config.txt
-
-# Structure option:
-# Sets the modules to use and their order.
-# Must be a list of module names, separated by colons.
-# List available modules with "fastfetch --list-modules".
-# Get the default structure with "fastfetch --print-structure".
-#--structure $"FASTFETCH_DATATEXT_STRUCTURE$"
-
-# Multithreading option:
-# Sets if fastfetch should use multiple threads to detect the values.
-# Must be true or false.
-# Default is true.
-#--multithreading true
-
-# Slow operations option:
-# Sets if fastfetch is allowed to use known slow operations to detect more / better values.
-# Must be true or false.
-# Default is false.
-#--allow-slow-operations false
-
-# Linewrap option:
-# Sets if fastfetch should disable linewrap during the run.
-# Must be true or false.
-# Default is true.
-#--disable-linewrap true
-
-# Cursor option:
-# Sets if fastfetch should hide the console cursor during the run.
-# Must be true or false.
-# Default is true.
-#--hide-cursor true
-
-# Logo option:
-# Sets the logo to use.
-# List available logos with "fastfetch --list-logos".
-# Print available logos with "fastfetch --print-logos".
-# Must be the name of an available logo or a path to a text file containing a custom logo.
-# Default is the current distribution.
-#--logo arch
-
-# Logo type option:
-# Sets the logo type to use.
-# Must be auto, builtin, file, raw, sixel or kitty.
-# Default is auto.
-#--logo-type auto
-
-# Logo width option:
-# Sets the width of the logos (in characters) if the logo is an image.
-# Must be a positive integer.
-# Default is 65.
-#--logo-width 65
-
-# Logo color options:
-# Overwrite a color in the logo. Also works for user provided logos.
-# In the user logo, they replace $[1-9]. Use $$ to print a single $ sign.
-# Must be linux console color codes or the name of a color.
-# Default is the one specified by the logo.
-# Use "fastfetch --help color" to learn more and see examples.
-# Valid index range is [1-9].
-#--logo-color-1 red
-#--logo-color-2 32
-# [...]
-#--logo-color-9 yellow
-
-# Logo padding option:
-# Adds a padding to the left and the right side of the logo.
-# Must be a positive integer.
-# Default is 0.
-#--logo-padding 0
-
-# Logo padding left option:
-# Adds a padding to the left side of the logo.
-# Must be a positive integer.
-# Default is 0.
-#--logo-padding-left 0
-
-# Logo padding right option:
-# Adds a padding to the right side of the logo.
-# Must be a positive integer.
-# Default is 0.
-#--logo-padding-right 0
-
-# Logo print remaining option:
-# Sets if the remaining logo should be printed, it is has more lines than modules to show.
-# Must be true or false.
-# Default is true.
-#--logo-print-remaining true
-
-# Color option:
-# Sets the color of the keys.
-# Must be linux console color codes or the name of a color.
-# Default is the primary color of the logo.
-# Use "fastfetch --help color" to learn more and see examples.
-#--color magenta
-
-# Separator option:
-# Sets the string placed between a key and its value.
-# Can be any string.
-# Default is ": ".
-#--separator ": "
-
-# Separator string option:
-# Sets the string printed by the "separator" module (usually between title and rest of output)
-# Must be any string. It is repated / cut to fit perfectly.
-# Default is "-"
-#--separator-string -
-
-# 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
-
-# OS file option
-# Sets the path to the file containing the operating system information.
-# Should be a valid path to an existing file.
-# Note that you might need to run fastfetch with --recache once for it to take affect.
-# Default is /etc/os-release.
-#--os-file /etc/os-release
-
-# Player name option
-# Sets the name of the player. This is also used in song detection
-# Must be the exact name of the player or a dbus address (e.g. org.mpris.MediaPlayer2.spotify)
-# Default is the first match starting with org.mpris.MediaPlayer2.
-#--player-name spotify
-
-# Key options:
-# Sets the displayed key of a module
-# Can be any string. Some of theme take an argument like a format string. See "fastfetch --help format" for help.
-#--os-key OS
-#--host-key Host
-#--kernel-key Kernel
-#--uptime-key Uptime
-#--processes-key Processes
-#--packages-key Packages
-#--shell-key Shell
-#--resolution-key Resolution {1}
-#--de-key DE
-#--wm-key WM
-#--wm-theme-key WM Theme
-#--theme-key Theme
-#--icons-key Icons
-#--font-key Font
-#--cursor-key Cursor
-#--terminal-key Terminal
-#--terminal-font-key Terminal Font
-#--cpu-key CPU
-#--cpu-usage-key CPU Usage
-#--gpu-key GPU {1}
-#--memory-key Memory
-#--disk-key Disk ({1})
-#--battery-key Battery {1}
-#--locale-key Locale
-#--local-ip-key Local IP ({1})
-#--public-ip-key Public IP
-#--player-key Media Player
-#--song-key Song
-#--datetime-key Date Time
-
-# 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.
-#--os-format
-#--host-format
-#--kernel-format
-#--uptime-format
-#--processes-format
-#--packages-format
-#--shell-format
-#--resolution-format
-#--de-format
-#--wm-format
-#--wm-theme-format
-#--theme-format
-#--icons-format
-#--font-format
-#--cursor-format
-#--terminal-format
-#--terminal-font-format
-#--cpu-format
-#--cpu-usage-format
-#--gpu-format
-#--memory-format
-#--disk-format
-#--battery-format
-#--locale-format
-#--local-ip-format
-#--public-ip-format
-#--player-format
-#--song-format
-#--datetime-format
-
-# Library options:
-# Sets an user specific path to a library to load.
-# Must be a valid path to a library.
-#--lib-PCI /usr/lib/libpci.so
-#--lib-vulkan /usr/lib/libvulkan.so
-#--lib-wayland /usr/lib/libwayland-client.so
-#--lib-xcb-randr /usr/lib/libxcb-randr.so
-#--lib-xcb /usr/lib/libxcb.so
-#--lib-Xrandr /usr/lib/libXrandr.so
-#--lib-X11 /usr/lib/libX11.so
-#--lib-gio /usr/lib/libgio-2.0.so
-#--lib-DConf /usr/lib/libdconf.so
-#--lib-DBus /usr/lib/libdbus-1.so
-#--lib-XFConf /usr/lib/libxfconf-0.so
-#--lib-rpm /usr/lib/librpm.so
-#--lib-imagemagick /usr/lib/libMagickCore-7.Q16HDRI.so
-#--lib-z /usr/lib/libz.so

src/data/config_system.txt

@@ -0,0 +1,16 @@
+# Fastfetch system configuration
+# 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.
+# 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
+# to overwrite this file with the current default file.
+
+# User config option
+# Sets if fastfetch should load user provided configuration.
+# If this is off, fastfetch ignores the user config file and any passed arguments
+# Must be true or false
+# Default is true.
+#--load-user-config true

src/data/config_user.txt

@@ -0,0 +1,461 @@
+# Fastfetch configuration
+# Write every argument in different lines.
+# Direct arguments will overwrite the corresponding ones in this file.
+# Argument keys are not case sensitive.
+# Whitespaces are trimmed at the beginning and the end.
+# Empty lines or lines starting with # are ignored.
+
+# This file was shipped with $" FASTFETCH_PROJECT_VERSION $".
+# Use fastfetch --gen-config-force to overwrite this file with the current defaults
+
+# Below some often usefull options are listed. Uncomment and modify them so they take affect.
+# Note that there are a lot more options than the ones listed here, take a look at "fastfetch --help".
+# Of course all of them can be made persistent here too.
+
+# Config option:
+# Load additional config files.
+# Some are shipped with fastfetch, list them with "fastfetch --list-presets".
+# Must be a path to a config file or the name of a shipped preset.
+# The config file is completely loaded before continuing in the current file, so the placement of this option matters, as later options overwrite already set ones.
+# Can be used multiple times to load multiple config files / presets.
+#--load-config /path/to/config.txt
+
+# Structure option:
+# Sets the modules to use and their order.
+# Must be a list of module names, separated by colons.
+# List available modules with "fastfetch --list-modules".
+# Get the default structure with "fastfetch --print-structure".
+#--structure $" FASTFETCH_DATATEXT_STRUCTURE $"
+
+# Multithreading option:
+# Sets if fastfetch should use multiple threads to detect the values.
+# Must be true or false.
+# Default is true.
+#--multithreading true
+
+# Print stat option:
+# Sets if fastfetch should print time usage (in ms) for individual modules
+# If true, it will also enable --show-errors
+# Must be true or false.
+# Default is false.
+#--stat true
+
+# Slow operations option:
+# Sets if fastfetch is allowed to use known slow operations to detect more / better values.
+# Must be true or false.
+# Default is false.
+#--allow-slow-operations false
+
+# Linewrap option:
+# Sets if fastfetch should disable linewrap during the run.
+# Must be true or false.
+# Default is true.
+#--disable-linewrap true
+
+# Cursor option:
+# Sets if fastfetch should hide the console cursor during the run.
+# Must be true or false.
+# Default is true.
+#--hide-cursor true
+
+# Logo option:
+# Sets the logo to use.
+# List available logos with "fastfetch --list-logos".
+# Print available logos with "fastfetch --print-logos".
+# Must be the name of an available logo or a path to a text file containing a custom logo.
+# Default is the current distribution.
+#--logo arch
+
+# Logo type option:
+# Sets the logo type to use.
+# Must be auto, builtin, file, file-raw, data, data-raw, sixel, kitty or chafa.
+# Default is auto.
+#--logo-type auto
+
+# Logo width option:
+# Sets the width of the logo (in characters) if the logo is an image.
+# Must be a positive integer.
+# Default is 65.
+#--logo-width 65
+
+# Logo height option:
+# Sets the height of the logo (in characters) if the logo is an image.
+# Must be a positive integer.
+# Default is 0 (keeps aspect ration).
+#--logo-height 0
+
+# Logo color options:
+# Overwrite a color in the logo. Also works for user provided logos.
+# In the user logo, they replace $[1-9]. Use $$ to print a single $ sign.
+# Must be linux console color codes or the name of a color.
+# Default is the one specified by the logo.
+# Use "fastfetch --help color" to learn more and see examples.
+# Valid index range is [1-9].
+#--logo-color-1 red
+#--logo-color-2 32
+# [...]
+#--logo-color-9 yellow
+
+# Logo padding option:
+# Adds a padding to the left and the right side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding 0
+
+# Logo padding left option:
+# Adds a padding to the left side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding-left 0
+
+# Logo padding right option:
+# Adds a padding to the right side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding-right 0
+
+# Logo padding top option:
+# Adds a padding to the top side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding-top 0
+
+# Logo print remaining option:
+# Sets if the remaining logo should be printed, it is has more lines than modules to show.
+# Must be true or false.
+# Default is true.
+#--logo-print-remaining true
+
+# Color keys option:
+# Sets the color of the keys.
+# Must be linux console color codes or the name of a color.
+# Default is the key color of the logo.
+# Use "fastfetch --help color" to learn more and see examples.
+#--color-keys magenta
+
+# Color title option:
+# Sets the color of the title.
+# Must be linux console color codes or the name of a color.
+# Default is the title color of the logo.
+# Use "fastfetch --help color" to learn more and see examples.
+#--color-title magenta
+
+# Binary prefix option:
+# Sets the binary prefix to use.
+# Must be a IEC, SI or JEDEC.
+# Default is IEC.
+#--binary-prefix IEC
+
+# 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
+
+# Separator option:
+# Sets the string placed between a key and its value.
+# Can be any string.
+# Default is ": ".
+#--separator ": "
+
+# Separator string option:
+# Sets the string printed by the "separator" module (usually between title and rest of output)
+# Must be any string. It is repated / cut to fit perfectly.
+# Default is "-"
+#--separator-string -
+
+# Public IP URL option:
+# 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".
+#--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).
+#--publicip-timeout 0
+
+# Weather output format option:
+# Sets the weather format to be used. It must be URI encoded.
+# See: https://github.com/chubin/wttr.in#one-line-output
+# Default is "%t+-+%C+(%l)".
+#--weather-output-format "%t+-+%C+(%l)"
+
+# Weather timeout option:
+# Sets the time to wait for the weather server (wttr.in) to respond.
+# Must be a positive integer.
+# Default is 0 (disabled).
+#--weather-timeout 0
+
+# OS file option
+# Sets the path to the file containing the operating system information.
+# Should be a valid path to an existing file.
+# Default is /etc/os-release.
+#--os-file /etc/os-release
+
+# Player name option
+# Sets the name of the player. This is also used in song detection
+# Must be the exact name of the player or a dbus address (e.g. org.mpris.MediaPlayer2.spotify)
+# Default is the first match starting with org.mpris.MediaPlayer2.
+#--player-name spotify
+
+# 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
+# Sets with opengl context creation library to use
+# Must be either auto, egl, glx or osmesa
+# Default is auto.
+#--gl auto
+
+# GPU hide options
+# Sets weather to hide certain gpu types
+# Must be either true or false
+# Default is false.
+#--gpu-hide-integrated
+#--gpu-hide-discrete
+
+# 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 false.
+#--gpu-force-vulkan
+
+# Shell option
+# Sets if shell version should be detected and printed
+# 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
+
+# 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
+#--disk-show-hidden false
+#--disk-show-subvolumes false
+#--disk-show-unknown false
+
+# Disk option
+# A colon (semicolon on Windows) separated list of folder paths for the disk output
+# This option override `--disk-show-*` options above
+# Must be a string
+# 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; 9: prints colored number
+#--percent-type 1
+
+# Key options:
+# Sets the displayed key of a module
+# Can be any string. Some of theme take an argument like a format string. See "fastfetch --help format" for help.
+#--os-key OS
+#--host-key Host
+#--chassis-key Chassis
+#--kernel-key Kernel
+#--uptime-key Uptime
+#--processes-key Processes
+#--packages-key Packages
+#--shell-key Shell
+#--display-key Display {1}
+#--brightness-key Brightness ({1})
+#--de-key DE
+#--wm-key WM
+#--wm-theme-key WM Theme
+#--theme-key Theme
+#--icons-key Icons
+#--font-key Font
+#--cursor-key Cursor
+#--terminal-key Terminal
+#--terminal-font-key Terminal Font
+#--cpu-key CPU
+#--cpu-usage-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}
+#--locale-key Locale
+#--localip-key Local IP ({1})
+#--publicip-key Public IP
+#--wifi-key Wifi
+#--weather-key Weather
+#--player-key Media Player
+#--media-key Media
+#--datetime-key Date Time
+#--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.
+#--os-format
+#--host-format
+#--chassis-format
+#--kernel-format
+#--uptime-format
+#--processes-format
+#--packages-format
+#--shell-format
+#--display-format
+#--brightness-format
+#--de-format
+#--wm-format
+#--wm-theme-format
+#--theme-format
+#--icons-format
+#--font-format
+#--cursor-format
+#--terminal-format
+#--terminal-font-format
+#--cpu-format
+#--cpu-usage-format
+#--gpu-format
+#--memory-format
+#--swap-format
+#--disk-format
+#--battery-format
+#--poweradapter-format
+#--locale-format
+#--localip-format
+#--publicip-format
+#--weather-format
+#--player-format
+#--media-format
+#--datetime-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
+#--localip-error
+#--publicip-error
+#--weather-error
+#--player-error
+#--media-error
+#--datetime-error
+#--vulkan-error
+#--opengl-error
+#--opencl-error
+#--users-error
+#--bluetooth-error
+#--sound-error
+#--gamepad-error
+#--wallpaper-error
+
+# Library options:
+# Sets an user specific path to a library to load.
+# Must be a valid path to a library.
+#--lib-PCI /usr/lib/libpci.so
+#--lib-vulkan /usr/lib/libvulkan.so (libMoltenVK.dylib on macOS)
+#--lib-wayland /usr/lib/libwayland-client.so
+#--lib-xcb-randr /usr/lib/libxcb-randr.so
+#--lib-xcb /usr/lib/libxcb.so
+#--lib-Xrandr /usr/lib/libXrandr.so
+#--lib-X11 /usr/lib/libX11.so
+#--lib-gio /usr/lib/libgio-2.0.so
+#--lib-DConf /usr/lib/libdconf.so
+#--lib-DBus /usr/lib/libdbus-1.so
+#--lib-XFConf /usr/lib/libxfconf-0.so
+#--lib-sqlite3 /usr/lib/libsqlite3.so
+#--lib-rpm /usr/lib/librpm.so
+#--lib-imagemagick /usr/lib/libMagickCore-7.Q16HDRI.so
+#--lib-z /usr/lib/libz.so
+#--lib-chafa /usr/lib/libchafa.so
+#--lib-egl /usr/lib/libEGL.so
+#--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

src/data/help.txt

@@ -1,112 +1,80 @@
 Usage: fastfetch <options>
 
 Informative options:
-    -h,--help:           shows this message and exits
-    -h,--help <command>: shows help for a specific command and exits
-    -v,--version:        prints the version of fastfetch and exits
-    --list-logos:        list available logos and exits
-    --list-modules:      lists available modules and exits
-    --list-presets:      list presets fastfetch knows about and exits. They can be loaded with --load-config. (+)
-    --list-features:     list the supported features fastfetch was compiled with and exits. Mainly for development.
-    --print-logos:       show available logos and exits
-    --print-config:      prints the default config and exits
-    --print-structure:   prints the default stucture and exits
+    -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
 
 General options:
-    -r,--recache <?value>:            generate new cached values
-    --nocache <?value>:               don't use cached values, but also don't overwrite existing ones
-    --load-config <file>:             load a config file or a preset (+)
-    --multithreading <?value>:        use multiple threads to detect values
-    --allow-slow-operations <?value>: allow operations that are usually very slow for more detailed output
+    --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
+    --escape-bedrock <?value>:        On Bedrock Linux, whether to escape the bedrock jail
+    --pipe <?value>:                  Disable logo and all escape sequences
 
 Logo options:
-    -l,--logo <logo>:                set the logo to use. The type is specified by --logo-type. 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, raw, sixel or kitty.
-    --logo-width <width>:            set the width of the logo (in characters), if it is an image
-    --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-print-remaining <?value>: weather to print the remaining logo, if it has more lines than modules to display
-    --sixel <file>:                  short for --logo-type sixel --logo <file>
-    --kitty <file>:                  short for --logo-type kitty --logo <file>
-    --file <file>:                   short for --logo-type file --logo <file>
-    --raw <file>:                    short for --logo-type raw --logo <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-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
+    --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>
+    --data-raw <data>:                     Short for --logo-type data-raw --logo <data>
+    --sixel <file>:                        Short for --logo-type sixel --logo <file>
+    --kitty <file>:                        Short for --logo-type kitty --logo <file>
+    --iterm <file>:                        Short for --logo-type iterm --logo <file>
+    --chafa <file>:                        Short for --logo-type chafa --logo <file>
+    --chafa-fg-only <?value>:              Produce character-cell output using foreground colors only. See chafa document for detail
+    --chafa-symbols <str>:                 Specify character symbols to employ in final output. See chafa document for detail
+    --chafa-canvas-mode <value>:           Determine how colors are used in the output. This value maps the int value of enum ChafaCanvasMode. See chafa document for detail
+    --chafa-color-space <value>:           Set color space used for quantization. 0 for RGB; 1 for DIN99d. See chafa document for detail
+    --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>:  sets the structure of the fetch. Must be a colon separated list of keys. Use "fastfetch --list-modules" to see the ones available.
-    -c,--color <color>:          sets the color of the keys. Must be a linux console color code or the name of a color (+)
-    --separator <str>:           sets the separator between key and value. Default is a colon with a space
-    --set <key=value>:           hard set the value of a key
-    --show-errors <?value>:      print occuring errors
-    --disable-linewrap <?value>: weather to disable linewrap during the run
-    --hide-cursor <?value>:      weather to hide the cursor during the run
+    -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.
+    --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
+    --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.
 
-Format options: Provide the format string for custom output. Use fastfetch --help *-format for specific help.
-    --os-format <format>
-    --host-format <format>
-    --kernel-format <format>
-    --uptime-format <format>
-    --processes-format <format>
-    --packages-format <format>
-    --shell-format <format>
-    --resolution-format <format>
-    --de-format <format>
-    --wm-format <format>
-    --wm-theme-format <format>
-    --theme-format <format>
-    --icons-format <format>
-    --font-format <format>
-    --cursor-format <format>
-    --terminal-format <format>
-    --terminal-font-format <format>
-    --cpu-format <format>
-    --cpu-usage-format <format>
-    --gpu-format <format>
-    --memory-format <format>
-    --disk-format <format>
-    --battery-format <format>
-    --locale-format <format>
-    --local-ip-format <format>
-    --public-ip-format <format>
-    --player-format <format>
-    --song-format <format>
-    --datetime-format <format>
-    --time-format <format>
-    --date-format <format>
+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.
 
-Key options: Provide a custom key for an output
-    --os-key <key>
-    --host-key <key>
-    --kernel-key <key>
-    --uptime-key <key>
-    --processes-key <key>
-    --packages-key <key>
-    --shell-key <key>
-    --resolution-key <key>: takes the resolution index as argument
-    --de-key <key>
-    --wm-key <key>
-    --wm-theme-key <key>
-    --theme-key <key>
-    --icons-key <key>
-    --font-key <key>
-    --cursor-key <key>
-    --terminal-key <key>
-    --terminal-font-key <key>
-    --cpu-key <key>
-    --cpu-usage-key <key>
-    --gpu-key <key>: takes the gpu index as format argument
-    --memory-key <key>
-    --disk-key <key>: takes the mount path as format argument
-    --battery-key <key>: takes the battery index as format argument
-    --locale-key <key>
-    --local-ip-key <key>: takes the name of this network interface as format argument
-    --public-ip-key <key>
-    --player-key <key>
-    --song-key <key>
-    --datetime-key <key>
-    --time-key <key>
-    --date-key <key>
+    --<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.
 
 Library options: Set the path of a library to load
     --lib-PCI <path>
@@ -120,20 +88,59 @@ Library options: Set the path of a library to load
     --lib-DConf <path>
     --lib-DBus <path>
     --lib-XFConf <path>
-    --lib-RPM <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-pulse <path>
+    --lib-freetype <path>
 
 Module specific options:
-    --separator-string <str>:     Set the string printed by the separator module
-    --os-file <path>:             Set the path to the file containing OS informations
-    --disk-folders <folders>:     A colon separated list of folder paths for the disk output. Default is "/:/home"
-    --battery-dir <folder>:       The directory where the battery folders are. Standard: /sys/class/power_supply/
-    --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
-    --public-ip-timeout:          Time in milliseconds to wait for the public ip server to respond. Default is disabled (0)
-    --player-name:                The name of the player to use
+    --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-regular <?value>:            Set if regular volume should be printed. Default is true
+    --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
+    --bluetooth-show-disconnected: <?value>: Set if disconnected bluetooth devices should be printed. 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
+    --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/
+    --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-force-vulkan  <?value>:            Force using vulkan to detect GPUs, which support video memory usage detection with `--allow-slow-operations`. 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-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 IPs with given name prefix only. Default is empty
+    --localip-compact <?value>:              Show all IPs in one line. Default is false
+    --publicip-timeout:                      Time in milliseconds to wait for the public ip server to respond. Default is disabled (0)
+    --publicip-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, 9 for colored number. 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
 
 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.

src/data/help_format.txt

@@ -19,24 +19,18 @@ If a "{?}" is found without an opener, it is printed as is.
 To only print something if a variable is not set, do the same as with if, just replace every '?' with a '!'.
 For example to print a fallback for a second value if it is not set, use "{?2}{2}{?}{/2}Second value fallback{/}"
 
-There is a special variable set if an error occured during detection. You can access it with "{e}", "{error}" o
-You can use ifs and not ifs with it like with an index. For example use "{?e}some text{?}", to print a text if an
-
 To stop formatting at any point in the format string, use "{-}".
-For example to print an error instead of the normal output if it occured, prefix the format string with "{?e}{e}{-
 
 To print something with color, start a placeholder with a '#' and then the linux terminal color encoding.
 "\\033[" at the start, and an 'm' at the end is automatically added, so don't do that.
 A "{#}" is equivalent to a "{#0}" and resets everything to normal.
 For example to print something pink and underline, use "{#4;35}...{#}".
-If not in a format string, fastfetch wraps errors with "{#1;31}error{#}", so you might want to do that to if you
 Information about what the numbers mean can be found here: https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Sele
 Which escape codes are supported and how they look is defined by your terminal.
 
 If a format string evaluates to an empty value, the whole line in the output will be discarded.
 You can therefore use --host-format " " to disable host output.
 Note that --host-format "" would evaluate as not set, and therefore use the built-in host format
-This can be used to print nothing if an error occured: prefix the format string with "{?e}{-}{?}...".
 
 Format string is also the way to go to set a fixed value - just use one without placeholders.
-For example when running in headless mode, you could use "--resolution-format "Preferred".
+For example when running in headless mode, you could use "--display-format Preferred".

src/data/modules.txt

@@ -1,5 +1,9 @@
 Battery
+Bios
+Bluetooth
+Board
 Break
+Chassis
 Colors
 CPU
 CPUUsage
@@ -8,6 +12,7 @@ Date
 Datetime
 DE
 Disk
+Display
 Font
 GPU
 Host
@@ -15,21 +20,26 @@ Icons
 Kernel
 Locale
 LocalIP
+Media
 Memory
+OpenGL
 OS
 Packages
 Player
+PowerAdapter
 Processes
 PublicIP
-Resolution
 Separator
 Shell
-Song
+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:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Disk:Battery:Locale:Break:Colors
+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

src/detection/battery/battery.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_battery_battery
+#define FF_INCLUDED_detection_battery_battery
+
+#include "fastfetch.h"
+
+#define FF_BATTERY_TEMP_UNSET (0/0.0)
+
+typedef struct BatteryResult
+{
+    FFstrbuf manufacturer;
+    FFstrbuf modelName;
+    FFstrbuf technology;
+    double capacity;
+    FFstrbuf status;
+    double temperature;
+} BatteryResult;
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results);
+
+#endif

src/detection/battery/battery_android.c

@@ -0,0 +1,56 @@
+#include "fastfetch.h"
+#include "battery.h"
+
+#include "common/processing.h"
+#include "common/properties.h"
+
+#define FF_TERMUX_API_PATH FASTFETCH_TARGET_DIR_ROOT "/libexec/termux-api"
+#define FF_TERMUX_API_PARAM "BatteryStatus"
+
+const char* ffDetectBatteryImpl(FF_MAYBE_UNUSED FFinstance* instance, FFlist* results)
+{
+    FF_STRBUF_AUTO_DESTROY buffer;
+    ffStrbufInit(&buffer);
+
+    if(ffProcessAppendStdOut(&buffer, (char* const[]){
+        FF_TERMUX_API_PATH,
+        FF_TERMUX_API_PARAM,
+        NULL
+    }))
+        return "Starting `" FF_TERMUX_API_PATH " " FF_TERMUX_API_PARAM "` failed";
+
+    if(buffer.chars[0] != '{')
+        return "`" FF_TERMUX_API_PATH " " FF_TERMUX_API_PARAM "` prints invalid result (not a JSON object)";
+
+    BatteryResult* 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))
+    {
+        battery->capacity = ffStrbufToDouble(&battery->status);
+        ffStrbufClear(&battery->status);
+    }
+
+    if(instance->config.batteryTemp)
+    {
+        if(ffParsePropLines(buffer.chars, "\"temperature\": ", &battery->status))
+        {
+            ffStrbufTrimRight(&battery->status, ',');
+            ffStrbufTrim(&battery->status, '"');
+            battery->temperature = ffStrbufToDouble(&battery->status);
+            ffStrbufClear(&battery->status);
+        }
+    }
+
+    if(ffParsePropLines(buffer.chars, "\"status\": ", &battery->status))
+    {
+        ffStrbufTrimRight(&battery->status, ',');
+        ffStrbufTrim(&battery->status, '"');
+    }
+
+    return NULL;
+}

src/detection/battery/battery_apple.c

@@ -0,0 +1,108 @@
+#include "fastfetch.h"
+#include "battery.h"
+#include "util/apple/cf_helpers.h"
+#include "detection/temps/temps_apple.h"
+
+#include <IOKit/IOKitLib.h>
+
+static double detectBatteryTemp()
+{
+    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)
+        return "IOServiceGetMatchingServices() failed";
+
+    io_registry_entry_t registryEntry;
+    while((registryEntry = IOIteratorNext(iterator)) != 0)
+    {
+        CFMutableDictionaryRef properties;
+        if(IORegistryEntryCreateCFProperties(registryEntry, &properties, kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
+        {
+            IOObjectRelease(registryEntry);
+            continue;
+        }
+
+        bool boolValue;
+        const char* error;
+
+        BatteryResult* battery = ffListAdd(results);
+        battery->capacity = 0.0/0.0;
+        int currentCapacity, maxCapacity;
+
+        if ((error = ffCfDictGetInt(properties, CFSTR("MaxCapacity"), &maxCapacity)))
+            return error;
+        if (maxCapacity <= 0)
+            return "Querying MaxCapacity failed";
+
+        if ((error = ffCfDictGetInt(properties, CFSTR("CurrentCapacity"), &currentCapacity)))
+            return error;
+        if(currentCapacity <= 0)
+            return "Querying CurrentCapacity failed";
+
+        battery->capacity = currentCapacity * 100.0 / maxCapacity;
+
+        ffStrbufInit(&battery->manufacturer);
+        ffStrbufInit(&battery->modelName);
+        ffStrbufInit(&battery->technology);
+        if (!ffCfDictGetBool(properties, CFSTR("built-in"), &boolValue) && boolValue)
+        {
+            ffStrbufAppendS(&battery->manufacturer, "Apple Inc.");
+            ffStrbufAppendS(&battery->modelName, "Builtin");
+            ffStrbufAppendS(&battery->technology, "Lithium");
+        }
+        else
+        {
+            ffStrbufAppendS(&battery->manufacturer, "Unknown");
+            ffStrbufAppendS(&battery->modelName, "Unknown");
+            ffStrbufAppendS(&battery->technology, "Unknown");
+        }
+
+        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);
+    }
+
+    IOObjectRelease(iterator);
+
+    return NULL;
+}

src/detection/battery/battery_bsd.c

@@ -0,0 +1,59 @@
+#include "fastfetch.h"
+#include "battery.h"
+
+#include <dev/acpica/acpiio.h>
+#include <sys/ioctl.h>
+#include <sys/fcntl.h>
+#include <unistd.h>
+
+const char* ffDetectBatteryImpl(FF_MAYBE_UNUSED FFinstance* instance, 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);
+    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))
+            continue;
+
+        BatteryResult* battery = ffListAdd(results);
+        battery->temperature = FF_BATTERY_TEMP_UNSET;
+        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)
+        {
+            ffStrbufAppendS(&battery->status, "Invalid");
+        }
+        else
+        {
+            if(battio.battinfo.state & ACPI_BATT_STAT_DISCHARG)
+                ffStrbufAppendS(&battery->status, "Discharging, ");
+            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");
+            ffStrbufTrimRight(&battery->status, ' ');
+            ffStrbufTrimRight(&battery->status, ',');
+        }
+    }
+    close(acpifd);
+    return NULL;
+}

src/detection/battery/battery_linux.c

@@ -0,0 +1,119 @@
+#include "fastfetch.h"
+#include "common/io/io.h"
+#include "battery.h"
+
+#include <dirent.h>
+
+static void parseBattery(FFstrbuf* dir, FFlist* results)
+{
+    uint32_t dirLength = dir->length;
+
+    FFstrbuf testBatteryBuffer;
+    ffStrbufInit(&testBatteryBuffer);
+
+    //type must exist and be "Battery"
+    ffStrbufAppendS(dir, "/type");
+    ffReadFileBuffer(dir->chars, &testBatteryBuffer);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Battery") != 0)
+    {
+        ffStrbufDestroy(&testBatteryBuffer);
+        return;
+    }
+
+    //scope may not exist or must not be "Device"
+    ffStrbufAppendS(dir, "/scope");
+    ffReadFileBuffer(dir->chars, &testBatteryBuffer);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Device") == 0)
+    {
+        ffStrbufDestroy(&testBatteryBuffer);
+        return;
+    }
+
+    BatteryResult* result = ffListAdd(results);
+
+    //capacity must exist and be not empty
+    ffStrbufAppendS(dir, "/capacity");
+    bool available = ffReadFileBuffer(dir->chars, &testBatteryBuffer);
+    ffStrbufSubstrBefore(dir, dirLength);
+    if(available)
+        result->capacity = ffStrbufToDouble(&testBatteryBuffer);
+    ffStrbufDestroy(&testBatteryBuffer);
+    if(!available)
+    {
+        result->capacity = 0.0/0.0;
+        --results->length;
+        return;
+    }
+
+    //At this point, we have a battery. Try to get as much values as possible.
+
+    ffStrbufInit(&result->manufacturer);
+    ffStrbufAppendS(dir, "/manufacturer");
+    ffReadFileBuffer(dir->chars, &result->manufacturer);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    ffStrbufInit(&result->modelName);
+    ffStrbufAppendS(dir, "/model_name");
+    ffReadFileBuffer(dir->chars, &result->modelName);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    ffStrbufInit(&result->technology);
+    ffStrbufAppendS(dir, "/technology");
+    ffReadFileBuffer(dir->chars, &result->technology);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    ffStrbufInit(&result->status);
+    ffStrbufAppendS(dir, "/status");
+    ffReadFileBuffer(dir->chars, &result->status);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    result->temperature = FF_BATTERY_TEMP_UNSET;
+}
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
+    if(instance->config.batteryDir.length > 0)
+    {
+        ffStrbufAppend(&baseDir, &instance->config.batteryDir);
+        ffStrbufEnsureEndsWithC(&baseDir, '/');
+    }
+    else
+    {
+        ffStrbufAppendS(&baseDir, "/sys/class/power_supply/");
+    }
+
+    uint32_t baseDirLength = baseDir.length;
+
+    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)
+            continue;
+
+        ffStrbufAppendS(&baseDir, entry->d_name);
+        parseBattery(&baseDir, results);
+        ffStrbufSubstrBefore(&baseDir, baseDirLength);
+    }
+
+    closedir(dirp);
+
+    if(results->length == 0) {
+        ffStrbufDestroy(&baseDir);
+        return "batteryDir doesn't contain any battery folder";
+    }
+
+    ffStrbufDestroy(&baseDir);
+    return NULL;
+}

src/detection/battery/battery_nosupport.c

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

src/detection/battery/battery_windows.c

@@ -0,0 +1,169 @@
+#include "battery.h"
+#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>
+
+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)
+{
+    if(*handle)
+        CloseHandle(*handle);
+}
+static inline void wrapSetupDiDestroyDeviceInfoList(HDEVINFO* hdev)
+{
+    if(*hdev)
+        SetupDiDestroyDeviceInfoList(*hdev);
+}
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
+{
+    if(instance->config.allowSlowOperations)
+    {
+        //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";
+
+        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(NtPowerInformation(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;
+
+            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;
+}

src/detection/bios/bios.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_bios_bios
+#define FF_INCLUDED_detection_bios_bios
+
+#include "fastfetch.h"
+
+typedef struct FFBiosResult
+{
+    FFstrbuf biosDate;
+    FFstrbuf biosRelease;
+    FFstrbuf biosVendor;
+    FFstrbuf biosVersion;
+    FFstrbuf error;
+} FFBiosResult;
+
+void ffDetectBios(FFBiosResult* bios);
+
+#endif

src/detection/bios/bios_apple.c

@@ -0,0 +1,70 @@
+#include "bios.h"
+#include "util/apple/cf_helpers.h"
+
+#include <IOKit/IOKitLib.h>
+
+void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInit(&bios->error);
+    ffStrbufInit(&bios->biosDate);
+    ffStrbufInit(&bios->biosRelease);
+    ffStrbufInit(&bios->biosVendor);
+    ffStrbufInit(&bios->biosVersion);
+
+    io_registry_entry_t registryEntry;
+
+    #ifndef __aarch64__
+
+    //https://github.com/osquery/osquery/blob/master/osquery/tables/system/darwin/smbios_tables.cpp
+    //For Intel
+    if((registryEntry = IORegistryEntryFromPath(MACH_PORT_NULL, "IODeviceTree:/rom")))
+    {
+        CFMutableDictionaryRef properties;
+        if(IORegistryEntryCreateCFProperties(registryEntry, &properties, kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
+        {
+            IOObjectRelease(registryEntry);
+            ffStrbufAppendS(&bios->error, "IORegistryEntryCreateCFProperties(registryEntry) failed");
+            return;
+        }
+
+        ffCfDictGetString(properties, CFSTR("vendor"), &bios->biosVendor);
+        ffCfDictGetString(properties, CFSTR("version"), &bios->biosVersion);
+        ffCfDictGetString(properties, CFSTR("release-date"), &bios->biosDate);
+        if(!ffStrbufContainC(&bios->biosDate, '-'))
+            ffStrbufAppendS(&bios->biosRelease, "Efi-");
+        ffStrbufAppend(&bios->biosRelease, &bios->biosVersion);
+
+        CFRelease(properties);
+        IOObjectRelease(registryEntry);
+        return;
+    }
+
+    #else
+
+    //For arm64
+    if((registryEntry = IORegistryEntryFromPath(MACH_PORT_NULL, "IODeviceTree:/")))
+    {
+        CFMutableDictionaryRef properties;
+        if(IORegistryEntryCreateCFProperties(registryEntry, &properties, kCFAllocatorDefault, kNilOptions) == kIOReturnSuccess)
+        {
+            ffCfDictGetString(properties, CFSTR("manufacturer"), &bios->biosVendor);
+            CFRelease(properties);
+        }
+        IOObjectRelease(registryEntry);
+    }
+
+    if((registryEntry = IORegistryEntryFromPath(MACH_PORT_NULL, "IODeviceTree:/chosen")))
+    {
+        CFMutableDictionaryRef properties;
+        if(IORegistryEntryCreateCFProperties(registryEntry, &properties, kCFAllocatorDefault, kNilOptions) == kIOReturnSuccess)
+        {
+            ffCfDictGetString(properties, CFSTR("system-firmware-version"), &bios->biosRelease);
+            ffStrbufAppend(&bios->biosVersion, &bios->biosRelease);
+            ffStrbufSubstrAfterFirstC(&bios->biosVersion, '-');
+            CFRelease(properties);
+        }
+        IOObjectRelease(registryEntry);
+    }
+
+    #endif
+}

src/detection/bios/bios_bsd.c

@@ -0,0 +1,26 @@
+#include "bios.h"
+
+#include <kenv.h>
+
+static void kenvLookup(const char* name, FFstrbuf* result)
+{
+    ffStrbufEnsureFree(result, 255);
+    int len = kenv(KENV_GET, name, result->chars, 256);
+    if(len > 0)
+        result->length = (uint32_t) len;
+}
+
+void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInit(&bios->error);
+    ffStrbufInit(&bios->biosDate);
+    ffStrbufInit(&bios->biosRelease);
+    ffStrbufInit(&bios->biosVendor);
+    ffStrbufInit(&bios->biosVersion);
+
+    //https://wiki.ghostbsd.org/index.php/Kenv
+    kenvLookup("smbios.bios.reldate", &bios->biosDate);
+    kenvLookup("smbios.system.product", &bios->biosRelease);
+    kenvLookup("smbios.bios.vendor", &bios->biosVendor);
+    kenvLookup("smbios.bios.version", &bios->biosVersion);
+}

src/detection/bios/bios_linux.c

@@ -0,0 +1,58 @@
+#include "bios.h"
+#include "common/io/io.h"
+
+#include <stdlib.h>
+
+static bool hostValueSet(FFstrbuf* value)
+{
+    return
+        value->length > 0 &&
+        ffStrbufStartsWithIgnCaseS(value, "To be filled") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "To be set") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "OEM") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "O.E.M.") != true &&
+        ffStrbufIgnCaseCompS(value, "None") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Default string") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Undefined") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Specified") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Applicable") != 0 &&
+        ffStrbufIgnCaseCompS(value, "INVALID") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Type1ProductConfigId") != 0 &&
+        ffStrbufIgnCaseCompS(value, "All Series") != 0
+    ;
+}
+
+static void getHostValue(const char* devicesPath, const char* classPath, FFstrbuf* buffer)
+{
+    ffReadFileBuffer(devicesPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffReadFileBuffer(classPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffStrbufClear(buffer);
+}
+
+void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInit(&bios->error);
+
+    ffStrbufInit(&bios->biosDate);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_date", "/sys/class/dmi/id/bios_date", &bios->biosDate);
+
+    ffStrbufInit(&bios->biosRelease);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_release", "/sys/class/dmi/id/bios_release", &bios->biosRelease);
+
+    ffStrbufInit(&bios->biosVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_vendor", "/sys/class/dmi/id/bios_vendor", &bios->biosVendor);
+
+    ffStrbufInit(&bios->biosVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_version", "/sys/class/dmi/id/bios_version", &bios->biosVersion);
+}

src/detection/bios/bios_nosupport.c

@@ -0,0 +1,11 @@
+#include "bios.h"
+
+void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInitS(&bios->error, "Not supported on this platform");
+
+    ffStrbufInit(&bios->biosDate);
+    ffStrbufInit(&bios->biosRelease);
+    ffStrbufInit(&bios->biosVendor);
+    ffStrbufInit(&bios->biosVersion);
+}

src/detection/bios/bios_windows.c

@@ -0,0 +1,28 @@
+#include "bios.h"
+#include "util/windows/registry.h"
+
+void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInit(&bios->error);
+
+    ffStrbufInit(&bios->biosDate);
+    ffStrbufInit(&bios->biosRelease);
+    ffStrbufInit(&bios->biosVendor);
+    ffStrbufInit(&bios->biosVersion);
+
+    FF_HKEY_AUTO_DESTROY hKey = NULL;
+    if(!ffRegOpenKeyForRead(HKEY_LOCAL_MACHINE, L"HARDWARE\\DESCRIPTION\\System\\BIOS", &hKey, &bios->error))
+        return;
+
+    if(!ffRegReadStrbuf(hKey, L"BIOSVersion", &bios->biosRelease, &bios->error))
+        return;
+    ffRegReadStrbuf(hKey, L"BIOSVendor", &bios->biosVendor, NULL);
+    ffRegReadStrbuf(hKey, L"BIOSReleaseDate", &bios->biosDate, NULL);
+
+    uint32_t major, minor;
+    if(
+        ffRegReadUint(hKey, L"BiosMajorRelease", &major, NULL) &&
+        ffRegReadUint(hKey, L"BiosMinorRelease", &minor, NULL)
+    )
+        ffStrbufAppendF(&bios->biosVersion, "%u.%u", (unsigned)major, (unsigned)minor);
+}

src/detection/bluetooth/bluetooth.c

@@ -0,0 +1,15 @@
+#include "bluetooth.h"
+
+#include "../internal.h"
+
+void ffDetectBluetoothImpl(const FFinstance* instance, FFBluetoothResult* bluetooth);
+
+const FFBluetoothResult* ffDetectBluetooth(const FFinstance* instance)
+{
+    FF_DETECTION_INTERNAL_GUARD(FFBluetoothResult,
+        ffStrbufInit(&result.error);
+        ffListInit(&result.devices, sizeof(FFBluetoothDevice));
+
+        ffDetectBluetoothImpl(instance, &result);
+    )
+}

src/detection/bluetooth/bluetooth.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_bluetooth_bluetooth
+#define FF_INCLUDED_detection_bluetooth_bluetooth
+
+#include "fastfetch.h"
+
+typedef struct FFBluetoothDevice
+{
+    FFstrbuf name;
+    FFstrbuf address;
+    FFstrbuf type;
+    uint8_t battery; // 0-100%
+    bool connected;
+} FFBluetoothDevice;
+
+typedef struct FFBluetoothResult
+{
+    FFstrbuf error;
+    FFlist devices; // List of FFBluetoothDevice
+} FFBluetoothResult;
+
+const FFBluetoothResult* ffDetectBluetooth(const FFinstance* instance);
+
+#endif

src/detection/bluetooth/bluetooth_apple.m

@@ -0,0 +1,93 @@
+#include "bluetooth.h"
+
+#import <IOBluetooth/IOBluetooth.h>
+
+void ffDetectBluetoothImpl(FF_MAYBE_UNUSED const FFinstance* instance, FFBluetoothResult* bluetooth)
+{
+    NSArray<IOBluetoothDevice*>* ioDevices = IOBluetoothDevice.pairedDevices;
+    if(!ioDevices)
+    {
+        ffStrbufAppendS(&bluetooth->error, "IOBluetoothDevice.pairedDevices failed");
+        return;
+    }
+
+    for(IOBluetoothDevice* ioDevice in ioDevices)
+    {
+        FFBluetoothDevice* device = ffListAdd(&bluetooth->devices);
+        ffStrbufInitS(&device->name, ioDevice.name.UTF8String);
+        ffStrbufInitS(&device->address, ioDevice.addressString.UTF8String);
+        ffStrbufInit(&device->type);
+        device->battery = 0;
+        device->connected = !!ioDevice.isConnected;
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorLimitedDiscoverableMode)
+            ffStrbufAppendS(&device->type, "Limited Discoverable Mode, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorReserved1)
+            ffStrbufAppendS(&device->type, "LE audio, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorReserved2)
+            ffStrbufAppendS(&device->type, "Reserved for future use, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorPositioning)
+            ffStrbufAppendS(&device->type, "Positioning, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorNetworking)
+            ffStrbufAppendS(&device->type, "Networking, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorRendering)
+            ffStrbufAppendS(&device->type, "Rendering, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorCapturing)
+            ffStrbufAppendS(&device->type, "Capturing, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorObjectTransfer)
+            ffStrbufAppendS(&device->type, "Object Transfer, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorAudio)
+            ffStrbufAppendS(&device->type, "Audio, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorTelephony)
+            ffStrbufAppendS(&device->type, "Telephony, ");
+        if(ioDevice.serviceClassMajor & kBluetoothServiceClassMajorInformation)
+            ffStrbufAppendS(&device->type, "Information, ");
+
+        if(device->type.length == 0)
+        {
+            switch(ioDevice.deviceClassMajor)
+            {
+                case kBluetoothDeviceClassMajorMiscellaneous:
+                    ffStrbufAppendS(&device->type, "Miscellaneous");
+                    break;
+                case kBluetoothDeviceClassMajorComputer:
+                    ffStrbufAppendS(&device->type, "Computer");
+                    break;
+                case kBluetoothDeviceClassMajorPhone:
+                    ffStrbufAppendS(&device->type, "Phone");
+                    break;
+                case kBluetoothDeviceClassMajorLANAccessPoint:
+                    ffStrbufAppendS(&device->type, "LAN/Network Access point");
+                    break;
+                case kBluetoothDeviceClassMajorAudio:
+                    ffStrbufAppendS(&device->type, "Audio/Video");
+                    break;
+                case kBluetoothDeviceClassMajorPeripheral:
+                    ffStrbufAppendS(&device->type, "Peripheral");
+                    break;
+                case kBluetoothDeviceClassMajorImaging:
+                    ffStrbufAppendS(&device->type, "Imaging");
+                    break;
+                case kBluetoothDeviceClassMajorWearable:
+                    ffStrbufAppendS(&device->type, "Wearable");
+                    break;
+                case kBluetoothDeviceClassMajorToy:
+                    ffStrbufAppendS(&device->type, "Toy");
+                    break;
+                case kBluetoothDeviceClassMajorHealth:
+                    ffStrbufAppendS(&device->type, "Health");
+                    break;
+                case kBluetoothDeviceClassMajorUnclassified:
+                    ffStrbufAppendS(&device->type, "Uncategorized");
+                    break;
+                default:
+                    ffStrbufAppendS(&device->type, "Unknown");
+                    break;
+            }
+        }
+        else
+        {
+            ffStrbufTrimRight(&device->type, ' ');
+            ffStrbufTrimRight(&device->type, ',');
+        }
+    }
+}

src/detection/bluetooth/bluetooth_linux.c

@@ -0,0 +1,203 @@
+#include "bluetooth.h"
+
+#ifdef FF_HAVE_DBUS
+#include "common/dbus.h"
+
+/* Example dbus reply, striped to only the relevant parts:
+array [                                                     //root
+    dict entry(                                             //object
+        object path "/org/bluez/hci0/dev_03_21_8B_91_16_4D"
+        array [
+           dict entry(                                      //property
+              string "org.bluez.Device1"
+              array [
+                 dict entry(                                //value
+                    string "Address"
+                    variant string "03:21:8B:91:16:4D"
+                 )
+                 dict entry(                                //value
+                    string "Name"
+                    variant string "JBL TUNE160BT"
+                 )
+                 dict entry(                                //value
+                    string "Icon"
+                    variant string "audio-headset"
+                 )
+                 dict entry(                                //value
+                    string "Connected"
+                    variant boolean true
+                 )
+              ]
+           )
+           dict entry(                                      //property
+              string "org.bluez.Battery1"
+              array [
+                 dict entry(                                //value
+                    string "Percentage"
+                    variant byte 100
+                 )
+              ]
+           )
+        ]
+    )
+]
+*/
+
+static void detectBluetoothValue(FFDBusData* dbus, DBusMessageIter* iter, FFBluetoothDevice* device)
+{
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(iter) != DBUS_TYPE_DICT_ENTRY)
+        return;
+
+    DBusMessageIter dictIter;
+    dbus->lib->ffdbus_message_iter_recurse(iter, &dictIter);
+
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(&dictIter) != DBUS_TYPE_STRING)
+        return;
+
+    const char* deviceProperty;
+    dbus->lib->ffdbus_message_iter_get_basic(&dictIter, &deviceProperty);
+
+    dbus->lib->ffdbus_message_iter_next(&dictIter);
+
+    if(strcmp(deviceProperty, "Address") == 0)
+        ffDBusGetValue(dbus, &dictIter, &device->address);
+    else if(strcmp(deviceProperty, "Name") == 0)
+        ffDBusGetValue(dbus, &dictIter, &device->name);
+    else if(strcmp(deviceProperty, "Icon") == 0)
+        ffDBusGetValue(dbus, &dictIter, &device->type);
+    else if(strcmp(deviceProperty, "Percentage") == 0)
+        ffDBusGetByte(dbus, &dictIter, &device->battery);
+    else if(strcmp(deviceProperty, "Connected") == 0)
+        ffDBusGetBool(dbus, &dictIter, &device->connected);
+}
+
+static void detectBluetoothProperty(FFDBusData* dbus, DBusMessageIter* iter, FFBluetoothDevice* device)
+{
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(iter) != DBUS_TYPE_DICT_ENTRY)
+        return;
+
+    DBusMessageIter dictIter;
+    dbus->lib->ffdbus_message_iter_recurse(iter, &dictIter);
+
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(&dictIter) != DBUS_TYPE_STRING)
+        return;
+
+    const char* propertyType;
+    dbus->lib->ffdbus_message_iter_get_basic(&dictIter, &propertyType);
+
+    if(strstr(propertyType, "Device") == NULL && strstr(propertyType, "Battery") == NULL)
+        return; //We don't care about other properties
+
+    dbus->lib->ffdbus_message_iter_next(&dictIter);
+
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(&dictIter) != DBUS_TYPE_ARRAY)
+        return;
+
+    DBusMessageIter arrayIter;
+    dbus->lib->ffdbus_message_iter_recurse(&dictIter, &arrayIter);
+
+    while(true)
+    {
+        detectBluetoothValue(dbus, &arrayIter, device);
+        FF_DBUS_ITER_CONTINUE(dbus, &arrayIter);
+    }
+}
+
+static void detectBluetoothObject(FFBluetoothResult* bluetooth, FFDBusData* dbus, DBusMessageIter* iter)
+{
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(iter) != DBUS_TYPE_DICT_ENTRY)
+        return;
+
+    DBusMessageIter dictIter;
+    dbus->lib->ffdbus_message_iter_recurse(iter, &dictIter);
+
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(&dictIter) != DBUS_TYPE_OBJECT_PATH)
+        return;
+
+    const char* objectPath;
+    dbus->lib->ffdbus_message_iter_get_basic(&dictIter, &objectPath);
+
+    //We don't want adapter objects
+    if(strstr(objectPath, "dev_") == NULL)
+        return;
+
+    dbus->lib->ffdbus_message_iter_next(&dictIter);
+
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(&dictIter) != DBUS_TYPE_ARRAY)
+        return;
+
+    DBusMessageIter arrayIter;
+    dbus->lib->ffdbus_message_iter_recurse(&dictIter, &arrayIter);
+
+    FFBluetoothDevice* device = ffListAdd(&bluetooth->devices);
+    ffStrbufInit(&device->name);
+    ffStrbufInit(&device->address);
+    ffStrbufInit(&device->type);
+    device->battery = 0;
+    device->connected = false;
+
+    while(true)
+    {
+        detectBluetoothProperty(dbus, &arrayIter, device);
+        FF_DBUS_ITER_CONTINUE(dbus, &arrayIter);
+    }
+
+    if(device->name.length == 0)
+    {
+        ffStrbufDestroy(&device->name);
+        ffStrbufDestroy(&device->address);
+        ffStrbufDestroy(&device->type);
+        --bluetooth->devices.length;
+    }
+}
+
+static void detectBluetoothRoot(FFBluetoothResult* bluetooth, FFDBusData* dbus, DBusMessageIter* iter)
+{
+    if(dbus->lib->ffdbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+        return;
+
+    DBusMessageIter arrayIter;
+    dbus->lib->ffdbus_message_iter_recurse(iter, &arrayIter);
+
+    while(true)
+    {
+        detectBluetoothObject(bluetooth, dbus, &arrayIter);
+        FF_DBUS_ITER_CONTINUE(dbus, &arrayIter);
+    }
+}
+
+static const char* detectBluetooth(const FFinstance* instance, FFBluetoothResult* bluetooth)
+{
+    FFDBusData dbus;
+    const char* error = ffDBusLoadData(instance, DBUS_BUS_SYSTEM, &dbus);
+    if(error)
+        return error;
+
+    DBusMessage* managedObjects = ffDBusGetMethodReply(&dbus, "org.bluez", "/", "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
+    if(!managedObjects)
+        return "Failed to call GetManagedObjects";
+
+    DBusMessageIter rootIter;
+    if(!dbus.lib->ffdbus_message_iter_init(managedObjects, &rootIter))
+    {
+        dbus.lib->ffdbus_message_unref(managedObjects);
+        return "Failed to get root iterator of GetManagedObjects";
+    }
+
+    detectBluetoothRoot(bluetooth, &dbus, &rootIter);
+
+    dbus.lib->ffdbus_message_unref(managedObjects);
+    return NULL;
+}
+
+#endif
+
+void ffDetectBluetoothImpl(const FFinstance* instance, FFBluetoothResult* bluetooth)
+{
+    #ifdef FF_HAVE_DBUS
+        ffStrbufAppendS(&bluetooth->error, detectBluetooth(instance, bluetooth));
+    #else
+        FF_UNUSED(instance);
+        ffStrbufAppendS(&bluetooth->error, "Fastfetch was compiled without DBus support");
+    #endif
+}

src/detection/bluetooth/bluetooth_nosupport.c

@@ -0,0 +1,6 @@
+#include "bluetooth.h"
+
+void ffDetectBluetoothImpl(FF_MAYBE_UNUSED const FFinstance* instance, FFBluetoothResult* bluetooth)
+{
+    ffStrbufAppendS(&bluetooth->error, "Bluetooth not supported on this platform");
+}

src/detection/bluetooth/bluetooth_windows.c

@@ -0,0 +1,115 @@
+#include "bluetooth.h"
+#include "util/windows/unicode.h"
+
+#include <windows.h>
+#include <bluetoothapis.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpointer-sign"
+
+void ffDetectBluetoothImpl(FF_MAYBE_UNUSED const FFinstance* instance, FFBluetoothResult* bluetooth)
+{
+    BLUETOOTH_DEVICE_SEARCH_PARAMS btsp = {
+        .fReturnConnected = TRUE,
+        .fReturnRemembered = TRUE,
+        .fReturnAuthenticated = TRUE,
+        .fReturnUnknown = TRUE,
+        .dwSize = sizeof(btsp)
+    };
+
+    BLUETOOTH_DEVICE_INFO btdi = {
+        .dwSize = sizeof(btdi)
+    };
+    HBLUETOOTH_DEVICE_FIND hFind = BluetoothFindFirstDevice(&btsp, &btdi);
+    if(!hFind)
+        ffStrbufAppendS(&bluetooth->error, "BluetoothFindFirstDevice() failed or no devices found");
+
+    do {
+        FFBluetoothDevice* device = ffListAdd(&bluetooth->devices);
+        ffStrbufInit(&device->name);
+        ffStrbufInit(&device->address);
+        ffStrbufInit(&device->type);
+        device->battery = 0;
+        device->connected = !!btdi.fConnected;
+
+        ffStrbufSetWS(&device->name, btdi.szName);
+        for (uint32_t i = 0; i < sizeof(btdi.Address.rgBytes) / sizeof(btdi.Address.rgBytes); ++i)
+            ffStrbufAppendF(&device->address, "%X:", btdi.Address.rgBytes[i]);
+        ffStrbufTrimRight(&device->name, ':');
+        //https://btprodspecificationrefs.blob.core.windows.net/assigned-numbers/Assigned%20Number%20Types/Assigned%20Numbers.pdf
+
+        if(BitTest(&btdi.ulClassofDevice, 13))
+            ffStrbufAppendS(&device->type, "Limited Discoverable Mode, ");
+        if(BitTest(&btdi.ulClassofDevice, 14))
+            ffStrbufAppendS(&device->type, "LE audio, ");
+        if(BitTest(&btdi.ulClassofDevice, 15))
+            ffStrbufAppendS(&device->type, "Reserved for future use, ");
+        if(BitTest(&btdi.ulClassofDevice, 16))
+            ffStrbufAppendS(&device->type, "Positioning, ");
+        if(BitTest(&btdi.ulClassofDevice, 17))
+            ffStrbufAppendS(&device->type, "Networking, ");
+        if(BitTest(&btdi.ulClassofDevice, 18))
+            ffStrbufAppendS(&device->type, "Rendering, ");
+        if(BitTest(&btdi.ulClassofDevice, 19))
+            ffStrbufAppendS(&device->type, "Capturing, ");
+        if(BitTest(&btdi.ulClassofDevice, 20))
+            ffStrbufAppendS(&device->type, "Object Transfer, ");
+        if(BitTest(&btdi.ulClassofDevice, 21))
+            ffStrbufAppendS(&device->type, "Audio, ");
+        if(BitTest(&btdi.ulClassofDevice, 22))
+            ffStrbufAppendS(&device->type, "Telephony, ");
+        if(BitTest(&btdi.ulClassofDevice, 23))
+            ffStrbufAppendS(&device->type, "Information, ");
+
+        if(device->type.length == 0)
+        {
+            uint32_t majorDeviceClasses = (btdi.ulClassofDevice >> 8) & ~(UINT32_MAX << 5);
+            switch(majorDeviceClasses)
+            {
+                case 0b00000:
+                    ffStrbufAppendS(&device->type, "Miscellaneous");
+                    break;
+                case 0b00001:
+                    ffStrbufAppendS(&device->type, "Computer");
+                    break;
+                case 0b00010:
+                    ffStrbufAppendS(&device->type, "Phone");
+                    break;
+                case 0b00011:
+                    ffStrbufAppendS(&device->type, "LAN/Network Access point");
+                    break;
+                case 0b00100:
+                    ffStrbufAppendS(&device->type, "Audio/Video");
+                    break;
+                case 0b00101:
+                    ffStrbufAppendS(&device->type, "Peripheral");
+                    break;
+                case 0b00110:
+                    ffStrbufAppendS(&device->type, "Imaging");
+                    break;
+                case 0b00111:
+                    ffStrbufAppendS(&device->type, "Wearable");
+                    break;
+                case 0b01000:
+                    ffStrbufAppendS(&device->type, "Toy");
+                    break;
+                case 0b01001:
+                    ffStrbufAppendS(&device->type, "Health");
+                    break;
+                case 0b11111:
+                    ffStrbufAppendS(&device->type, "Uncategorized");
+                    break;
+                default:
+                    ffStrbufAppendS(&device->type, "Unknown");
+                    break;
+            }
+        }
+        else
+        {
+            ffStrbufTrimRight(&device->type, ' ');
+            ffStrbufTrimRight(&device->type, ',');
+        }
+    } while (BluetoothFindNextDevice(hFind, &btdi));
+}
+
+#pragma GCC diagnostic pop

src/detection/board/board.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_board_board
+#define FF_INCLUDED_detection_board_board
+
+#include "fastfetch.h"
+
+typedef struct FFBoardResult
+{
+    FFstrbuf boardName;
+    FFstrbuf boardVendor;
+    FFstrbuf boardVersion;
+    FFstrbuf error;
+} FFBoardResult;
+
+void ffDetectBoard(FFBoardResult* result);
+
+#endif

src/detection/board/board_linux.c

@@ -0,0 +1,55 @@
+#include "board.h"
+#include "common/io/io.h"
+
+#include <stdlib.h>
+
+static bool hostValueSet(FFstrbuf* value)
+{
+    return
+        value->length > 0 &&
+        ffStrbufStartsWithIgnCaseS(value, "To be filled") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "To be set") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "OEM") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "O.E.M.") != true &&
+        ffStrbufIgnCaseCompS(value, "None") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Default string") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Undefined") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Specified") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Applicable") != 0 &&
+        ffStrbufIgnCaseCompS(value, "INVALID") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Type1ProductConfigId") != 0 &&
+        ffStrbufIgnCaseCompS(value, "All Series") != 0
+    ;
+}
+
+static void getHostValue(const char* devicesPath, const char* classPath, FFstrbuf* buffer)
+{
+    ffReadFileBuffer(devicesPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffReadFileBuffer(classPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffStrbufClear(buffer);
+}
+
+void ffDetectBoard(FFBoardResult* board)
+{
+    ffStrbufInit(&board->error);
+
+    ffStrbufInit(&board->boardName);
+    getHostValue("/sys/devices/virtual/dmi/id/board_name", "/sys/class/dmi/id/board_name", &board->boardName);
+
+    ffStrbufInit(&board->boardVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/board_vendor", "/sys/class/dmi/id/board_vendor", &board->boardVendor);
+
+    ffStrbufInit(&board->boardVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/board_version", "/sys/class/dmi/id/board_version", &board->boardVersion);
+}

src/detection/board/board_nosupport.c

@@ -0,0 +1,10 @@
+#include "board.h"
+
+void ffDetectBoard(FFBoardResult* board)
+{
+    ffStrbufInitS(&board->error, "Not supported on this platform");
+
+    ffStrbufInit(&board->boardName);
+    ffStrbufInit(&board->boardVendor);
+    ffStrbufInit(&board->boardVersion);
+}