Merge pull request #1271 from fastfetch-cli/dev

Release: v2.25.0

.github/workflows/ci.yml

@@ -456,7 +456,7 @@ jobs:
         with:
           msystem: CLANG64
           update: true
-          install: git mingw-w64-clang-x86_64-7zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-vulkan-headers mingw-w64-clang-x86_64-opencl-icd mingw-w64-clang-x86_64-opencl-headers mingw-w64-clang-x86_64-cppwinrt
+          install: git mingw-w64-clang-x86_64-7zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-vulkan-headers mingw-w64-clang-x86_64-opencl-icd mingw-w64-clang-x86_64-opencl-headers mingw-w64-clang-x86_64-cppwinrt mingw-w64-clang-x86_64-imagemagick
 
       - name: print msys version
         run: uname -a

CHANGELOG.md

@@ -1,3 +1,58 @@
+# 2.25.0
+
+Features:
+* Moore Threads GPU add support to query number of cores (#1259, GPU)
+* Cache detection result based on last modification time (Packages)
+* Add cmake options to disable certain package managers at compile time
+    * Package managers are encouraged to disable some package managers by passing `-DPACKAGES_DISABLE_` when running `cmake`. For example, when building for Arch Linux, `-DPACKAGES_DISABLE_APK=ON -DPACKAGES_DISABLE_DPKG=ON -DPACKAGES_DISABLE_RPM=ON ...` should be specified.
+    * See all available options by [running `cmake -L | grep PACKAGES_DISABLE_`](https://github.com/fastfetch-cli/fastfetch/blob/dev/CMakeLists.txt#L91)
+    * This option does NOT remove the detection code. It just disables the detection at runtime. One can still use `--packages-disabled ""` to enable all package managers.
+* Add new option `--show-localip-{speed,mtu}` (LocalIP)
+* Add new module `Btrfs`, which prints all mounted Btrfs volumes, like `Zpool` module (#1262, Linux)
+* Improve Wifi module support for macOS Sequoia (Wifi, macOS)
+    * Currently it uses `system_profiler` which costs about 2 seconds on my MBP. I suggest disabling it for now until a better solution is found.
+
+Bugfixes:
+* Fix invalid CPU temperature detection on FreeBSD (#1260, CPU, FreeBSD)
+* Remove `showPeCoreCount` support on FreeBSD (#1260, CPU, FreeBSD)
+* Don't use Wifi speed as Ethernet speed (LocalIP, FreeBSD)
+* Fix compiling with old linux headers (Camera, Linux)
+* Fix detecting public ipv6 address (PublicIP, Windows)
+
+Logo:
+* Fix parrot logo detection
+* Rename TorizonCore to Torizon OS
+
+# 2.24.0
+
+Changes:
+* Support of `--lib-XXX` is removed
+    * If fastfetch fails to load some `.so` `.dylib` libraries, `LD_LIBRARY_PATH` should be used.
+
+Features:
+* Support sixel image protocol on Windows (Logo, Windows)
+    * Requires imagemagick7 to be installed. MSYS2 is recommended.
+* Improve terminal query on Windows (Windows)
+    * TerminalSize, TerminalTheme
+* Detect more ARM microarchitectures and SOC names (CPU, Linux)
+* Detect the number of online cores (CPU, FreeBSD)
+* Support board name detection for Asahi Linux (Board, Linux)
+* Add new option `--command-param` to customize the parameters when running shell
+* Support syntax of sub string in `--<module>-format`: `{variable~startIndex,endIndex}`
+    * See `fastfetch -h format` for detail
+
+Bugfixes:
+* Fix tests building when system yyjson is used (#1244)
+* Fix dinit detection; support dinit version detection (#1245, InitSystem, Linux)
+* Fix signal quality, refresh rate and maybe others in custom format (#1241)
+* Fix boot time calculation (#1249, Uptime, Linux)
+* Fix custom format for boolean values
+    * `{?false-value}This should not print{?}{?true-value}This should print{?}` will print `This should print`
+* Fix possible hanging when running fastfetch in screen 5.0 (TerminalTheme, macOS)
+
+Logos:
+* Add Lliurex
+
 # 2.23.0
 
 Features:

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url
 
 project(fastfetch
-    VERSION 2.23.0
+    VERSION 2.25.0
     LANGUAGES C
     DESCRIPTION "Fast neofetch-like system information tool"
     HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -69,7 +69,7 @@ cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)
 cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR SunOS" OFF)
 cmake_dependent_option(ENABLE_DDCUTIL "Enable ddcutil" ON "LINUX" OFF)
 cmake_dependent_option(ENABLE_DIRECTX_HEADERS "Enable DirectX headers for WSL" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_ELF "Enable libelf" ON "LINUX OR FreeBSD OR ANDROID" OFF)
+cmake_dependent_option(ENABLE_ELF "Enable libelf" ON "LINUX OR ANDROID" OFF)
 cmake_dependent_option(ENABLE_THREADS "Enable multithreading" ON "Threads_FOUND" OFF)
 cmake_dependent_option(ENABLE_LIBZFS "Enable libzfs" ON "LINUX OR FreeBSD OR SunOS" OFF)
 
@@ -88,6 +88,15 @@ if(NOT BINARY_LINK_TYPE IN_LIST BINARY_LINK_TYPE_OPTIONS)
     message(FATAL_ERROR "BINARY_LINK_TYPE must be one of ${BINARY_LINK_TYPE_OPTIONS}")
 endif()
 
+set(PACKAGE_MANAGERS AM APK BREW CHOCO DPKG EMERGE EOPKG FLATPAK GUIX LINGLONG LPKG LPKGBUILD MACPORTS NIX OPKG PACMAN PALUDIS PKG PKGTOOL RPM SCOOP SNAP SORCERY WINGET XBPS)
+foreach(package_manager ${PACKAGE_MANAGERS})
+    if(package_manager STREQUAL "WINGET")
+        option(PACKAGES_DISABLE_${package_manager} "Disable ${package_manager} package manager detection by default" ON)
+    else()
+        option(PACKAGES_DISABLE_${package_manager} "Disable ${package_manager} package manager detection by default" OFF)
+    endif()
+endforeach()
+
 if (LINUX)
     set(CUSTOM_PCI_IDS_PATH "" CACHE STRING "Custom path to file pci.ids, defaults to `/usr/share/hwdata/pci.ids`")
     set(CUSTOM_AMDGPU_IDS_PATH "" CACHE STRING "Custom path to file amdgpu.ids, defaults to `/usr/share/libdrm/amdgpu.ids`")
@@ -333,6 +342,7 @@ set(LIBFASTFETCH_SRC
     src/modules/bootmgr/bootmgr.c
     src/modules/brightness/brightness.c
     src/modules/break/break.c
+    src/modules/btrfs/btrfs.c
     src/modules/camera/camera.c
     src/modules/chassis/chassis.c
     src/modules/colors/colors.c
@@ -398,7 +408,6 @@ set(LIBFASTFETCH_SRC
     src/options/modules.c
     src/options/logo.c
     src/options/general.c
-    src/options/library.c
     src/util/edidHelper.c
     src/util/base64.c
     src/util/FFlist.c
@@ -420,6 +429,7 @@ if(LINUX)
         src/detection/board/board_linux.c
         src/detection/bootmgr/bootmgr_linux.c
         src/detection/brightness/brightness_linux.c
+        src/detection/btrfs/btrfs_linux.c
         src/detection/chassis/chassis_linux.c
         src/detection/cpu/cpu_linux.c
         src/detection/cpucache/cpucache_linux.c
@@ -500,6 +510,7 @@ elseif(ANDROID)
         src/detection/board/board_android.c
         src/detection/bootmgr/bootmgr_nosupport.c
         src/detection/brightness/brightness_nosupport.c
+        src/detection/btrfs/btrfs_nosupport.c
         src/detection/chassis/chassis_nosupport.c
         src/detection/cpu/cpu_linux.c
         src/detection/cpucache/cpucache_linux.c
@@ -565,6 +576,7 @@ elseif(FreeBSD)
         src/detection/board/board_bsd.c
         src/detection/bootmgr/bootmgr_bsd.c
         src/detection/brightness/brightness_bsd.c
+        src/detection/btrfs/btrfs_nosupport.c
         src/detection/chassis/chassis_bsd.c
         src/detection/cpu/cpu_bsd.c
         src/detection/cpucache/cpucache_shared.c
@@ -644,6 +656,7 @@ elseif(APPLE)
         src/detection/board/board_apple.c
         src/detection/bootmgr/bootmgr_apple.c
         src/detection/brightness/brightness_apple.c
+        src/detection/btrfs/btrfs_nosupport.c
         src/detection/chassis/chassis_nosupport.c
         src/detection/cpu/cpu_apple.c
         src/detection/cpucache/cpucache_apple.c
@@ -710,6 +723,7 @@ elseif(WIN32)
         src/detection/board/board_windows.c
         src/detection/bootmgr/bootmgr_windows.c
         src/detection/brightness/brightness_windows.cpp
+        src/detection/btrfs/btrfs_nosupport.c
         src/detection/chassis/chassis_windows.c
         src/detection/cpu/cpu_windows.c
         src/detection/cpucache/cpucache_windows.c
@@ -777,6 +791,7 @@ elseif(SunOS)
         src/detection/board/board_windows.c
         src/detection/bootmgr/bootmgr_nosupport.c
         src/detection/brightness/brightness_nosupport.c
+        src/detection/btrfs/btrfs_nosupport.c
         src/detection/chassis/chassis_windows.c
         src/detection/cpu/cpu_sunos.c
         src/detection/cpucache/cpucache_shared.c
@@ -886,8 +901,8 @@ add_library(libfastfetch OBJECT
 )
 
 if(yyjson_FOUND)
-    target_compile_definitions(libfastfetch PRIVATE FF_USE_SYSTEM_YYJSON)
-    target_link_libraries(libfastfetch PRIVATE yyjson::yyjson)
+    target_compile_definitions(libfastfetch PUBLIC FF_USE_SYSTEM_YYJSON)
+    target_link_libraries(libfastfetch PUBLIC yyjson::yyjson)
     # `target_link_libraries(yyjson::yyjson)` sets rpath implicitly
 else()
     # Used for dlopen finding dylibs installed by homebrew
@@ -929,11 +944,11 @@ elseif(SunOS)
 endif()
 
 if(HAVE_STATX)
-    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_STATX)
+    target_compile_definitions(libfastfetch PUBLIC FF_HAVE_STATX)
 endif()
 
 if(HAVE_WCWIDTH)
-    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WCWIDTH)
+    target_compile_definitions(libfastfetch PUBLIC FF_HAVE_WCWIDTH)
 endif()
 
 if(NOT "${CUSTOM_PCI_IDS_PATH}" STREQUAL "")
@@ -1265,6 +1280,22 @@ if(NOT WIN32)
     endif()
 endif()
 
+set(PACKAGES_DISABLE_LIST "")
+foreach(package_manager ${PACKAGE_MANAGERS})
+    if(PACKAGES_DISABLE_${package_manager})
+        list(APPEND PACKAGES_DISABLE_LIST "${package_manager}")
+    endif()
+endforeach()
+if("${PACKAGES_DISABLE_LIST}" STREQUAL "")
+    set(PACKAGES_DISABLE_LIST "FF_PACKAGES_FLAG_NONE")
+else()
+    message(STATUS "Disabled package managers: ${PACKAGES_DISABLE_LIST}")
+    list(TRANSFORM PACKAGES_DISABLE_LIST PREPEND "FF_PACKAGES_FLAG_")
+    list(TRANSFORM PACKAGES_DISABLE_LIST APPEND "_BIT")
+    list(JOIN PACKAGES_DISABLE_LIST " | " PACKAGES_DISABLE_LIST)
+endif()
+target_compile_definitions(libfastfetch PRIVATE FF_PACKAGES_DISABLE_LIST=${PACKAGES_DISABLE_LIST})
+
 ######################
 # Executable targets #
 ######################
@@ -1295,13 +1326,6 @@ set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "")
 set_target_properties(fastfetch PROPERTIES LINKER_LANGUAGE C)
 set_target_properties(flashfetch PROPERTIES LINKER_LANGUAGE C)
 
-if(yyjson_FOUND)
-    target_compile_definitions(fastfetch PRIVATE FF_USE_SYSTEM_YYJSON)
-    target_link_libraries(fastfetch PRIVATE yyjson::yyjson)
-    target_compile_definitions(flashfetch PRIVATE FF_USE_SYSTEM_YYJSON)
-    target_link_libraries(flashfetch PRIVATE yyjson::yyjson)
-endif()
-
 if(WIN32)
     target_sources(fastfetch
         PRIVATE src/util/windows/version.rc

README.md

@@ -27,7 +27,7 @@ There are [screenshots on different platforms](https://github.com/fastfetch-cli/
 
 ### Linux
 
-Some distros packaged an outdated fastfetch version. Older version receive no support, so please try always to use the latest version.
+Some distros package an outdated fastfetch version. Older versions receive no support, so please try always to use the latest version.
 
 * Ubuntu: [`ppa:zhangsongcui3371/fastfetch`](https://launchpad.net/~zhangsongcui3371/+archive/ubuntu/fastfetch) (for Ubuntu 22.04 or newer)
 * Debian: `apt install fastfetch` (for Debian 13 or newer)
@@ -81,7 +81,7 @@ See Wiki: https://github.com/fastfetch-cli/fastfetch/wiki/Building
 ## Usage
 
 * Run it with default configuration: `fastfetch`
-* Run it with [all supported modules](https://github.com/fastfetch-cli/fastfetch/wiki/Support+Status#available-modules) and find what you interest: `fastfetch -c all.jsonc`
+* Run it with [all supported modules](https://github.com/fastfetch-cli/fastfetch/wiki/Support+Status#available-modules) and find what interests you: `fastfetch -c all.jsonc`
 * Find all data that fastfetch detects: `fastfetch -s <module> --format json`
 * Display help messages: `fastfetch --help`
 * Generate config file based on command line arguments: `fastfetch --arg1 --arg2 --gen-config`
@@ -90,7 +90,7 @@ See Wiki: https://github.com/fastfetch-cli/fastfetch/wiki/Building
 
 Fastfetch uses the JSONC (or JSON with comments) for configuration. [See Wiki for detail](https://github.com/fastfetch-cli/fastfetch/wiki/Configuration). There are some premade config files in [`presets`](presets), including the ones used for the screenshots above. You can load them using `-c <filename>`. Those files can serve as examples of the configuration syntax.
 
-Logos can be heavily customized too; see the [logo documentation](https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options) for more information.
+Logos can also be heavily customized; see the [logo documentation](https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options) for more information.
 
 
 ## Packaging
@@ -112,7 +112,7 @@ Logos can be heavily customized too; see the [logo documentation](https://github
 2. Fastfetch is faster. As the name suggests.
 3. Fastfetch has a greater number of features, though by default fastfetch only has a few modules enabled; use `fastfetch -c all` to find what you want.
 4. Fastfetch is more configurable. You can find more information in the Wiki: <https://github.com/fastfetch-cli/fastfetch/wiki/Configuration>.
-5. Fastfetch is more polished. For example, neofetch prints `555MiB` in `Memory` module and `23G` in `Disk` module, whereas fastfetch prints `555.00 MiB` and `22.97 GiB` respectively.
+5. Fastfetch is more polished. For example, neofetch prints `555 MiB` in the Memory module and `23 G` in the Disk module, whereas fastfetch prints `555.00 MiB` and `22.97 GiB` respectively.
 6. Fastfetch is more accurate. For example, [neofetch never actually supports the Wayland protocol](https://github.com/dylanaraps/neofetch/pull/2395).
 
 ### Q: Fastfetch shows my local IP address. It leaks my privacy!

debian/changelog

@@ -1,3 +1,15 @@
+fastfetch (2.24.0) jammy; urgency=medium
+
+  * Update to 2.24.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 11 Sep 2024 13:50:02 +0800
+
+fastfetch (2.23.0) jammy; urgency=medium
+
+  * Update to 2.23.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 03 Sep 2024 18:44:11 +0800
+
 fastfetch (2.22.0) jammy; urgency=medium
 
   * Update to 2.22.0

debian/files

@@ -1 +1 @@
-fastfetch_2.22.0_source.buildinfo universe/utils optional
+fastfetch_2.24.0_source.buildinfo universe/utils optional

doc/json_schema.json

@@ -337,7 +337,7 @@
                 "processingTimeout": {
                     "type": "integer",
                     "description": "Set the timeout (ms) when waiting for child processes, `-1` for no timeout",
-                    "default": 1000
+                    "default": 5000
                 },
                 "preRun": {
                     "type": "string",
@@ -638,113 +638,6 @@
                 }
             }
         },
-        "library": {
-            "description": "Set the path of a library to load",
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-                "vulkan": {
-                    "type": "string",
-                    "description": "Vulkan module & fallback for GPU output"
-                },
-                "freetype": {
-                    "type": "string",
-                    "description": "Used for Termux font detection (Android)"
-                },
-                "wayland": {
-                    "type": "string",
-                    "description": "Better display performance and output in wayland sessions.\nSupports different refresh rates per monitor.\n(Linux, FreeBSD)"
-                },
-                "xcbRandr": {
-                    "type": "string",
-                    "description": "X11 sessions for better display detection and faster WM detection.\nThe *randr ones provide multi monitor support The libxcb* ones usually have better performance.\n (Linux, FreeBSD, SunOS)"
-                },
-                "xcb": {
-                    "type": "string",
-                    "description": "X11 sessions for better display detection and faster WM detection.\nThe *randr ones provide multi monitor support The libxcb* ones usually have better performance.\n (Linux, FreeBSD, SunOS)"
-                },
-                "xrandr": {
-                    "type": "string",
-                    "description": "X11 sessions for better display detection and faster WM detection.\nThe *randr ones provide multi monitor support The libxcb* ones usually have better performance.\n (Linux, FreeBSD, SunOS)"
-                },
-                "x11": {
-                    "type": "string",
-                    "description": "X11 sessions for better display detection and faster WM detection.\nThe *randr ones provide multi monitor support The libxcb* ones usually have better performance.\n (Linux, FreeBSD, SunOS)"
-                },
-                "drm": {
-                    "type": "string",
-                    "description": "Used for fast resolution and refresh rate detection (Linux, FreeBSD)"
-                },
-                "gio": {
-                    "type": "string",
-                    "description": "Needed for values that are only stored GSettings (Linux, FreeBSD, SunOS)"
-                },
-                "dconf": {
-                    "type": "string",
-                    "description": "Needed for values that are only stored in DConf + Fallback for GSettings (Linux, FreeBSD, SunOS)"
-                },
-                "dbus": {
-                    "type": "string",
-                    "description": "Bluetooth, Player & Media detection (Linux, FreeBSD, SunOS)"
-                },
-                "xfconf": {
-                    "type": "string",
-                    "description": "Needed for XFWM theme and XFCE Terminal font (Linux, FreeBSD, SunOS)"
-                },
-                "sqlite3": {
-                    "type": "string",
-                    "description": "Needed for pkg & rpm package count (Linux, FreeBSD)"
-                },
-                "rpm": {
-                    "type": "string",
-                    "description": "Slower fallback for rpm package count. Needed on openSUSE & old CentOS / Redhat. (Linux)"
-                },
-                "imagemagick": {
-                    "type": "string",
-                    "description": "Images in terminal using sixel or kitty graphics protocol (Linux, FreeBSD, SunOS, macOS)"
-                },
-                "z": {
-                    "description": "Libz. Faster image output when using kitty graphics protocol (Linux, FreeBSD, SunOS, macOS)",
-                    "type": "string"
-                },
-                "chafa": {
-                    "type": "string",
-                    "description": "Image output as ascii art (Linux, FreeBSD, SunOS, macOS)"
-                },
-                "egl": {
-                    "type": "string",
-                    "description": "Library used by the OpenGL module for gl context creation (Linux, FreeBSD, SunOS, Windows)"
-                },
-                "glx": {
-                    "type": "string",
-                    "description": "Library used by the OpenGL module for gl context creation (Linux, FreeBSD, SunOS)"
-                },
-                "osmesa": {
-                    "type": "string",
-                    "description": "Library used by the OpenGL module for gl context creation (Linux, FreeBSD, SunOS)"
-                },
-                "opencl": {
-                    "type": "string",
-                    "description": "OpenCL module (Linux, FreeBSD, SunOS, Windows)"
-                },
-                "pulse": {
-                    "description": "Pulseaudio. Used for Sound detection (Linux, FreeBSD, SunOS)",
-                    "type": "string"
-                },
-                "nm": {
-                    "description": "NetworkManager. Used for Wifi detection (Linux)",
-                    "type": "string"
-                },
-                "ddcutil": {
-                    "description": "Used for brightness detection of external displays (Linux)",
-                    "type": "string"
-                },
-                "elf": {
-                    "description": "Used for st terminal font detection and systemd version detection (Linux)",
-                    "type": "string"
-                }
-            }
-        },
         "modules": {
             "description": "Fastfetch modules to run",
             "type": "array",
@@ -762,6 +655,7 @@
                             "bootmgr",
                             "break",
                             "brightness",
+                            "btrfs",
                             "camera",
                             "chassis",
                             "cpu",
@@ -994,10 +888,6 @@
                                             {
                                                 "const": "wmtheme",
                                                 "description": "Print current theme of window manager"
-                                            },
-                                            {
-                                                "const": "zpool",
-                                                "description": "Print ZFS storage pools"
                                             }
                                         ]
                                     },
@@ -1166,6 +1056,38 @@
                                     }
                                 }
                             },
+                            {
+                                "title": "BTRFS",
+                                "type": "object",
+                                "additionalProperties": false,
+                                "properties": {
+                                    "type": {
+                                        "const": "btrfs",
+                                        "description": "Print Btrfs volumes"
+                                    },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
+                                    },
+                                    "keyColor": {
+                                        "$ref": "#/$defs/keyColor"
+                                    },
+                                    "keyIcon": {
+                                        "$ref": "#/$defs/keyIcon"
+                                    },
+                                    "keyWidth": {
+                                        "$ref": "#/$defs/keyWidth"
+                                    },
+                                    "outputColor": {
+                                        "$ref": "#/$defs/outputColor"
+                                    },
+                                    "format": {
+                                        "$ref": "#/$defs/format"
+                                    }
+                                }
+                            },
                             {
                                 "title": "Chassis",
                                 "type": "object",
@@ -1343,6 +1265,10 @@
                                         "description": "Set the shell program to execute the command text\nDefault: cmd for Windows, /bin/sh for *nix",
                                         "type": "string"
                                     },
+                                    "param": {
+                                        "description": "Set the parameter used when starting the shell\nDefault: /c for Windows, -c for *nix",
+                                        "type": "string"
+                                    },
                                     "text": {
                                         "description": "Set the command text to be executed",
                                         "type": "string"
@@ -1737,6 +1663,16 @@
                                         "type": "boolean",
                                         "default": false
                                     },
+                                    "showSpeed": {
+                                        "description": "Show ethernet rx speed",
+                                        "type": "boolean",
+                                        "default": false
+                                    },
+                                    "showMtu": {
+                                        "description": "Show MTU",
+                                        "type": "boolean",
+                                        "default": false
+                                    },
                                     "showMac": {
                                         "description": "Show MAC addresses",
                                         "type": "boolean",
@@ -2364,6 +2300,38 @@
                                         "$ref": "#/$defs/format"
                                     }
                                 }
+                            },
+                            {
+                                "title": "Zpool",
+                                "type": "object",
+                                "additionalProperties": false,
+                                "properties": {
+                                    "type": {
+                                        "const": "zpool",
+                                        "description": "Print ZFS storage pools"
+                                    },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
+                                    },
+                                    "keyColor": {
+                                        "$ref": "#/$defs/keyColor"
+                                    },
+                                    "keyIcon": {
+                                        "$ref": "#/$defs/keyIcon"
+                                    },
+                                    "keyWidth": {
+                                        "$ref": "#/$defs/keyWidth"
+                                    },
+                                    "outputColor": {
+                                        "$ref": "#/$defs/outputColor"
+                                    },
+                                    "format": {
+                                        "$ref": "#/$defs/format"
+                                    }
+                                }
                             }
                         ]
                     }

presets/all.jsonc

@@ -54,8 +54,12 @@
         "physicalmemory",
         "swap",
         "disk",
+        "btrfs",
         "zpool",
-        "battery",
+        {
+            "type": "battery",
+            "temp": true
+        },
         "poweradapter",
         "player",
         "media",
@@ -66,7 +70,9 @@
         {
             "type": "localip",
             "showIpv6": true,
-            "showMac": true
+            "showMac": true,
+            "showSpeed": true,
+            "showMtu": true
         },
         "dns",
         "wifi",

presets/ci.jsonc

@@ -1,100 +1,106 @@
 {
-  "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
-  "display": {
-    "stat": true,
-    "pipe": true,
-    "showErrors": true,
-    "noBuffer": true
-  },
-  "logo": null,
-  "modules": [
-    "title",
-    "separator",
-    "os",
-    "host",
-    "bios",
-    "bootmgr",
-    "board",
-    "chassis",
-    "kernel",
-    "initsystem",
-    "uptime",
-    "loadavg",
-    "processes",
-    "packages",
-    "shell",
-    "editor",
-    "display",
-    "brightness",
-    "monitor",
-    "lm",
-    "de",
-    "wm",
-    "wmtheme",
-    "theme",
-    "icons",
-    "font",
-    "cursor",
-    "wallpaper",
-    "terminal",
-    "terminalfont",
-    "terminalsize",
-    "terminaltheme",
-    {
-        "type": "cpu",
-        "showPeCoreCount": true,
-        "temp": true
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "display": {
+        "stat": true,
+        "pipe": true,
+        "showErrors": true,
+        "noBuffer": true
     },
-    "cpucache",
-    "cpuusage",
-    {
-        "type": "gpu",
-        "driverSpecific": true,
-        "temp": true
-    },
-    "memory",
-    "physicalmemory",
-    "swap",
-    "disk",
-    "zpool",
-    "battery",
-    "poweradapter",
-    "player",
-    "media",
-    {
-        "type": "publicip",
-        "timeout": 1000
-    },
-    {
-        "type": "localip",
-        "showIpv6": true,
-        "showMac": true
-    },
-    "dns",
-    "wifi",
-    "datetime",
-    "locale",
-    "vulkan",
-    "opengl",
-    "opencl",
-    "users",
-    "bluetooth",
-    "bluetoothradio",
-    "sound",
-    "camera",
-    "gamepad",
-    {
-      "type": "weather",
-      "timeout": 1000
-    },
-    "netio",
-    "diskio",
-    {
-        "type": "physicaldisk",
-        "temp": true
-    },
-    "version",
-    "break",
-    "colors"
-  ]
+    "logo": null,
+    "modules": [
+        "title",
+        "separator",
+        "os",
+        "host",
+        "bios",
+        "bootmgr",
+        "board",
+        "chassis",
+        "kernel",
+        "initsystem",
+        "uptime",
+        "loadavg",
+        "processes",
+        "packages",
+        "shell",
+        "editor",
+        "display",
+        "brightness",
+        "monitor",
+        "lm",
+        "de",
+        "wm",
+        "wmtheme",
+        "theme",
+        "icons",
+        "font",
+        "cursor",
+        "wallpaper",
+        "terminal",
+        "terminalfont",
+        "terminalsize",
+        "terminaltheme",
+        {
+            "type": "cpu",
+            "showPeCoreCount": true,
+            "temp": true
+        },
+        "cpucache",
+        "cpuusage",
+        {
+            "type": "gpu",
+            "driverSpecific": true,
+            "temp": true
+        },
+        "memory",
+        "physicalmemory",
+        "swap",
+        "disk",
+        "btrfs",
+        "zpool",
+        {
+            "type": "battery",
+            "temp": true
+        },
+        "poweradapter",
+        "player",
+        "media",
+        {
+            "type": "publicip",
+            "timeout": 1000
+        },
+        {
+            "type": "localip",
+            "showIpv6": true,
+            "showMac": true,
+            "showSpeed": true,
+            "showMtu": true
+        },
+        "dns",
+        "wifi",
+        "datetime",
+        "locale",
+        "vulkan",
+        "opengl",
+        "opencl",
+        "users",
+        "bluetooth",
+        "bluetoothradio",
+        "sound",
+        "camera",
+        "gamepad",
+        {
+            "type": "weather",
+            "timeout": 1000
+        },
+        "netio",
+        "diskio",
+        {
+            "type": "physicaldisk",
+            "temp": true
+        },
+        "version",
+        "break",
+        "colors"
+    ]
 }

presets/examples/24.jsonc

@@ -0,0 +1,152 @@
+// By jan-rex
+// Modified from: https://github.com/fastfetch-cli/fastfetch/discussions/1269
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+      "padding": {
+        "top": 2
+      }
+    },
+    "display": {
+      "separator": "",
+      "constants": [
+        // CONSTANT {$1} - COLOR BACKGROUND FOR KEY
+        "\u001b[48;2;43;43;69m",
+        // CONSTANT {$2} - COLOR BACKGROUND FOR OUTPUT
+        "\u001b[48;2;56;59;78m",
+        // CONSTANT {$3} - VERTICAL BARS AT START AND 75th CHARACTERS FORWARD AND BACKWARD
+        "\u001b[90m│                                                            │\u001b[60D\u001b[39m",
+      ]
+    },
+    "modules": [
+      // CUSTOM - Top UI bar
+      {
+        "type": "custom",
+        "key": "{#90}{$1}╭─────────────╮",
+        "format": "{#90}{$2}╭────────────────────────────────────────────────────────────╮",
+      },
+      {
+        "type": "title",
+        "key": "{#90}{$1}│ {#92}User        {#90}│",
+        "format": "{$2}{$3}{user-name} {#2}[{home-dir}]"
+      },
+      {
+        "type": "users",
+        "key": "{#90}{$1}│ {#92}Users       {#90}│",
+        "myselfOnly": false,
+        "format": "{$2}{$3}{1}@{host-name}{/host-name}localhost{/}{?client-ip}  {#2}[IP:{client-ip}]{?}  {#2}[Login time: {login-time}]",
+      },
+      {
+        "type": "datetime",
+        "key": "{#90}{$1}│ {#92}Datetime    {#90}│",
+        "format": "{$2}{$3}{year}-{month-pretty}-{day-in-month}  {hour-pretty}:{minute-pretty}:{second-pretty}  {#2}{weekday}  {#2}[W{week}] {#2}[UTC{offset-from-utc}]"
+      },
+      {
+        "type": "title",
+        "key": "{#90}{$1}│ {#93}Host:       {#90}│",
+        "format": "{$2}{$3}{#1}{#36}{host-name}"
+      },
+      {
+        "type": "host",
+        "key": "{#90}{$1}│ {#93}Machine     {#90}│",
+        "format": "{$2}{$3}{name} {#2}{version}"
+      },
+      {
+        "type": "os",
+        "key": "{#90}{$1}│ {#93}OS          {#90}│",
+        "format": "{$2}{$3}{pretty-name} {codename} {#2}[v{version}] {#2}[{arch}]"
+      },
+      {
+        "type": "kernel",
+        "key": "{#90}{$1}│ {#93}Kernel      {#90}│",
+        "format": "{$2}{$3}{sysname} {#2}[v{release}]"
+      },
+      {
+        "type": "uptime",
+        "key": "{#90}{$1}│ {#93}Uptime      {#90}│",
+        "format": "{$2}{$3}{?days}{days} Days + {?}{hours}:{minutes}:{seconds}"
+      },
+      {
+        "type": "cpu",
+        "key": "{#90}{$1}│ {#91}CPU         {#90}│",
+        "showPeCoreCount": true,
+        "temp": true,
+        "format": "{$2}{$3}{name} {#2}[C:{core-types}] {#2}[{freq-max}]"
+      },
+      {
+        "type": "gpu",
+        "key": "{#90}{$1}│ {#91}GPU         {#90}│",
+        "detectionMethod": "auto",
+        "driverSpecific": true,
+        "format": "{$2}{$3}{name} {#2}[C:{core-count}] {#2}[{type}]"
+      },
+      {
+        "type": "memory",
+        "key": "{#90}{$1}│ {#91}Memory      {#90}│",
+        "format": "{$2}{$3}{used} / {total} ({percentage}{$2})"
+      },
+      {
+        "type": "disk",
+        "key": "{#90}{$1}│ {#91}Disk        {#90}│",
+        "format": "{$2}{$3}{size-used} / {size-used} ({size-percentage}{$2})"
+      },
+      {
+        "type": "poweradapter",
+        "key": "{#90}{$1}│ {#91}Power       {#90}│",
+        "format": "{$2}{$3}{name}"
+      },
+      {
+        "type": "terminal",
+        "key": "{#90}{$1}│ {#95}Terminal    {#90}│",
+        "format": "{$2}{$3}{pretty-name} {#2}[{version}] [PID:{pid}]"
+      },
+      {
+        "type": "terminalfont",
+        "key": "{#90}{$1}│ {#95}Font        {#90}│",
+        "format": "{$2}{$3}{name}  {#2}[{size}]"
+      },
+      {
+        "type": "shell",
+        "key": "{#90}{$1}│ {#95}Shell       {#90}│",
+        "format": "{$2}{$3}{pretty-name}  {#2}[v{version}] [PID:{pid}]"
+      },
+      {
+        // localip IPv4
+        "type": "localip",
+        "key": "{#90}{$1}│ {#94}Local IPv4  {#90}│",
+        "showPrefixLen": true,
+        "showIpv4": true,
+        "showIpv6": false,
+        "showMtu": true,
+        "format": "{$2}{$3}{ifname}: {ipv4}  {#2}[MTU:{mtu}]"
+      },
+      {
+        // localip IPv6
+        "type": "localip",
+        "key": "{#90}{$1}│ {#94}Local IPv6  {#90}│",
+        "showPrefixLen": true,
+        "showIpv4": false,
+        "showIpv6": true,
+        "showMtu": true,
+        "format": "{$2}{$3}{ifname}: {ipv6}  {#2}[MTU:{mtu}]"
+      },
+      {
+        "type": "publicip",
+        "key": "{#90}{$1}│ {#94}Public IPv4 {#90}│",
+        "ipv6": false,
+        "format": "{$2}{$3}{ip}  {#2}[{location}]"
+      },
+      {
+        "type": "publicip",
+        "key": "{#90}{$1}│ {#94}Public IPv6 {#90}│",
+        "ipv6": true,
+        "format": "{$2}{$3}{ip}  {#2}[{location}]"
+      },
+      // CUSTOM - Button UI bar
+      {
+        "type": "custom",
+        "key": "{#90}{$1}╰─────────────╯",
+        "format": "{#90}{$2}╰────────────────────────────────────────────────────────────╯",
+      }
+    ]
+  }

presets/examples/9.jsonc

@@ -25,7 +25,10 @@
             "type": "disk",
             "folders": "/"
         },
-        "battery",
+        {
+            "type": "battery",
+            "key": "Battery"
+        },
         {
             "type": "colors",
             "paddingLeft": 10,

src/common/dbus.c

@@ -7,7 +7,7 @@
 
 static bool loadLibSymbols(FFDBusLibrary* lib)
 {
-    FF_LIBRARY_LOAD(dbus, &instance.config.library.libDBus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_LOAD(dbus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_bus_get, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_new_method_call, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_append_args, false)

src/common/format.c

@@ -8,39 +8,53 @@
 
 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, "%" PRIu32, *(uint32_t*)formatarg->value);
-    else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT64)
-        ffStrbufAppendF(buffer, "%" PRIu64, *(uint64_t*)formatarg->value);
-    else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT16)
-        ffStrbufAppendF(buffer, "%" PRIu16, *(uint16_t*)formatarg->value);
-    else if(formatarg->type == FF_FORMAT_ARG_TYPE_UINT8)
-        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, *(bool*)formatarg->value ? "true" : "false");
-    else if(formatarg->type == FF_FORMAT_ARG_TYPE_LIST)
+    switch(formatarg->type)
     {
-        const FFlist* list = formatarg->value;
-        for(uint32_t i = 0; i < list->length; i++)
+        case FF_FORMAT_ARG_TYPE_INT:
+            ffStrbufAppendF(buffer, "%" PRIi32, *(int32_t*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_UINT:
+            ffStrbufAppendF(buffer, "%" PRIu32, *(uint32_t*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_UINT64:
+            ffStrbufAppendF(buffer, "%" PRIu64, *(uint64_t*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_UINT16:
+            ffStrbufAppendF(buffer, "%" PRIu16, *(uint16_t*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_UINT8:
+            ffStrbufAppendF(buffer, "%" PRIu8, *(uint8_t*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_STRING:
+            ffStrbufAppendS(buffer, (const char*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_STRBUF:
+            ffStrbufAppend(buffer, (FFstrbuf*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_FLOAT:
+            ffStrbufAppendF(buffer, "%f", *(float*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_DOUBLE:
+            ffStrbufAppendF(buffer, "%g", *(double*)formatarg->value);
+            break;
+        case FF_FORMAT_ARG_TYPE_BOOL:
+            ffStrbufAppendS(buffer, *(bool*)formatarg->value ? "true" : "false");
+            break;
+        case FF_FORMAT_ARG_TYPE_LIST:
         {
-            ffStrbufAppend(buffer, ffListGet(list, i));
-            if(i < list->length - 1)
-                ffStrbufAppendS(buffer, ", ");
+            const FFlist* list = formatarg->value;
+            for(uint32_t i = 0; i < list->length; i++)
+            {
+                ffStrbufAppend(buffer, ffListGet(list, i));
+                if(i < list->length - 1)
+                    ffStrbufAppendS(buffer, ", ");
+            }
+            break;
         }
-    }
-    else if(formatarg->type != FF_FORMAT_ARG_TYPE_NULL)
-    {
-        fprintf(stderr, "Error: format string \"%s\": argument is not implemented: %i\n", buffer->chars, formatarg->type);
+        default:
+            if(formatarg->type != FF_FORMAT_ARG_TYPE_NULL)
+                fprintf(stderr, "Error: format string \"%s\": argument is not implemented: %i\n", buffer->chars, formatarg->type);
+            break;
     }
 }
 
@@ -100,7 +114,8 @@ static inline bool formatArgSet(const FFformatarg* arg)
         (arg->type == FF_FORMAT_ARG_TYPE_UINT8 && *(uint8_t*)arg->value > 0) ||
         (arg->type == FF_FORMAT_ARG_TYPE_UINT16 && *(uint16_t*)arg->value > 0) ||
         (arg->type == FF_FORMAT_ARG_TYPE_UINT && *(uint32_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_BOOL && arg->value != NULL)
+        (arg->type == FF_FORMAT_ARG_TYPE_BOOL && *(bool*)arg->value) ||
+        (arg->type == FF_FORMAT_ARG_TYPE_LIST && ((FFlist*)arg->value)->length > 0)
     );
 }
 
@@ -265,34 +280,18 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             continue;
         }
 
-        int32_t truncLength = 0;
-        char align = '\0';
-        char* pSep = memchr(placeholderValue.chars, ':', placeholderValue.length);
-        if (pSep)
-            align = ':';
+        char* pSep = placeholderValue.chars;
+        char cSep = '\0';
+        while (*pSep && *pSep != ':' && *pSep != '<' && *pSep != '>' && *pSep != '~')
+            ++pSep;
+        if (*pSep)
+        {
+            cSep = *pSep;
+            *pSep = '\0';
+        }
         else
         {
-            pSep = memchr(placeholderValue.chars, '<', placeholderValue.length);
-            if (pSep)
-                align = '<';
-            else
-            {
-                pSep = memchr(placeholderValue.chars, '>', placeholderValue.length);
-                if (pSep)
-                    align = '>';
-            }
-        }
-
-        if (pSep)
-        {
-            char* pEnd = NULL;
-            truncLength = (int32_t) strtol(pSep + 1, &pEnd, 10);
-            if (*pEnd != '\0')
-            {
-                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-                continue;
-            }
-            *pSep = '\0';
+            pSep = NULL;
         }
 
         uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);
@@ -303,53 +302,97 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
 
         if (index > numArgs)
         {
-            if (pSep) *pSep = align;
+            if (pSep) *pSep = cSep;
             appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
             continue;
         }
 
-        bool ellipsis = false;
-        if (truncLength < 0)
-        {
-            ellipsis = true;
-            truncLength = -truncLength;
-        }
-
-        if (!align)
+        if (!cSep)
             ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
+        else if (cSep == '~')
+        {
+            FF_STRBUF_AUTO_DESTROY tempString = ffStrbufCreate();
+            ffFormatAppendFormatArg(&tempString, &arguments[index - 1]);
+
+            char* pEnd = NULL;
+            int32_t start = (int32_t) strtol(pSep + 1, &pEnd, 10);
+            if (start < 0)
+                start = (int32_t) tempString.length + start;
+            if (start >= 0 && (uint32_t) start < tempString.length)
+            {
+                if (*pEnd == '\0')
+                    ffStrbufAppendNS(buffer, tempString.length - (uint32_t) start, &tempString.chars[start]);
+                else if (*pEnd == ',')
+                {
+                    int32_t end = (int32_t) strtol(pEnd + 1, &pEnd, 10);
+                    if (!*pEnd)
+                    {
+                        if (end < 0)
+                            end = (int32_t) tempString.length + end;
+                        if ((uint32_t) end > tempString.length)
+                            end = (int32_t) tempString.length;
+                        if (end > start)
+                            ffStrbufAppendNS(buffer, (uint32_t) (end - start), &tempString.chars[start]);
+                    }
+                }
+            }
+
+            if (*pEnd)
+            {
+                *pSep = cSep;
+                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
+                continue;
+            }
+        }
         else
         {
-            ffStrbufClear(&placeholderValue);
-            ffFormatAppendFormatArg(&placeholderValue, &arguments[index - 1]);
-            if (placeholderValue.length == (uint32_t) truncLength)
-                ffStrbufAppend(buffer, &placeholderValue);
-            else if (placeholderValue.length > (uint32_t) truncLength)
+            char* pEnd = NULL;
+            int32_t truncLength = (int32_t) strtol(pSep + 1, &pEnd, 10);
+            if (*pEnd != '\0')
             {
-                if (align == ':')
+                *pSep = cSep;
+                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
+                continue;
+            }
+
+            bool ellipsis = false;
+            if (truncLength < 0)
+            {
+                ellipsis = true;
+                truncLength = -truncLength;
+            }
+
+            FF_STRBUF_AUTO_DESTROY tempString = ffStrbufCreate();
+            ffFormatAppendFormatArg(&tempString, &arguments[index - 1]);
+            if (tempString.length == (uint32_t) truncLength)
+                ffStrbufAppend(buffer, &tempString);
+            else if (tempString.length > (uint32_t) truncLength)
+            {
+                if (cSep == ':')
                 {
-                    ffStrbufSubstrBefore(&placeholderValue, (uint32_t) truncLength);
-                    ffStrbufTrimRightSpace(&placeholderValue);
+                    ffStrbufSubstrBefore(&tempString, (uint32_t) truncLength);
+                    ffStrbufTrimRightSpace(&tempString);
                 }
                 else
-                    ffStrbufSubstrBefore(&placeholderValue, (uint32_t) (!ellipsis? truncLength : truncLength - 1));
-                ffStrbufAppend(buffer, &placeholderValue);
+                    ffStrbufSubstrBefore(&tempString, (uint32_t) (!ellipsis? truncLength : truncLength - 1));
+                ffStrbufAppend(buffer, &tempString);
 
                 if (ellipsis)
                     ffStrbufAppendS(buffer, "…");
             }
-            else if (align == ':')
-                ffStrbufAppend(buffer, &placeholderValue);
+            else if (cSep == ':')
+                ffStrbufAppend(buffer, &tempString);
             else
             {
-                if (align == '<')
+                if (cSep == '<')
                 {
-                    ffStrbufAppend(buffer, &placeholderValue);
-                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - placeholderValue.length, ' ');
+                    ffStrbufAppend(buffer, &tempString);
+                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - tempString.length, ' ');
                 }
                 else
                 {
-                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - placeholderValue.length, ' ');
-                    ffStrbufAppend(buffer, &placeholderValue);
+                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - tempString.length, ' ');
+                    ffStrbufAppend(buffer, &tempString);
                 }
             }
         }

src/common/format.h

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

src/common/init.c

@@ -43,7 +43,6 @@ static void defaultConfig(void)
     ffOptionsInitGeneral(&instance.config.general);
     ffOptionsInitModules(&instance.config.modules);
     ffOptionsInitDisplay(&instance.config.display);
-    ffOptionsInitLibrary(&instance.config.library);
 }
 
 void ffInitInstance(void)
@@ -148,7 +147,6 @@ static void destroyConfig(void)
     ffOptionsDestroyGeneral(&instance.config.general);
     ffOptionsDestroyModules(&instance.config.modules);
     ffOptionsDestroyDisplay(&instance.config.display);
-    ffOptionsDestroyLibrary(&instance.config.library);
 }
 
 static void destroyState(void)
@@ -244,7 +242,7 @@ void ffListFeatures(void)
         #if FF_HAVE_DDCUTIL
             "libddcutil\n"
         #endif
-        #if FF_HAVE_ELF
+        #if FF_HAVE_ELF || __sun || __FreeBSD__
             "libelf\n"
         #endif
         #if FF_HAVE_LIBZFS

src/common/io/io.h

@@ -130,8 +130,8 @@ bool ffPathExpandEnv(const char* in, FFstrbuf* out);
 
 #define FF_IO_TERM_RESP_WAIT_MS 100 // #554
 
-FF_C_SCANF(2, 3)
-const char* ffGetTerminalResponse(const char* request, const char* format, ...);
+FF_C_SCANF(3, 4)
+const char* ffGetTerminalResponse(const char* request, int nParams, const char* format, ...);
 
 // Not thread safe!
 bool ffSuppressIO(bool suppress);

src/common/io/io_unix.c

@@ -4,9 +4,13 @@
 
 #include <fcntl.h>
 #include <termios.h>
-#include <poll.h>
 #include <dirent.h>
 #include <errno.h>
+#ifndef __APPLE__
+#include <poll.h>
+#else
+#include <sys/select.h>
+#endif
 
 #if FF_HAVE_WORDEXP
     #include <wordexp.h>
@@ -140,11 +144,11 @@ void restoreTerm(void)
     tcsetattr(ftty, TCSAFLUSH, &oldTerm);
 }
 
-const char* ffGetTerminalResponse(const char* request, const char* format, ...)
+const char* ffGetTerminalResponse(const char* request, int nParams, const char* format, ...)
 {
     if (ftty < 0)
     {
-        ftty = open("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC | O_NONBLOCK);
+        ftty = open("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
         if (ftty < 0)
             return "open(\"/dev/tty\", O_RDWR | O_NOCTTY | O_CLOEXEC) failed";
 
@@ -161,20 +165,44 @@ const char* ffGetTerminalResponse(const char* request, const char* format, ...)
     ffWriteFDData(ftty, strlen(request), request);
 
     //Give the terminal some time to respond
+    #ifndef __APPLE__
     if(poll(&(struct pollfd) { .fd = ftty, .events = POLLIN }, 1, FF_IO_TERM_RESP_WAIT_MS) <= 0)
-        return "poll() timeout or failed";
+        return "poll(/dev/tty) timeout or failed";
+    #else
+    {
+        // On macOS, poll(/dev/tty) always returns immediately
+        // See also https://nathancraddock.com/blog/macos-dev-tty-polling/
+        fd_set rd;
+        FD_ZERO(&rd);
+        FD_SET(ftty, &rd);
+        if(select(ftty + 1, &rd, NULL, NULL, &(struct timeval) { .tv_sec = FF_IO_TERM_RESP_WAIT_MS / 1000, .tv_usec = (FF_IO_TERM_RESP_WAIT_MS % 1000) * 1000 }) <= 0)
+            return "select(/dev/tty) timeout or failed";
+    }
+    #endif
 
-    char buffer[512];
-    ssize_t bytesRead = read(ftty, buffer, sizeof(buffer) - 1);
-
-    if(bytesRead <= 0)
-        return "read(STDIN_FILENO, buffer, sizeof(buffer) - 1) failed";
-
-    buffer[bytesRead] = '\0';
+    char buffer[1024];
+    size_t bytesRead = 0;
 
     va_list args;
     va_start(args, format);
-    vsscanf(buffer, format, args);
+
+    while (true)
+    {
+        ssize_t nRead = read(ftty, buffer + bytesRead, sizeof(buffer) - bytesRead - 1);
+
+        if (nRead <= 0)
+            return "read(STDIN_FILENO, buffer, sizeof(buffer) - 1) failed";
+
+        bytesRead += (size_t) nRead;
+        buffer[bytesRead] = '\0';
+
+        int ret = vsscanf(buffer, format, args);
+        if (ret <= 0)
+            return "vsscanf(buffer, format, args) failed";
+        if (ret >= nParams)
+            break;
+    }
+
     va_end(args);
 
     return NULL;

src/common/io/io_windows.c

@@ -205,7 +205,7 @@ void ffListFilesRecursively(const char* path, bool pretty)
     listFilesRecursively(folder.length, &folder, 0, NULL, pretty);
 }
 
-const char* ffGetTerminalResponse(const char* request, const char* format, ...)
+const char* ffGetTerminalResponse(const char* request, int nParams, const char* format, ...)
 {
     HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
     FF_AUTO_CLOSE_FD HANDLE hConin = INVALID_HANDLE_VALUE;
@@ -256,20 +256,30 @@ const char* ffGetTerminalResponse(const char* request, const char* format, ...)
             ReadConsoleInputW(hInput, &record, 1, &len);
     }
 
-    char buffer[512];
-    DWORD bytes = 0;
-    ReadFile(hInput, buffer, sizeof(buffer) - 1, &bytes, NULL);
+    va_list args;
+    va_start(args, format);
+
+    char buffer[1024];
+    uint32_t bytesRead = 0;
+
+    while (true)
+    {
+        DWORD bytes = 0;
+        if (!ReadFile(hInput, buffer, sizeof(buffer) - 1, &bytes, NULL) || bytes == 0)
+            return "ReadFile() failed";
+
+        bytesRead += bytes;
+        buffer[bytesRead] = '\0';
+
+        int ret = vsscanf(buffer, format, args);
+        if (ret <= 0)
+            return "vsscanf(buffer, format, args) failed";
+        if (ret >= nParams)
+            break;
+    }
 
     SetConsoleMode(hInput, inputMode);
 
-    if(bytes <= 0)
-        return "ReadFile() failed";
-
-    buffer[bytes] = '\0';
-
-    va_list args;
-    va_start(args, format);
-    vsscanf(buffer, format, args);
     va_end(args);
 
     return NULL;

src/common/library.c

@@ -55,28 +55,28 @@ static void* libraryLoad(const char* path, int maxVersion)
     return result;
 }
 
-void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)
+void* ffLibraryLoad(const char* path, int maxVersion, ...)
 {
-    if(userProvidedName != NULL && userProvidedName->length > 0)
-        return dlopen(userProvidedName->chars, FF_DLOPEN_FLAGS);
+    void* result = libraryLoad(path, maxVersion);
 
-    va_list defaultNames;
-    va_start(defaultNames, userProvidedName);
-
-    void* result = NULL;
-
-    while(result == NULL)
+    if (!result)
     {
-        const char* path = va_arg(defaultNames, const char*);
-        if(path == NULL)
-            break;
+        va_list defaultNames;
+        va_start(defaultNames, maxVersion);
 
-        int maxVersion = va_arg(defaultNames, int);
-        result = libraryLoad(path, maxVersion);
+        do
+        {
+            const char* pathRest = va_arg(defaultNames, const char*);
+            if(pathRest == NULL)
+                break;
+
+            int maxVersionRest = va_arg(defaultNames, int);
+            result = libraryLoad(pathRest, maxVersionRest);
+        } while (!result);
+
+        va_end(defaultNames);
     }
 
-    va_end(defaultNames);
-
     return result;
 }
 

src/common/library.h

@@ -33,8 +33,8 @@ static inline void ffLibraryUnload(void** 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);\
+#define FF_LIBRARY_LOAD(libraryObjectName, returnValue, ...) \
+    void* __attribute__((__cleanup__(ffLibraryUnload))) libraryObjectName = ffLibraryLoad(__VA_ARGS__, NULL);\
     if(libraryObjectName == NULL) \
         return returnValue;
 
@@ -72,7 +72,7 @@ static inline void ffLibraryUnload(void** handle)
 #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, ...);
+void* ffLibraryLoad(const char* path, int maxVersion, ...);
 
 #else
 
@@ -81,7 +81,7 @@ void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
 #define FF_LIBRARY_SYMBOL(symbolName) \
     __typeof__(&symbolName) ff ## symbolName;
 
-#define FF_LIBRARY_LOAD(libraryObjectName, userLibraryName, returnValue, ...) \
+#define FF_LIBRARY_LOAD(libraryObjectName, returnValue, ...) \
     FF_MAYBE_UNUSED void* libraryObjectName = NULL; // Placeholder
 
 #define FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, symbolMapping, symbolName, returnValue) \

src/common/modules.c

@@ -13,6 +13,7 @@ static FFModuleBaseInfo* B[] = {
     (void*) &instance.config.modules.bootmgr,
     (void*) &instance.config.modules.break_,
     (void*) &instance.config.modules.brightness,
+    (void*) &instance.config.modules.btrfs,
     NULL,
 };
 

src/common/networking_linux.c

@@ -132,5 +132,6 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
     } while (ffStrbufGetFree(buffer) > 0 && strstr(buffer->chars + recvStart, "\r\n\r\n") == NULL);
 
     close(state->sockfd);
+    if (buffer->length == 0) return "Empty server response received";
     return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n") ? NULL : "Invalid response";
 }

src/common/networking_windows.c

@@ -63,19 +63,21 @@ const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* ho
         return "socket() failed";
     }
 
-    {
-        //ConnectEx requires the socket to be initially bound
-        if(bind(state->sockfd, (SOCKADDR *) &(struct sockaddr_in) {
+    //ConnectEx requires the socket to be initially bound
+    if((state->ipv6
+        ? bind(state->sockfd, (SOCKADDR *) &(struct sockaddr_in6) {
+            .sin6_family = AF_INET6,
+            .sin6_addr = in6addr_any,
+        }, sizeof(struct sockaddr_in6))
+        : bind(state->sockfd, (SOCKADDR *) &(struct sockaddr_in) {
             .sin_family = AF_INET,
             .sin_addr.s_addr = INADDR_ANY,
-            .sin_port = 0,
-        }, sizeof(struct sockaddr_in)) != 0)
-        {
-            closesocket(state->sockfd);
-            freeaddrinfo(addr);
-            state->sockfd = INVALID_SOCKET;
-            return "bind() failed";
-        }
+        }, sizeof(struct sockaddr_in))) != 0)
+    {
+        closesocket(state->sockfd);
+        freeaddrinfo(addr);
+        state->sockfd = INVALID_SOCKET;
+        return "bind() failed";
     }
 
     FF_STRBUF_AUTO_DESTROY command = ffStrbufCreateA(64);
@@ -93,7 +95,6 @@ const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* ho
     if(!result && WSAGetLastError() != WSA_IO_PENDING)
     {
         closesocket(state->sockfd);
-        freeaddrinfo(addr);
         state->sockfd = INVALID_SOCKET;
         return "ConnectEx() failed";
     }
@@ -140,5 +141,6 @@ const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buf
     } while (ffStrbufGetFree(buffer) > 0 && strstr(buffer->chars + recvStart, "\r\n\r\n") == NULL);
 
     closesocket(state->sockfd);
+    if (buffer->length == 0) return "Empty server response received";
     return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n") ? NULL : "Invalid response";
 }

src/common/printing.c

@@ -51,8 +51,8 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModu
             {
                 FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate();
                 FF_PARSE_FORMAT_STRING_CHECKED(&key, &moduleArgs->key, 2, ((FFformatarg[]){
-                    {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex, "index"},
-                    {FF_FORMAT_ARG_TYPE_STRBUF, &moduleArgs->keyIcon, "icon"},
+                    FF_FORMAT_ARG(moduleIndex, "index"),
+                    FF_FORMAT_ARG(moduleArgs->keyIcon, "icon"),
                 }));
                 ffStrbufWriteTo(&key, stdout);
             }

src/common/settings.c

@@ -60,7 +60,7 @@ static const GSettingsData* getGSettingsData(void)
     if (!data.inited)
     {
         data.inited = true;
-        FF_LIBRARY_LOAD(libgsettings, &instance.config.library.libGIO, NULL, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
+        FF_LIBRARY_LOAD(libgsettings, NULL, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
         FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_source_lookup, NULL)
         FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_has_key, NULL)
         FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_new_full, NULL)
@@ -141,7 +141,7 @@ static const DConfData* getDConfData(void)
     {
         data.inited = true;
 
-        FF_LIBRARY_LOAD(libdconf, &instance.config.library.libDConf, NULL, "libdconf" FF_LIBRARY_EXTENSION, 2);
+        FF_LIBRARY_LOAD(libdconf, NULL, "libdconf" FF_LIBRARY_EXTENSION, 2);
         FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data, dconf_client_read_full, NULL)
         FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data, dconf_client_new, NULL)
         FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_dup_string, NULL)
@@ -218,7 +218,7 @@ static const XFConfData* getXFConfData(void)
     if (!data.inited)
     {
         data.inited = true;
-        FF_LIBRARY_LOAD(libxfconf, &instance.config.library.libXFConf, NULL, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
+        FF_LIBRARY_LOAD(libxfconf, NULL, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
 
         FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_channel_get, NULL)
         FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_channel_has_property, NULL)
@@ -292,7 +292,7 @@ static const SQLiteData* getSQLiteData(void)
     if (!data.inited)
     {
         data.inited = true;
-        FF_LIBRARY_LOAD(libsqlite, &instance.config.library.libSQLite3, NULL, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
+        FF_LIBRARY_LOAD(libsqlite, NULL, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
         FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_open_v2, NULL)
         FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_prepare_v2, NULL)
         FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_step, NULL)

src/data/help.json

@@ -128,7 +128,7 @@
             "desc": "Set the timeout (ms) when waiting for child processes",
             "arg": {
                 "type": "num",
-                "default": 1000
+                "default": 5000
             }
         },
         {
@@ -766,184 +766,6 @@
             }
         }
     ],
-    "Library path": [
-        {
-            "long": "lib-vulkan",
-            "desc": "Vulkan module & fallback for GPU output",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-wayland",
-            "desc": "Better display performance and output in wayland sessions",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-xcb-randr",
-            "desc": "X11 sessions for better display detection and faster WM detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-xcb",
-            "desc": "X11 sessions for better display detection and faster WM detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-xrandr",
-            "desc": "X11 sessions for better display detection and faster WM detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-x11",
-            "desc": "X11 sessions for better display detection and faster WM detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-drm",
-            "desc": "Used for fast resolution and refresh rate detection",
-            "remark": "Linux only",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-gio",
-            "desc": "Needed for values that are only stored GSettings",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-dconf",
-            "desc": "Needed for values that are only stored in DConf + Fallback for GSettings",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-dbus",
-            "desc": "Bluetooth, Player & Media detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-xfconf",
-            "desc": "Needed for XFWM theme and XFCE Terminal font",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-sqlite3",
-            "desc": "Needed for pkg & rpm package count",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-rpm",
-            "desc": "Slower fallback for rpm package count",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-imagemagick",
-            "desc": "Images in terminal using sixel or kitty graphics protocol",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-z",
-            "desc": "Libz. Faster image output when using kitty graphics protocol",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-chafa",
-            "desc": "Image output as ascii art",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-egl",
-            "desc": "Needed by the OpenGL module for gl context creation",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-glx",
-            "desc": "Needed by the OpenGL module for gl context creation",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-osmesa",
-            "desc": "Needed by the OpenGL module for gl context creation",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-opencl",
-            "desc": "OpenCL module",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-pulse",
-            "desc": "Pulseaudio. Used for Sound detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-nm",
-            "desc": "NetworkManager. Used for Wifi detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-freetype",
-            "desc": "Used for Termux font detection",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-ddcutil",
-            "desc": "Used for brightness detection of external displays",
-            "arg": {
-                "type": "path"
-            }
-        },
-        {
-            "long": "lib-elf",
-            "desc": "Used for st terminal font detection and systemd version detection",
-            "arg": {
-                "type": "path"
-            }
-        }
-    ],
     "Module specific": [
         {
             "long": "title-fqdn",
@@ -1554,6 +1376,15 @@
                 "default": "\"cmd\" for Windows; \"/bin/sh\" for *nix"
             }
         },
+        {
+            "long": "command-param",
+            "desc": "Set the parameter used when starting the shell",
+            "remark": "Due to the difference of how OSes handle command line parameters, Windows will parse whitespaces as param separators, while *nix will not",
+            "arg": {
+                "type": "str",
+                "default": "\"/c\" for Windows; \"-c\" for *nix"
+            }
+        },
         {
             "long": "command-key",
             "desc": "Set the module key to display",

src/data/help_format.txt

@@ -17,6 +17,10 @@ In 2.23.0 or newer, `<` or `>` can be specified instead of `:` to set a left or
 For example: "--title-format '{user-name<20}'" will generate `<user-name>         `;
 "--title-format '{user-name>20}'" will generate `         <user-name>`
 
+In 2.24.0 or newer, `{~startIndex,endIndex}` can be specified to slice a string. Negative index counts back from the end of the string.
+If an index is omitted, 0 is used. For example, both `{~,0}` `{~0,}` and `{~,}` are same as `{~0,0}` and will always generate a empty string.
+If `,endIndex` is omitted or greater than the length of the string, the length of string is used.
+
 If the value index is missing, meaning the placeholder is "{}", an internal counter sets the value index.
 This means that the format string "Values: {1} ({2})" is equivalent to "Values: {} ({})".
 Note that this counter only counts empty placeholders, so the format string "{2} {} {}" will contain the second value, then the first, and then the second again.

src/detection/bluetooth/bluetooth_windows.c

@@ -10,7 +10,7 @@
 const char* ffDetectBluetooth(FFlist* devices /* FFBluetoothResult */)
 {
     // Actually bluetoothapis.dll, but it's missing on Windows 7
-    FF_LIBRARY_LOAD(bluetoothapis, NULL, "dlopen bthprops.cpl failed", "bthprops.cpl", 1)
+    FF_LIBRARY_LOAD(bluetoothapis, "dlopen bthprops.cpl failed", "bthprops.cpl", 1)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(bluetoothapis, BluetoothFindFirstDevice)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(bluetoothapis, BluetoothFindNextDevice)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(bluetoothapis, BluetoothFindDeviceClose)

src/detection/bluetoothradio/bluetoothradio_windows.c

@@ -54,7 +54,7 @@ static_assert(sizeof(BTH_LOCAL_RADIO_INFO) == 292, "BTH_LOCAL_RADIO_INFO should
 const char* ffDetectBluetoothRadio(FFlist* devices /* FFBluetoothRadioResult */)
 {
     // Actually bluetoothapis.dll, but it's missing on Windows 7
-    FF_LIBRARY_LOAD(bluetoothapis, NULL, "dlopen bthprops.cpl failed", "bthprops.cpl", 1)
+    FF_LIBRARY_LOAD(bluetoothapis, "dlopen bthprops.cpl failed", "bthprops.cpl", 1)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(bluetoothapis, BluetoothFindFirstRadio)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(bluetoothapis, BluetoothFindNextRadio)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(bluetoothapis, BluetoothFindRadioClose)

src/detection/board/board_linux.c

@@ -6,9 +6,21 @@
 
 const char* ffDetectBoard(FFBoardResult* board)
 {
-    ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_name", "/sys/class/dmi/id/board_name", &board->name);
-    ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_serial", "/sys/class/dmi/id/board_serial", &board->serial);
-    ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_vendor", "/sys/class/dmi/id/board_vendor", &board->vendor);
-    ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_version", "/sys/class/dmi/id/board_version", &board->version);
+    if (ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_name", "/sys/class/dmi/id/board_name", &board->name))
+    {
+        ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_serial", "/sys/class/dmi/id/board_serial", &board->serial);
+        ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_vendor", "/sys/class/dmi/id/board_vendor", &board->vendor);
+        ffGetSmbiosValue("/sys/devices/virtual/dmi/id/board_version", "/sys/class/dmi/id/board_version", &board->version);
+    }
+    else if (ffReadFileBuffer("/proc/device-tree/compatible", &board->vendor))
+    {
+        // use model name as board name
+        uint32_t comma = ffStrbufFirstIndexC(&board->vendor, ',');
+        if (comma < board->vendor.length)
+        {
+            ffStrbufSetS(&board->name, board->vendor.chars + comma + 1);
+            ffStrbufSubstrBefore(&board->vendor, comma);
+        }
+    }
     return NULL;
 }

src/detection/brightness/brightness_linux.c

@@ -101,7 +101,7 @@ DDCA_Status ddca_init(const char *libopts, int syslog_level, int opts);
 
 static const char* detectWithDdcci(FFBrightnessOptions* options, FFlist* result)
 {
-    FF_LIBRARY_LOAD(libddcutil, &instance.config.library.libDdcutil, "dlopen ddcutil failed", "libddcutil" FF_LIBRARY_EXTENSION, 5);
+    FF_LIBRARY_LOAD(libddcutil, "dlopen ddcutil failed", "libddcutil" FF_LIBRARY_EXTENSION, 5);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libddcutil, ddca_get_display_info_list2)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libddcutil, ddca_open_display2)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libddcutil, ddca_get_any_vcp_value_using_explicit_type)

src/detection/brightness/brightness_windows.cpp

@@ -39,7 +39,7 @@ static const char* detectWithWmi(FFlist* result)
 
 static const char* detectWithDdcci(const FFDisplayServerResult* displayServer, FFlist* result)
 {
-    FF_LIBRARY_LOAD(dxva2, NULL, "dlopen dxva2" FF_LIBRARY_EXTENSION " failed", "dxva2" FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD(dxva2, "dlopen dxva2" FF_LIBRARY_EXTENSION " failed", "dxva2" FF_LIBRARY_EXTENSION, 1)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(dxva2, GetPhysicalMonitorsFromHMONITOR)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(dxva2, GetMonitorBrightness)
 

src/detection/btrfs/btrfs.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "fastfetch.h"
+
+typedef struct FFBtrfsDiskUsage
+{
+    uint64_t total;
+    uint64_t used;
+    const char* type;
+    bool dup;
+} FFBtrfsDiskUsage;
+
+typedef struct FFBtrfsResult
+{
+    FFstrbuf name;
+    FFstrbuf uuid;
+    FFstrbuf devices;
+    FFstrbuf features;
+    uint32_t generation;
+    uint32_t nodeSize;
+    uint32_t sectorSize;
+    uint64_t totalSize;
+    uint64_t globalReservationUsed;
+    uint64_t globalReservationTotal;
+    FFBtrfsDiskUsage allocation[3];
+} FFBtrfsResult;
+
+const char* ffDetectBtrfs(FFlist* result /* list of FFBtrfsResult */);

src/detection/btrfs/btrfs_linux.c

@@ -0,0 +1,166 @@
+#include "btrfs.h"
+
+#include "common/io/io.h"
+
+enum { uuidLen = (uint32_t) __builtin_strlen("00000000-0000-0000-0000-000000000000") };
+
+static const char* enumerateDevices(FFBtrfsResult* item, FFstrbuf* path, FFstrbuf* buffer)
+{
+    ffStrbufAppendS(path, "devices/");
+    FF_AUTO_CLOSE_DIR DIR* dirp = opendir(path->chars);
+    if(dirp == NULL)
+        return "opendir(\"/sys/fs/btrfs/UUID/devices\") == NULL";
+    const uint32_t devicesPathLen = path->length;
+
+    struct dirent* entry;
+    while ((entry = readdir(dirp)) != NULL)
+    {
+        if (entry->d_name[0] == '.')
+            continue;
+
+        if (item->devices.length)
+            ffStrbufAppendC(&item->devices, ',');
+        ffStrbufAppendS(&item->devices, entry->d_name);
+        ffStrbufAppendS(path, entry->d_name);
+        ffStrbufAppendS(path, "/size");
+
+        if (ffReadFileBuffer(path->chars, buffer))
+            item->totalSize += ffStrbufToUInt(buffer, 0) * 512;
+
+        ffStrbufSubstrBefore(path, devicesPathLen);
+    }
+
+    return NULL;
+}
+
+static const char* enumerateFeatures(FFBtrfsResult* item, FFstrbuf* path)
+{
+    ffStrbufAppendS(path, "features/");
+    FF_AUTO_CLOSE_DIR DIR* dirp = opendir(path->chars);
+    if(dirp == NULL)
+        return "opendir(\"/sys/fs/btrfs/UUID/features\") == NULL";
+    const uint32_t featuresPathLen = path->length;
+
+    struct dirent* entry;
+    while ((entry = readdir(dirp)) != NULL)
+    {
+        if (entry->d_name[0] == '.')
+            continue;
+        if (item->features.length)
+            ffStrbufAppendC(&item->features, ',');
+        ffStrbufAppendS(&item->features, entry->d_name);
+
+        ffStrbufSubstrBefore(path, featuresPathLen);
+    }
+
+    return NULL;
+}
+
+static const char* detectAllocation(FFBtrfsResult* item, FFstrbuf* path, FFstrbuf* buffer)
+{
+    ffStrbufAppendS(path, "allocation/");
+    const uint32_t AllocationPathLen = path->length;
+
+    ffStrbufAppendS(path, "global_rsv_size");
+    if (ffReadFileBuffer(path->chars, buffer))
+        item->globalReservationTotal = ffStrbufToUInt(buffer, 0);
+    else
+        return "ffReadFileBuffer(\"/sys/fs/btrfs/UUID/allocation/global_rsv_size\") == NULL";
+    ffStrbufSubstrBefore(path, AllocationPathLen);
+
+    ffStrbufAppendS(path, "global_rsv_reserved");
+    if (ffReadFileBuffer(path->chars, buffer))
+        item->globalReservationUsed = ffStrbufToUInt(buffer, 0);
+    ffStrbufSubstrBefore(path, AllocationPathLen);
+    item->globalReservationUsed = item->globalReservationTotal - item->globalReservationUsed;
+
+    #define FF_BTRFS_DETECT_TYPE(index, _type) \
+    ffStrbufAppendS(path, #_type "/total_bytes"); \
+    if (ffReadFileBuffer(path->chars, buffer)) \
+        item->allocation[index].total = ffStrbufToUInt(buffer, 0); \
+    ffStrbufSubstrBefore(path, AllocationPathLen); \
+    \
+    ffStrbufAppendS(path, #_type "/bytes_used"); \
+    if (ffReadFileBuffer(path->chars, buffer)) \
+        item->allocation[index].used = ffStrbufToUInt(buffer, 0); \
+    ffStrbufSubstrBefore(path, AllocationPathLen); \
+    \
+    ffStrbufAppendS(path, #_type "/dup"); \
+    item->allocation[index].dup = ffPathExists(path->chars, FF_PATHTYPE_DIRECTORY); \
+    ffStrbufSubstrBefore(path, AllocationPathLen); \
+    \
+    item->allocation[index].type = #_type;
+
+    FF_BTRFS_DETECT_TYPE(0, data);
+    FF_BTRFS_DETECT_TYPE(1, metadata);
+    FF_BTRFS_DETECT_TYPE(2, system);
+
+    #undef FF_BTRFS_DETECT_TYPE
+
+    return NULL;
+}
+
+const char* ffDetectBtrfs(FFlist* result)
+{
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateS("/sys/fs/btrfs/");
+    const uint32_t basePathLen = path.length;
+
+    FF_AUTO_CLOSE_DIR DIR* dirp = opendir(path.chars);
+    if(dirp == NULL)
+        return "opendir(\"/sys/fs/btrfs\") == NULL";
+
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+
+    struct dirent* entry;
+    while ((entry = readdir(dirp)) != NULL)
+    {
+        if (entry->d_name[0] == '.')
+            continue;
+        if (strlen(entry->d_name) != uuidLen)
+            continue;
+
+        FFBtrfsResult* item = ffListAdd(result);
+        (*item) = (FFBtrfsResult){};
+        ffStrbufInitNS(&item->uuid, uuidLen, entry->d_name);
+        ffStrbufInit(&item->name);
+        ffStrbufInit(&item->devices);
+        ffStrbufInit(&item->features);
+
+        ffStrbufAppendNS(&path, uuidLen, entry->d_name);
+        ffStrbufAppendC(&path, '/');
+        const uint32_t itemPathLen = path.length;
+
+        ffStrbufAppendS(&path, "label");
+        if (ffAppendFileBuffer(path.chars, &item->name))
+            ffStrbufTrimRightSpace(&item->name);
+        ffStrbufSubstrBefore(&path, itemPathLen);
+
+        enumerateDevices(item, &path, &buffer);
+        ffStrbufSubstrBefore(&path, itemPathLen);
+
+        enumerateFeatures(item, &path);
+        ffStrbufSubstrBefore(&path, itemPathLen);
+
+        ffStrbufAppendS(&path, "generation");
+        if (ffReadFileBuffer(path.chars, &buffer))
+            item->generation = (uint32_t) ffStrbufToUInt(&buffer, 0);
+        ffStrbufSubstrBefore(&path, itemPathLen);
+
+        ffStrbufAppendS(&path, "nodesize");
+        if (ffReadFileBuffer(path.chars, &buffer))
+            item->nodeSize = (uint32_t) ffStrbufToUInt(&buffer, 0);
+        ffStrbufSubstrBefore(&path, itemPathLen);
+
+        ffStrbufAppendS(&path, "sectorsize");
+        if (ffReadFileBuffer(path.chars, &buffer))
+            item->sectorSize = (uint32_t) ffStrbufToUInt(&buffer, 0);
+        ffStrbufSubstrBefore(&path, itemPathLen);
+
+        detectAllocation(item, &path, &buffer);
+
+        // finally
+        ffStrbufSubstrBefore(&path, basePathLen);
+    }
+
+    return NULL;
+}

src/detection/btrfs/btrfs_nosupport.c

@@ -0,0 +1,6 @@
+#include "btrfs.h"
+
+const char* ffDetectBtrfs(FF_MAYBE_UNUSED FFlist* result)
+{
+    return "Not supported on this platform";
+}

src/detection/camera/camera_linux.c

@@ -43,10 +43,10 @@ const char* ffDetectCamera(FFlist* result)
         case V4L2_COLORSPACE_JPEG: ffStrbufInitStatic(&camera->colorspace, "JPEG"); break;
         case V4L2_COLORSPACE_REC709:
         case V4L2_COLORSPACE_SRGB: ffStrbufInitStatic(&camera->colorspace, "sRGB"); break;
-        case V4L2_COLORSPACE_OPRGB: ffStrbufInitStatic(&camera->colorspace, "Adobe RGB"); break;
-        case V4L2_COLORSPACE_BT2020: ffStrbufInitStatic(&camera->colorspace, "BT.2020"); break;
-        case V4L2_COLORSPACE_RAW: ffStrbufInitStatic(&camera->colorspace, "RAW"); break;
-        case V4L2_COLORSPACE_DCI_P3: ffStrbufInitStatic(&camera->colorspace, "DCI-P3"); break;
+        case 9 /* V4L2_COLORSPACE_OPRGB */: ffStrbufInitStatic(&camera->colorspace, "Adobe RGB"); break;
+        case 10 /* V4L2_COLORSPACE_BT2020 */: ffStrbufInitStatic(&camera->colorspace, "BT.2020"); break;
+        case 11 /* V4L2_COLORSPACE_RAW */: ffStrbufInitStatic(&camera->colorspace, "RAW"); break;
+        case 12 /* V4L2_COLORSPACE_DCI_P3 */: ffStrbufInitStatic(&camera->colorspace, "DCI-P3"); break;
         default: ffStrbufInit(&camera->colorspace); break;
         }
         camera->width = fmt.fmt.pix.width;

src/detection/camera/camera_windows.cpp

@@ -21,9 +21,9 @@ private:
 extern "C"
 const char* ffDetectCamera(FF_MAYBE_UNUSED FFlist* result)
 {
-    FF_LIBRARY_LOAD(mfplat, NULL, "dlopen mfplat" FF_LIBRARY_EXTENSION " failed", "mfplat" FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD(mfplat, "dlopen mfplat" FF_LIBRARY_EXTENSION " failed", "mfplat" FF_LIBRARY_EXTENSION, 1)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(mfplat, MFCreateAttributes)
-    FF_LIBRARY_LOAD(mf, NULL, "dlopen mf" FF_LIBRARY_EXTENSION " failed", "mf" FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD(mf, "dlopen mf" FF_LIBRARY_EXTENSION " failed", "mf" FF_LIBRARY_EXTENSION, 1)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(mf, MFEnumDeviceSources)
 
     const char* error = ffInitCom();

src/detection/cpu/cpu.c

@@ -37,6 +37,19 @@ const char* ffCPUAppleCodeToName(uint32_t code)
         case 6031:
         case 6034: return "Apple M3 Max";
         case 8132: return "Apple M4";
-        default: return "Apple Silicon";
+        default: return NULL;
+    }
+}
+
+const char* ffCPUQualcommCodeToName(uint32_t code)
+{
+    // https://github.com/AsahiLinux/docs/wiki/Codenames
+    switch (code)
+    {
+        case 7180: return "Qualcomm Snapdragon 7c";
+        case 7280: return "Qualcomm Snapdragon 7c+ Gen 3";
+        case 8180: return "Qualcomm Snapdragon 8cx Gen 2 5G";
+        case 8280: return "Qualcomm Snapdragon 8cx Gen 3";
+        default: return NULL;
     }
 }

src/detection/cpu/cpu.h

@@ -30,7 +30,7 @@ typedef struct FFCPUResult
 
 const char* ffDetectCPU(const FFCPUOptions* options, FFCPUResult* cpu);
 const char* ffCPUAppleCodeToName(uint32_t code);
-
+const char* ffCPUQualcommCodeToName(uint32_t code);
 
 #if defined(__x86_64__) || defined(__i386__)
 

src/detection/cpu/cpu_arm.h

@@ -106,6 +106,9 @@ static const char* armPartId2name(uint32_t partId)
     case 0xd80: return "Cortex-A520";
     case 0xd81: return "Cortex-A720";
     case 0xd82: return "Cortex-X4";
+    case 0xd84: return "Neoverse-V3";
+    case 0xd85: return "Cortex-X925";
+    case 0xd87: return "Cortex-A725";
     default: return NULL;
     }
 }

src/detection/cpu/cpu_bsd.c

@@ -9,7 +9,7 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 
     cpu->coresPhysical = (uint16_t) ffSysctlGetInt("hw.ncpu", 1);
     cpu->coresLogical = cpu->coresPhysical;
-    cpu->coresOnline = cpu->coresPhysical;
+    cpu->coresOnline = (uint16_t) ffSysctlGetInt("kern.smp.cpus", cpu->coresLogical);
 
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
     if (ffSysctlGetString("kern.sched.topology_spec", &buffer) == NULL && buffer.length > 0)
@@ -41,39 +41,12 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 
     ffCPUDetectSpeedByCpuid(cpu);
 
-    for (uint16_t i = 0; i < cpu->coresLogical; ++i)
-    {
-        ffStrbufClear(&buffer);
-        char key[32];
-        snprintf(key, sizeof(key), "dev.cpu.%u.freq_levels", i);
-        if (ffSysctlGetString(key, &buffer) == NULL)
-        {
-            if (buffer.length == 0) continue;
-
-            // MHz/Watts pairs like: 2501/32000 2187/27125 2000/24000
-            uint32_t fmax = (uint32_t) strtoul(buffer.chars, NULL, 10);
-            if (cpu->frequencyMax < fmax) cpu->frequencyMax = fmax;
-
-            if (options->showPeCoreCount)
-            {
-                uint32_t ifreq = 0;
-                while (cpu->coreTypes[ifreq].freq != fmax && cpu->coreTypes[ifreq].freq > 0)
-                    ++ifreq;
-                if (cpu->coreTypes[ifreq].freq == 0)
-                    cpu->coreTypes[ifreq].freq = fmax;
-                cpu->coreTypes[ifreq].count++;
-            }
-        }
-        else
-            break;
-    }
-
     cpu->frequencyBase = (uint32_t) ffSysctlGetInt("hw.clockrate", 0);
     cpu->temperature = FF_CPU_TEMP_UNSET;
 
     if (options->temp)
     {
-        if (!ffDetectCpuTemp(&cpu->temperature))
+        if (ffDetectCpuTemp(&cpu->temperature) != NULL)
             ffDetectThermalTemp(&cpu->temperature);
     }
 

src/detection/cpu/cpu_linux.c

@@ -15,6 +15,8 @@
 
 static void detectQualcomm(FFCPUResult* cpu)
 {
+    // https://en.wikipedia.org/wiki/List_of_Qualcomm_Snapdragon_systems_on_chips
+
     if (ffStrbufEqualS(&cpu->name, "SM8635"))
         ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8s Gen 3 [SM8635]");
     else if (ffStrbufEqualS(&cpu->name, "SM8650-AC"))
@@ -32,6 +34,8 @@ static void detectQualcomm(FFCPUResult* cpu)
 
     else if (ffStrbufEqualS(&cpu->name, "SM7675"))
         ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7+ Gen 3 [SM7675]");
+    else if (ffStrbufEqualS(&cpu->name, "SM7635"))
+        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7s Gen 3 [SM7635]");
     else if (ffStrbufEqualS(&cpu->name, "SM7550"))
         ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7 Gen 3 [SM7550]");
     else if (ffStrbufEqualS(&cpu->name, "SM7475"))
@@ -43,6 +47,10 @@ static void detectQualcomm(FFCPUResult* cpu)
 
     else if (ffStrbufEqualS(&cpu->name, "SM6375-AC"))
         ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6s Gen 3 [SM6375-AC]");
+    else if (ffStrbufEqualS(&cpu->name, "SM6475"))
+        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6 Gen 3 [SM6475]");
+    else if (ffStrbufEqualS(&cpu->name, "SM6115"))
+        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6s Gen 1 [SM6115]");
     else if (ffStrbufEqualS(&cpu->name, "SM6450"))
         ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6 Gen 1 [SM6450]");
 
@@ -311,25 +319,51 @@ FF_MAYBE_UNUSED static void parseIsa(FFstrbuf* cpuIsa)
     }
 }
 
-FF_MAYBE_UNUSED static void detectAsahi(FFCPUResult* cpu)
+FF_MAYBE_UNUSED static void detectArmSoc(FFCPUResult* cpu)
 {
-    // In Asahi Linux, reading /proc/device-tree/compatible gives
-    // information on the device model. It consists of 3 NUL terminated
-    // strings, the second of which gives the actual SoC model. But it
-    // is not the marketing name, i.e. for M2 there is "apple,t8112" in
-    // the compatible string.
-    if (cpu->name.length == 0 && ffStrbufEqualS(&cpu->vendor, "Apple"))
-    {
-        char content[32];
-        ssize_t length = ffReadFileData("/proc/device-tree/compatible", sizeof(content), content);
-        if (length <= 0) return;
+    if (cpu->name.length > 0)
+        return;
 
-        // get the second NUL terminated string
-        char* modelName = memchr(content, '\0', (size_t) length) + 1;
-        if (modelName - content < length && ffStrStartsWith(modelName, "apple,t"))
+    // device-vendor,device-model\0soc-vendor,soc-model\0
+    char content[64];
+    ssize_t length = ffReadFileData("/proc/device-tree/compatible", sizeof(content), content);
+    if (length <= 2) return;
+
+    // get the second NUL terminated string
+    char* modelName = memchr(content, '\0', (size_t) length) + 1;
+    if (!modelName || modelName - content >= length) return;
+
+    if (ffStrStartsWith(modelName, "apple,t"))
+    {
+        // https://elixir.bootlin.com/linux/v6.11-rc7/source/arch/arm64/boot/dts/apple
+        const char* code = modelName + strlen("apple,t");
+        uint32_t deviceId = (uint32_t) strtoul(code, NULL, 10);
+        ffStrbufSetStatic(&cpu->name, ffCPUAppleCodeToName(deviceId));
+        if (!cpu->name.length)
         {
-            uint32_t deviceId = (uint32_t) strtoul(modelName + strlen("apple,t"), NULL, 10);
-            ffStrbufSetStatic(&cpu->name, ffCPUAppleCodeToName(deviceId));
+            ffStrbufAppendS(&cpu->name, "Apple Silicon T");
+            ffStrbufAppendS(&cpu->name, code);
+        }
+    }
+    else if (ffStrStartsWith(modelName, "qcom,"))
+    {
+        // https://elixir.bootlin.com/linux/v6.11-rc7/source/arch/arm64/boot/dts/qcom
+        if (ffStrStartsWith(modelName + strlen("qcom,"), "x"))
+        {
+            ffStrbufSetS(&cpu->name, "Qualcomm Snapdragon X Elite ");
+            for (const char* p = modelName + strlen("qcom,"); *p; ++p)
+                ffStrbufAppendC(&cpu->name, (char) toupper(*p));
+        }
+        else if (ffStrStartsWith(modelName + strlen("qcom,"), "sc"))
+        {
+            const char* code = modelName + strlen("qcom,sc");
+            uint32_t deviceId = (uint32_t) strtoul(code, NULL, 10);
+            ffStrbufSetStatic(&cpu->name, ffCPUQualcommCodeToName(deviceId));
+            if (!cpu->name.length)
+            {
+                ffStrbufAppendS(&cpu->name, "Qualcomm Snapdragon SC");
+                ffStrbufAppendS(&cpu->name, code);
+            }
         }
     }
 }
@@ -384,7 +418,7 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
     #if __ANDROID__
     detectAndroid(cpu);
     #elif __aarch64__
-    detectAsahi(cpu);
+    detectArmSoc(cpu);
     #endif
 
     if (cpu->name.length == 0)

src/detection/de/de_linux.c

@@ -121,7 +121,7 @@ static const char* getXfce4ByLib(FFstrbuf* result)
 {
 #ifndef FF_DISABLE_DLOPEN
     const char* xfce_version_string(void); // from `xfce4/libxfce4util/xfce-misutils.h
-    FF_LIBRARY_LOAD(xfce4util, NULL, "dlopen libxfce4util" FF_LIBRARY_EXTENSION "failed", "libxfce4util" FF_LIBRARY_EXTENSION, 7);
+    FF_LIBRARY_LOAD(xfce4util, "dlopen libxfce4util" FF_LIBRARY_EXTENSION "failed", "libxfce4util" FF_LIBRARY_EXTENSION, 7);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xfce4util, xfce_version_string);
     ffStrbufSetS(result, ffxfce_version_string());
     return NULL;

src/detection/disk/disk_windows.c

@@ -6,7 +6,7 @@
 #include <windows.h>
 #include <winioctl.h>
 
-static unsigned __stdcall testRemoteVolumeAccessable(void* mountpoint)
+static unsigned __stdcall testRemoteVolumeAccessible(void* mountpoint)
 {
     FF_AUTO_CLOSE_FD HANDLE handle = CreateFileW(
         (wchar_t*) mountpoint,
@@ -84,7 +84,7 @@ const char* ffDetectDisksImpl(FFDiskOptions* options, FFlist* disks)
         #ifdef FF_HAVE_THREADS
         if (driveType == DRIVE_REMOTE)
         {
-            FFThreadType thread = ffThreadCreate(testRemoteVolumeAccessable, mountpoint);
+            FFThreadType thread = ffThreadCreate(testRemoteVolumeAccessible, mountpoint);
             if (!ffThreadJoin(thread, 500))
                 continue;
         }

src/detection/displayserver/linux/displayserver_linux.h

@@ -9,13 +9,13 @@ bool ffdsMatchDrmConnector(const char* connName, FFstrbuf* edidName);
 
 const char* ffdsConnectWayland(FFDisplayServerResult* result);
 
-void ffdsConnectXcbRandr(FFDisplayServerResult* result);
-void ffdsConnectXcb(FFDisplayServerResult* result);
+const char* ffdsConnectXcbRandr(FFDisplayServerResult* result);
+const char* ffdsConnectXcb(FFDisplayServerResult* result);
 
-void ffdsConnectXrandr(FFDisplayServerResult* result);
-void ffdsConnectXlib(FFDisplayServerResult* result);
+const char* ffdsConnectXrandr(FFDisplayServerResult* result);
+const char* ffdsConnectXlib(FFDisplayServerResult* result);
 
-void ffdsConnectDrm(FFDisplayServerResult* result);
+const char* ffdsConnectDrm(FFDisplayServerResult* result);
 
 void ffdsDetectWMDE(FFDisplayServerResult* result);
 

src/detection/displayserver/linux/drm.c

@@ -199,7 +199,7 @@ static const char* drmGetNameByConnId(uint32_t connId, FFstrbuf* name)
 
 static const char* drmConnectLibdrm(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(libdrm, &instance.config.library.libdrm, "dlopen libdrm" FF_LIBRARY_EXTENSION " failed", "libdrm" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(libdrm, "dlopen libdrm" FF_LIBRARY_EXTENSION " failed", "libdrm" FF_LIBRARY_EXTENSION, 2)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libdrm, drmGetDevices)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libdrm, drmModeGetResources)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libdrm, drmModeGetConnectorCurrent)
@@ -376,17 +376,19 @@ static const char* drmConnectLibdrm(FFDisplayServerResult* result)
 
 #endif
 
-void ffdsConnectDrm(FFDisplayServerResult* result)
+const char* ffdsConnectDrm(FFDisplayServerResult* result)
 {
     #ifdef FF_HAVE_DRM
     if (instance.config.general.dsForceDrm != FF_DS_FORCE_DRM_TYPE_SYSFS_ONLY)
     {
         if (drmConnectLibdrm(result) == NULL)
-            return;
+            return NULL;
     }
     #endif
 
     #ifdef __linux__
-    drmParseSysfs(result);
+    return drmParseSysfs(result);
     #endif
+
+    return "fastfetch was compiled without drm support";
 }

src/detection/displayserver/linux/wayland/wayland.c

@@ -150,7 +150,7 @@ const char* ffdsConnectWayland(FFDisplayServerResult* result)
     if (getenv("XDG_RUNTIME_DIR") == NULL)
         return "Wayland requires $XDG_RUNTIME_DIR being set";
 
-    FF_LIBRARY_LOAD(wayland, &instance.config.library.libWayland, false, "libwayland-client" FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD(wayland, false, "libwayland-client" FF_LIBRARY_EXTENSION, 1)
 
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(wayland, wl_display_connect)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(wayland, wl_display_get_fd)

src/detection/displayserver/linux/xcb.c

@@ -82,21 +82,21 @@ static void xcbDetectWMfromEWMH(XcbPropertyData* data, xcb_connection_t* connect
     ffStrbufSetS(&result->wmProcessName, wmName);
 }
 
-void ffdsConnectXcb(FFDisplayServerResult* result)
+const char* ffdsConnectXcb(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcb, &instance.config.library.libXcb, , "libxcb" FF_LIBRARY_EXTENSION, 2)
-    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_connect,)
-    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_get_setup,)
-    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_setup_roots_iterator,)
-    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_screen_next,)
-    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_disconnect,)
+    FF_LIBRARY_LOAD(xcb, "dlopen lbxcb failed", "libxcb" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcb, xcb_connect)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcb, xcb_get_setup)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcb, xcb_setup_roots_iterator)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcb, xcb_screen_next)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcb, xcb_disconnect)
 
     XcbPropertyData propertyData;
     bool propertyDataInitialized = xcbInitPropertyData(xcb, &propertyData);
 
     xcb_connection_t* connection = ffxcb_connect(NULL, NULL);
     if(connection == NULL)
-        return;
+        return "xcb_connect failed";
 
     xcb_screen_iterator_t iterator = ffxcb_setup_roots_iterator(ffxcb_get_setup(connection));
 
@@ -128,14 +128,17 @@ void ffdsConnectXcb(FFDisplayServerResult* result)
     //If wayland hasn't set this, connection failed for it. So we are running only a X Server, not XWayland.
     if(result->wmProtocolName.length == 0)
         ffStrbufSetS(&result->wmProtocolName, FF_WM_PROTOCOL_X11);
+
+    return NULL;
 }
 
 #else
 
-void ffdsConnectXcb(FFDisplayServerResult* result)
+const char* ffdsConnectXcb(FFDisplayServerResult* result)
 {
     //Do nothing. There are other implementations coming
     FF_UNUSED(result)
+    return "Fastfetch was compiled without XCB support";
 }
 
 #endif
@@ -388,45 +391,45 @@ static void xcbRandrHandleScreen(XcbRandrData* data, xcb_screen_t* screen)
     );
 }
 
-void ffdsConnectXcbRandr(FFDisplayServerResult* result)
+const char* ffdsConnectXcbRandr(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcbRandr, &instance.config.library.libXcbRandr, , "libxcb-randr" FF_LIBRARY_EXTENSION, 1)
-    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_connect,)
-    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_get_setup,)
-    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_setup_roots_iterator,)
-    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_screen_next,)
-    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_disconnect,)
+    FF_LIBRARY_LOAD(xcbRandr, "dlopen lbxcb-randr failed", "libxcb-randr" FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcbRandr, xcb_connect)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcbRandr, xcb_get_setup)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcbRandr, xcb_setup_roots_iterator)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcbRandr, xcb_screen_next)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xcbRandr, xcb_disconnect)
 
     XcbRandrData data;
 
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_intern_atom,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_intern_atom_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_resources_current,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_resources_current_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_resources_current_modes_iterator,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_mode_info_next,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_monitors,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_monitors_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_monitors_monitors_iterator,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_monitor_info_next,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_monitor_info_outputs_length,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_monitor_info_outputs,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_output_next,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_info,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_info_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_property,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_property_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_property_data,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_property_data_length,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_crtc_info,)
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_crtc_info_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_intern_atom)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_intern_atom_reply)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_screen_resources_current)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_screen_resources_current_reply)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_screen_resources_current_modes_iterator)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_mode_info_next)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_monitors)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_monitors_reply)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_monitors_monitors_iterator)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_monitor_info_next)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_monitor_info_outputs_length)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_monitor_info_outputs)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_output_next)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_output_info)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_output_info_reply)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_output_property)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_output_property_reply)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_output_property_data)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_output_property_data_length)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_crtc_info)
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xcbRandr, data, xcb_randr_get_crtc_info_reply)
 
     bool propertyDataInitialized = xcbInitPropertyData(xcbRandr, &data.propData);
 
 
     data.connection = ffxcb_connect(NULL, NULL);
     if(data.connection == NULL)
-        return;
+        return "xcb_connect failed";
 
 
     data.result = result;
@@ -450,14 +453,17 @@ void ffdsConnectXcbRandr(FFDisplayServerResult* result)
     //If wayland hasn't set this, connection failed for it. So we are running only a X Server, not XWayland.
     if(result->wmProtocolName.length == 0)
         ffStrbufSetS(&result->wmProtocolName, FF_WM_PROTOCOL_X11);
+
+    return NULL;
 }
 
 #else
 
-void ffdsConnectXcbRandr(FFDisplayServerResult* result)
+const char* ffdsConnectXcbRandr(FFDisplayServerResult* result)
 {
     //Do nothing. There are other implementations coming
     FF_UNUSED(result)
+    return "Fastfetch was compiled without libxcb-randr support";
 }
 
 #endif

src/detection/displayserver/linux/xlib.c

@@ -58,18 +58,18 @@ static void x11DetectWMFromEWMH(X11PropertyData* data, Display* display, FFDispl
     data->ffXFree(wmWindow);
 }
 
-void ffdsConnectXlib(FFDisplayServerResult* result)
+const char* ffdsConnectXlib(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(x11, &instance.config.library.libX11, , "libX11" FF_LIBRARY_EXTENSION, 7, "libX11-xcb" FF_LIBRARY_EXTENSION, 2)
-    FF_LIBRARY_LOAD_SYMBOL(x11, XOpenDisplay,)
-    FF_LIBRARY_LOAD_SYMBOL(x11, XCloseDisplay,)
+    FF_LIBRARY_LOAD(x11, "dlopen libX11 failed", "libX11" FF_LIBRARY_EXTENSION, 7, "libX11-xcb" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(x11, XOpenDisplay)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(x11, XCloseDisplay)
 
     X11PropertyData propertyData;
     bool propertyDataInitialized = x11InitPropertyData(x11, &propertyData);
 
     Display* display = ffXOpenDisplay(x11);
     if(display == NULL)
-        return;
+        return "XOpenDisplay failed";
 
     if(propertyDataInitialized && ScreenCount(display) > 0)
         x11DetectWMFromEWMH(&propertyData, display, result);
@@ -98,14 +98,17 @@ void ffdsConnectXlib(FFDisplayServerResult* result)
     //If wayland hasn't set this, connection failed for it. So we are running only a X Server, not XWayland.
     if(result->wmProtocolName.length == 0)
         ffStrbufSetS(&result->wmProtocolName, FF_WM_PROTOCOL_X11);
+
+    return NULL;
 }
 
 #else
 
-void ffdsConnectXlib(FFDisplayServerResult* result)
+const char* ffdsConnectXlib(FFDisplayServerResult* result)
 {
     //Do nothing. WM / DE detection will use environment vars to detect as much as possible.
     FF_UNUSED(result);
+    return "Fastfetch was compiled without libX11 support";
 }
 
 #endif //FF_HAVE_X11
@@ -308,34 +311,34 @@ static void xrandrHandleScreen(XrandrData* data, Screen* screen)
     );
 }
 
-void ffdsConnectXrandr(FFDisplayServerResult* result)
+const char* ffdsConnectXrandr(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xrandr, &instance.config.library.libXrandr, , "libXrandr" FF_LIBRARY_EXTENSION, 3)
+    FF_LIBRARY_LOAD(xrandr, "dlopen libXrandr failed", "libXrandr" FF_LIBRARY_EXTENSION, 3)
 
-    FF_LIBRARY_LOAD_SYMBOL(xrandr, XOpenDisplay,)
-    FF_LIBRARY_LOAD_SYMBOL(xrandr, XCloseDisplay,)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xrandr, XOpenDisplay)
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xrandr, XCloseDisplay)
 
     XrandrData data;
 
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XInternAtom,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XGetAtomName,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XFree,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetMonitors,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetScreenResourcesCurrent,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetOutputInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetOutputProperty,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetCrtcInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeCrtcInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeOutputInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeScreenResources,);
-    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeMonitors,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XInternAtom);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XGetAtomName);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XFree);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRGetMonitors);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRGetScreenResourcesCurrent);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRGetOutputInfo);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRGetOutputProperty);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRGetCrtcInfo);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRFreeCrtcInfo);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRFreeOutputInfo);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRFreeScreenResources);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(xrandr, data, XRRFreeMonitors);
 
     X11PropertyData propertyData;
     bool propertyDataInitialized = x11InitPropertyData(xrandr, &propertyData);
 
     data.display = ffXOpenDisplay(NULL);
     if(data.display == NULL)
-        return;
+        return "XOpenDisplay() failed";
 
     if(propertyDataInitialized && ScreenCount(data.display) > 0)
         x11DetectWMFromEWMH(&propertyData, data.display, result);
@@ -350,14 +353,17 @@ void ffdsConnectXrandr(FFDisplayServerResult* result)
     //If wayland hasn't set this, connection failed for it. So we are running only a X Server, not XWayland.
     if(result->wmProtocolName.length == 0)
         ffStrbufSetS(&result->wmProtocolName, FF_WM_PROTOCOL_X11);
+
+    return NULL;
 }
 
 #else
 
-void ffdsConnectXrandr(FFDisplayServerResult* result)
+const char* ffdsConnectXrandr(FFDisplayServerResult* result)
 {
     //Do nothing here. There are more x11 implementations to come.
     FF_UNUSED(result);
+    return "Fastfetch was compiled without libXrandr support";
 }
 
 #endif // FF_HAVE_XRANDR

src/detection/gpu/gpu_amd.c

@@ -17,7 +17,7 @@ const char* ffDetectAmdGpuInfo(const FFGpuDriverCondition* cond, FFGpuDriverResu
     if (!inited)
     {
         inited = true;
-        FF_LIBRARY_LOAD(libags, NULL, "dlopen amd_ags failed", soName , 1);
+        FF_LIBRARY_LOAD(libags, "dlopen amd_ags failed", soName , 1);
         FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libags, agsInitialize)
 
         struct AGSContext* apiHandle;

src/detection/gpu/gpu_intel.c

@@ -34,7 +34,7 @@ const char* ffDetectIntelGpuInfo(const FFGpuDriverCondition* cond, FFGpuDriverRe
     if (!igclData.inited)
     {
         igclData.inited = true;
-        FF_LIBRARY_LOAD(libigcl, NULL, "dlopen igcl (ControlLib) failed", soName , 1);
+        FF_LIBRARY_LOAD(libigcl, "dlopen igcl (ControlLib) failed", soName , 1);
         FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libigcl, ctlInit)
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libigcl, igclData, ctlClose)
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libigcl, igclData, ctlEnumerateDevices)

src/detection/gpu/gpu_linux.c

@@ -407,6 +407,8 @@ FF_MAYBE_UNUSED static const char* detectAsahi(FFlist* gpus, FFstrbuf* buffer, F
     FFGPUResult* gpu = (FFGPUResult*)ffListAdd(gpus);
     gpu->deviceId = strtoul(buffer->chars + index, NULL, 10);
     ffStrbufInitStatic(&gpu->name, ffCPUAppleCodeToName((uint32_t) gpu->deviceId));
+    if (!gpu->name.length)
+        ffStrbufAppendF(&gpu->name, "Apple Silicon T%u", (uint32_t) gpu->deviceId);
     ffStrbufInitStatic(&gpu->vendor, FF_GPU_VENDOR_NAME_APPLE);
     ffStrbufInit(&gpu->driver);
     ffStrbufInitF(&gpu->platformApi, "DRM (%s)", drmKey);

src/detection/gpu/gpu_mthreads.c

@@ -5,6 +5,7 @@
 
 struct FFMtmlData
 {
+    FF_LIBRARY_SYMBOL(mtmlDeviceCountGpuCores)
     FF_LIBRARY_SYMBOL(mtmlDeviceGetBrand)
     FF_LIBRARY_SYMBOL(mtmlDeviceGetIndex)
     FF_LIBRARY_SYMBOL(mtmlDeviceGetName)
@@ -41,8 +42,9 @@ const char *ffDetectMthreadsGpuInfo(const FFGpuDriverCondition *cond, FFGpuDrive
     if (!mtmlData.inited)
     {
         mtmlData.inited = true;
-        FF_LIBRARY_LOAD(libmtml, NULL, "dlopen mtml failed", soName, 1);
+        FF_LIBRARY_LOAD(libmtml, "dlopen mtml failed", soName, 1);
         FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libmtml, mtmlLibraryInit)
+        FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libmtml, mtmlData, mtmlDeviceCountGpuCores)
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libmtml, mtmlData, mtmlDeviceGetBrand)
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libmtml, mtmlData, mtmlDeviceGetIndex)
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libmtml, mtmlData, mtmlDeviceGetName)
@@ -158,6 +160,9 @@ const char *ffDetectMthreadsGpuInfo(const FFGpuDriverCondition *cond, FFGpuDrive
         }
     }
 
+    if (result.coreCount)
+        mtmlData.ffmtmlDeviceCountGpuCores(device, result.coreCount);
+
     if (result.frequency)
     {
         MtmlGpu *gpu = NULL;

src/detection/gpu/gpu_nvidia.c

@@ -26,7 +26,7 @@ const char* ffDetectNvidiaGpuInfo(const FFGpuDriverCondition* cond, FFGpuDriverR
     if (!nvmlData.inited)
     {
         nvmlData.inited = true;
-        FF_LIBRARY_LOAD(libnvml, NULL, "dlopen nvml failed", soName , 1);
+        FF_LIBRARY_LOAD(libnvml, "dlopen nvml failed", soName , 1);
         FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libnvml, nvmlInit_v2)
         FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libnvml, nvmlShutdown)
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libnvml, nvmlData, nvmlDeviceGetCount_v2)

src/detection/gpu/gpu_wsl.cpp

@@ -28,7 +28,7 @@ private:
 extern "C"
 const char* ffGPUDetectByDirectX(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist* gpus)
 {
-    FF_LIBRARY_LOAD(libdxcore, nullptr, "dlopen libdxcore.so failed", "/usr/lib/wsl/lib/libdxcore" FF_LIBRARY_EXTENSION, 4)
+    FF_LIBRARY_LOAD(libdxcore, "dlopen libdxcore.so failed", "/usr/lib/wsl/lib/libdxcore" FF_LIBRARY_EXTENSION, 4)
     // DXCoreCreateAdapterFactory is a reloaded function, so we can't use FF_LIBRARY_LOAD_SYMBOL_MESSAGE here
     typedef HRESULT (*DXCoreCreateAdapterFactory_t)(REFIID riid, void** ppvFactory);
 

src/detection/gpu/mtml.h

@@ -56,6 +56,8 @@ typedef struct
     int rsvd[6];                                 //!< Reserved for future extension.
 } MtmlPciInfo;
 
+// Retrieves the number of cores of a device.
+MtmlReturn MTML_API mtmlDeviceCountGpuCores(const MtmlDevice* device, unsigned int* numCores);
 // Retrieves the brand of a device.
 MtmlReturn MTML_API mtmlDeviceGetBrand(const MtmlDevice *dev, MtmlBrandType *type);
 // Retrieves the index associated with the specified device.

src/detection/initsystem/initsystem_linux.c

@@ -3,6 +3,7 @@
 #include "util/binary.h"
 #include "util/stringUtils.h"
 
+#include <libgen.h>
 #include <unistd.h>
 
 FF_MAYBE_UNUSED static bool extractSystemdVersion(const char* str, uint32_t len, void* userdata)
@@ -39,7 +40,10 @@ const char* ffDetectInitSystem(FFInitSystemResult* result)
         // In some old system, /sbin/init is a symlink
         char buf[PATH_MAX];
         if (realpath(result->exe.chars, buf))
+        {
             ffStrbufSetS(&result->exe, buf);
+            ffStrbufSetS(&result->name, basename(result->exe.chars));
+        }
     }
 
     if (instance.config.general.detectVersion)
@@ -66,6 +70,20 @@ const char* ffDetectInitSystem(FFInitSystemResult* result)
                 }
             }
         }
+        else if (ffStrbufEqualS(&result->name, "dinit"))
+        {
+            if (ffProcessAppendStdOut(&result->version, (char* const[]) {
+                ffStrbufEndsWithS(&result->exe, "/dinit") ? result->exe.chars : "dinit",
+                "--version",
+                NULL,
+            }) == NULL && result->version.length)
+            {
+                // Dinit version 0.18.0.
+                ffStrbufSubstrBeforeFirstC(&result->version, '\n');
+                ffStrbufTrimRight(&result->version, '.');
+                ffStrbufSubstrAfterLastC(&result->version, ' ');
+            }
+        }
         #elif __APPLE__
         if (ffStrbufEqualS(&result->name, "launchd"))
         {

src/detection/lm/lm_linux.c

@@ -54,7 +54,7 @@ static const char* getSshdVersion(FFstrbuf* version)
 
 static const char* getSddmVersion(FFstrbuf* version)
 {
-    FF_LIBRARY_LOAD(zlib, &instance.config.library.libZ, "dlopen libz failed", "libz" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(zlib, "dlopen libz failed", "libz" FF_LIBRARY_EXTENSION, 2)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(zlib, gzopen)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(zlib, gzread)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(zlib, gzerror)

src/detection/localip/localip_linux.c

@@ -172,403 +172,416 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
 
     if (ifAddrStruct) freeifaddrs(ifAddrStruct);
 
-    FF_AUTO_CLOSE_FD int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
-    if (sockfd > 0)
+    if ((options->showType & FF_LOCALIP_TYPE_MTU_BIT) || (options->showType & FF_LOCALIP_TYPE_SPEED_BIT)
+        #ifdef __sun
+        || (options->showType & FF_LOCALIP_TYPE_MAC_BIT)
+        #endif
+    )
     {
-        FF_LIST_FOR_EACH(FFLocalIpResult, iface, *results)
+        FF_AUTO_CLOSE_FD int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+        if (sockfd > 0)
         {
-            struct ifreq ifr;
-            strncpy(ifr.ifr_name, iface->name.chars, IFNAMSIZ - 1);
-
-            if (ioctl(sockfd, SIOCGIFMTU, &ifr) == 0)
-                iface->mtu = (int32_t) ifr.ifr_mtu;
-
-            #ifdef __linux__
-            struct ethtool_cmd edata = { .cmd = ETHTOOL_GSET };
-            ifr.ifr_data = (void*) &edata;
-            if (ioctl(sockfd, SIOCETHTOOL, &ifr) == 0)
-                iface->speed = (edata.speed_hi << 16) | edata.speed; // ethtool_cmd_speed is not available on Android
-            #elif __FreeBSD__ || __APPLE__
-            struct ifmediareq ifmr = {};
-            strncpy(ifmr.ifm_name, iface->name.chars, IFNAMSIZ - 1);
-            if (ioctl(sockfd, SIOCGIFMEDIA, &ifmr) == 0)
+            FF_LIST_FOR_EACH(FFLocalIpResult, iface, *results)
             {
-                switch (IFM_SUBTYPE(ifmr.ifm_active))
+                struct ifreq ifr;
+                strncpy(ifr.ifr_name, iface->name.chars, IFNAMSIZ - 1);
+
+                if (options->showType & FF_LOCALIP_TYPE_MTU_BIT)
                 {
-                #ifdef IFM_HPNA_1
-                case IFM_HPNA_1:
-                #endif
-                    iface->speed = 1; break;
-                #ifdef IFM_1000_CX
-                case IFM_1000_CX:
-                #endif
-                #ifdef IFM_1000_CX_SGMII
-                case IFM_1000_CX_SGMII:
-                #endif
-                #ifdef IFM_1000_KX
-                case IFM_1000_KX:
-                #endif
-                #ifdef IFM_1000_LX
-                case IFM_1000_LX:
-                #endif
-                #ifdef IFM_1000_SGMII
-                case IFM_1000_SGMII:
-                #endif
-                #ifdef IFM_1000_SX
-                case IFM_1000_SX:
-                #endif
-                #ifdef IFM_1000_T
-                case IFM_1000_T:
-                #endif
-                    iface->speed = 1000; break;
-                #ifdef IFM_100G_AUI2
-                case IFM_100G_AUI2:
-                #endif
-                #ifdef IFM_100G_AUI2_AC
-                case IFM_100G_AUI2_AC:
-                #endif
-                #ifdef IFM_100G_AUI4
-                case IFM_100G_AUI4:
-                #endif
-                #ifdef IFM_100G_AUI4_AC
-                case IFM_100G_AUI4_AC:
-                #endif
-                #ifdef IFM_100G_CAUI2
-                case IFM_100G_CAUI2:
-                #endif
-                #ifdef IFM_100G_CAUI2_AC
-                case IFM_100G_CAUI2_AC:
-                #endif
-                #ifdef IFM_100G_CAUI4
-                case IFM_100G_CAUI4:
-                #endif
-                #ifdef IFM_100G_CAUI4_AC
-                case IFM_100G_CAUI4_AC:
-                #endif
-                #ifdef IFM_100G_CP2
-                case IFM_100G_CP2:
-                #endif
-                #ifdef IFM_100G_CR4
-                case IFM_100G_CR4:
-                #endif
-                #ifdef IFM_100G_CR_PAM4
-                case IFM_100G_CR_PAM4:
-                #endif
-                #ifdef IFM_100G_DR
-                case IFM_100G_DR:
-                #endif
-                #ifdef IFM_100G_KR2_PAM4
-                case IFM_100G_KR2_PAM4:
-                #endif
-                #ifdef IFM_100G_KR4
-                case IFM_100G_KR4:
-                #endif
-                #ifdef IFM_100G_KR_PAM4
-                case IFM_100G_KR_PAM4:
-                #endif
-                #ifdef IFM_100G_LR4
-                case IFM_100G_LR4:
-                #endif
-                #ifdef IFM_100G_SR2
-                case IFM_100G_SR2:
-                #endif
-                #ifdef IFM_100G_SR4
-                case IFM_100G_SR4:
-                #endif
-                    iface->speed = 100000; break;
-                #ifdef IFM_100_FX
-                case IFM_100_FX:
-                #endif
-                #ifdef IFM_100_SGMII
-                case IFM_100_SGMII:
-                #endif
-                #ifdef IFM_100_T
-                case IFM_100_T:
-                #endif
-                #ifdef IFM_100_T2
-                case IFM_100_T2:
-                #endif
-                #ifdef IFM_100_T4
-                case IFM_100_T4:
-                #endif
-                #ifdef IFM_100_TX
-                case IFM_100_TX:
-                #endif
-                #ifdef IFM_100_VG
-                case IFM_100_VG:
-                #endif
-                    iface->speed = 100; break;
-                #ifdef IFM_10G_AOC
-                case IFM_10G_AOC:
-                #endif
-                #ifdef IFM_10G_CR1
-                case IFM_10G_CR1:
-                #endif
-                #ifdef IFM_10G_CX4
-                case IFM_10G_CX4:
-                #endif
-                #ifdef IFM_10G_ER
-                case IFM_10G_ER:
-                #endif
-                #ifdef IFM_10G_KR
-                case IFM_10G_KR:
-                #endif
-                #ifdef IFM_10G_KX4
-                case IFM_10G_KX4:
-                #endif
-                #ifdef IFM_10G_LR
-                case IFM_10G_LR:
-                #endif
-                #ifdef IFM_10G_LRM
-                case IFM_10G_LRM:
-                #endif
-                #ifdef IFM_10G_SFI
-                case IFM_10G_SFI:
-                #endif
-                #ifdef IFM_10G_SR
-                case IFM_10G_SR:
-                #endif
-                #ifdef IFM_10G_T
-                case IFM_10G_T:
-                #endif
-                #ifdef IFM_10G_TWINAX
-                case IFM_10G_TWINAX:
-                #endif
-                #ifdef IFM_10G_TWINAX_LONG
-                case IFM_10G_TWINAX_LONG:
-                #endif
-                    iface->speed = 10000; break;
-                #ifdef IFM_10_2
-                case IFM_10_2:
-                #endif
-                #ifdef IFM_10_5
-                case IFM_10_5:
-                #endif
-                #ifdef IFM_10_FL
-                case IFM_10_FL:
-                #endif
-                #ifdef IFM_10_STP
-                case IFM_10_STP:
-                #endif
-                #ifdef IFM_10_T
-                case IFM_10_T:
-                #endif
-                    iface->speed = 10; break;
-                #ifdef IFM_200G_AUI4
-                case IFM_200G_AUI4:
-                #endif
-                #ifdef IFM_200G_AUI4_AC
-                case IFM_200G_AUI4_AC:
-                #endif
-                #ifdef IFM_200G_AUI8
-                case IFM_200G_AUI8:
-                #endif
-                #ifdef IFM_200G_AUI8_AC
-                case IFM_200G_AUI8_AC:
-                #endif
-                #ifdef IFM_200G_CR4_PAM4
-                case IFM_200G_CR4_PAM4:
-                #endif
-                #ifdef IFM_200G_DR4
-                case IFM_200G_DR4:
-                #endif
-                #ifdef IFM_200G_FR4
-                case IFM_200G_FR4:
-                #endif
-                #ifdef IFM_200G_KR4_PAM4
-                case IFM_200G_KR4_PAM4:
-                #endif
-                #ifdef IFM_200G_LR4
-                case IFM_200G_LR4:
-                #endif
-                #ifdef IFM_200G_SR4
-                case IFM_200G_SR4:
-                #endif
-                    iface->speed = 200000; break;
-                #ifdef IFM_20G_KR2
-                case IFM_20G_KR2:
-                #endif
-                    iface->speed = 20000; break;
-                #ifdef IFM_2500_KX
-                case IFM_2500_KX:
-                #endif
-                #ifdef IFM_2500_SX
-                case IFM_2500_SX:
-                #endif
-                #ifdef IFM_2500_T
-                case IFM_2500_T:
-                #endif
-                #ifdef IFM_2500_X
-                case IFM_2500_X:
-                #endif
-                    iface->speed = 2500; break;
-                #ifdef IFM_25G_ACC
-                case IFM_25G_ACC:
-                #endif
-                #ifdef IFM_25G_AOC
-                case IFM_25G_AOC:
-                #endif
-                #ifdef IFM_25G_AUI
-                case IFM_25G_AUI:
-                #endif
-                #ifdef IFM_25G_CR
-                case IFM_25G_CR:
-                #endif
-                #ifdef IFM_25G_CR1
-                case IFM_25G_CR1:
-                #endif
-                #ifdef IFM_25G_CR_S
-                case IFM_25G_CR_S:
-                #endif
-                #ifdef IFM_25G_KR
-                case IFM_25G_KR:
-                #endif
-                #ifdef IFM_25G_KR1
-                case IFM_25G_KR1:
-                #endif
-                #ifdef IFM_25G_KR_S
-                case IFM_25G_KR_S:
-                #endif
-                #ifdef IFM_25G_LR
-                case IFM_25G_LR:
-                #endif
-                #ifdef IFM_25G_PCIE
-                case IFM_25G_PCIE:
-                #endif
-                #ifdef IFM_25G_SR
-                case IFM_25G_SR:
-                #endif
-                #ifdef IFM_25G_T
-                case IFM_25G_T:
-                #endif
-                    iface->speed = 25000; break;
-                #ifdef IFM_400G_AUI8
-                case IFM_400G_AUI8:
-                #endif
-                #ifdef IFM_400G_AUI8_AC
-                case IFM_400G_AUI8_AC:
-                #endif
-                #ifdef IFM_400G_DR4
-                case IFM_400G_DR4:
-                #endif
-                #ifdef IFM_400G_FR8
-                case IFM_400G_FR8:
-                #endif
-                #ifdef IFM_400G_LR8
-                case IFM_400G_LR8:
-                #endif
-                    iface->speed = 400000; break;
-                #ifdef IFM_40G_CR4
-                case IFM_40G_CR4:
-                #endif
-                #ifdef IFM_40G_ER4
-                case IFM_40G_ER4:
-                #endif
-                #ifdef IFM_40G_KR4
-                case IFM_40G_KR4:
-                #endif
-                #ifdef IFM_40G_LR4
-                case IFM_40G_LR4:
-                #endif
-                #ifdef IFM_40G_SR4
-                case IFM_40G_SR4:
-                #endif
-                #ifdef IFM_40G_XLAUI
-                case IFM_40G_XLAUI:
-                #endif
-                #ifdef IFM_40G_XLAUI_AC
-                case IFM_40G_XLAUI_AC:
-                #endif
-                #ifdef IFM_40G_XLPPI
-                case IFM_40G_XLPPI:
-                #endif
-                #ifdef IFM_40G_LM4
-                case IFM_40G_LM4:
-                #endif
-                    iface->speed = 40000; break;
-                #ifdef IFM_5000_KR
-                case IFM_5000_KR:
-                #endif
-                #ifdef IFM_5000_KR1
-                case IFM_5000_KR1:
-                #endif
-                #ifdef IFM_5000_KR_S
-                case IFM_5000_KR_S:
-                #endif
-                #ifdef IFM_5000_T
-                case IFM_5000_T:
-                #endif
-                    iface->speed = 5000; break;
-                #ifdef IFM_50G_AUI1
-                case IFM_50G_AUI1:
-                #endif
-                #ifdef IFM_50G_AUI1_AC
-                case IFM_50G_AUI1_AC:
-                #endif
-                #ifdef IFM_50G_AUI2
-                case IFM_50G_AUI2:
-                #endif
-                #ifdef IFM_50G_AUI2_AC
-                case IFM_50G_AUI2_AC:
-                #endif
-                #ifdef IFM_50G_CP
-                case IFM_50G_CP:
-                #endif
-                #ifdef IFM_50G_CR2
-                case IFM_50G_CR2:
-                #endif
-                #ifdef IFM_50G_FR
-                case IFM_50G_FR:
-                #endif
-                #ifdef IFM_50G_KR2
-                case IFM_50G_KR2:
-                #endif
-                #ifdef IFM_50G_KR_PAM4
-                case IFM_50G_KR_PAM4:
-                #endif
-                #ifdef IFM_50G_LAUI2
-                case IFM_50G_LAUI2:
-                #endif
-                #ifdef IFM_50G_LAUI2_AC
-                case IFM_50G_LAUI2_AC:
-                #endif
-                #ifdef IFM_50G_LR
-                case IFM_50G_LR:
-                #endif
-                #ifdef IFM_50G_LR2
-                case IFM_50G_LR2:
-                #endif
-                #ifdef IFM_50G_PCIE
-                case IFM_50G_PCIE:
-                #endif
-                #ifdef IFM_50G_SR
-                case IFM_50G_SR:
-                #endif
-                #ifdef IFM_50G_SR2
-                case IFM_50G_SR2:
-                #endif
-                #ifdef IFM_50G_KR4
-                case IFM_50G_KR4:
-                #endif
-                    iface->speed = 50000; break;
-                #ifdef IFM_56G_R4
-                case IFM_56G_R4:
-                #endif
-                    iface->speed = 56000; break;
-                default:
-                    iface->speed = -1;
+                    if (ioctl(sockfd, SIOCGIFMTU, &ifr) == 0)
+                        iface->mtu = (int32_t) ifr.ifr_mtu;
                 }
-            }
-            #endif
 
-            #ifdef __sun
-            if ((options->showType & FF_LOCALIP_TYPE_MAC_BIT) && ioctl(sockfd, SIOCGIFHWADDR, &ifr) == 0)
-            {
-                const uint8_t* ptr = (uint8_t*) ifr.ifr_addr.sa_data; // NOT ifr_enaddr
-                ffStrbufSetF(&iface->mac, "%02x:%02x:%02x:%02x:%02x:%02x",
-                             ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
+                if (options->showType & FF_LOCALIP_TYPE_SPEED_BIT)
+                {
+                    #ifdef __linux__
+                    struct ethtool_cmd edata = { .cmd = ETHTOOL_GSET };
+                    ifr.ifr_data = (void*) &edata;
+                    if (ioctl(sockfd, SIOCETHTOOL, &ifr) == 0)
+                        iface->speed = (edata.speed_hi << 16) | edata.speed; // ethtool_cmd_speed is not available on Android
+                    #elif __FreeBSD__ || __APPLE__
+                    struct ifmediareq ifmr = {};
+                    strncpy(ifmr.ifm_name, iface->name.chars, IFNAMSIZ - 1);
+                    if (ioctl(sockfd, SIOCGIFMEDIA, &ifmr) == 0 && (IFM_TYPE(ifmr.ifm_active) & IFM_ETHER))
+                    {
+                        switch (IFM_SUBTYPE(ifmr.ifm_active))
+                        {
+                        #ifdef IFM_HPNA_1
+                        case IFM_HPNA_1:
+                        #endif
+                            iface->speed = 1; break;
+                        #ifdef IFM_1000_CX
+                        case IFM_1000_CX:
+                        #endif
+                        #ifdef IFM_1000_CX_SGMII
+                        case IFM_1000_CX_SGMII:
+                        #endif
+                        #ifdef IFM_1000_KX
+                        case IFM_1000_KX:
+                        #endif
+                        #ifdef IFM_1000_LX
+                        case IFM_1000_LX:
+                        #endif
+                        #ifdef IFM_1000_SGMII
+                        case IFM_1000_SGMII:
+                        #endif
+                        #ifdef IFM_1000_SX
+                        case IFM_1000_SX:
+                        #endif
+                        #ifdef IFM_1000_T
+                        case IFM_1000_T:
+                        #endif
+                            iface->speed = 1000; break;
+                        #ifdef IFM_100G_AUI2
+                        case IFM_100G_AUI2:
+                        #endif
+                        #ifdef IFM_100G_AUI2_AC
+                        case IFM_100G_AUI2_AC:
+                        #endif
+                        #ifdef IFM_100G_AUI4
+                        case IFM_100G_AUI4:
+                        #endif
+                        #ifdef IFM_100G_AUI4_AC
+                        case IFM_100G_AUI4_AC:
+                        #endif
+                        #ifdef IFM_100G_CAUI2
+                        case IFM_100G_CAUI2:
+                        #endif
+                        #ifdef IFM_100G_CAUI2_AC
+                        case IFM_100G_CAUI2_AC:
+                        #endif
+                        #ifdef IFM_100G_CAUI4
+                        case IFM_100G_CAUI4:
+                        #endif
+                        #ifdef IFM_100G_CAUI4_AC
+                        case IFM_100G_CAUI4_AC:
+                        #endif
+                        #ifdef IFM_100G_CP2
+                        case IFM_100G_CP2:
+                        #endif
+                        #ifdef IFM_100G_CR4
+                        case IFM_100G_CR4:
+                        #endif
+                        #ifdef IFM_100G_CR_PAM4
+                        case IFM_100G_CR_PAM4:
+                        #endif
+                        #ifdef IFM_100G_DR
+                        case IFM_100G_DR:
+                        #endif
+                        #ifdef IFM_100G_KR2_PAM4
+                        case IFM_100G_KR2_PAM4:
+                        #endif
+                        #ifdef IFM_100G_KR4
+                        case IFM_100G_KR4:
+                        #endif
+                        #ifdef IFM_100G_KR_PAM4
+                        case IFM_100G_KR_PAM4:
+                        #endif
+                        #ifdef IFM_100G_LR4
+                        case IFM_100G_LR4:
+                        #endif
+                        #ifdef IFM_100G_SR2
+                        case IFM_100G_SR2:
+                        #endif
+                        #ifdef IFM_100G_SR4
+                        case IFM_100G_SR4:
+                        #endif
+                            iface->speed = 100000; break;
+                        #ifdef IFM_100_FX
+                        case IFM_100_FX:
+                        #endif
+                        #ifdef IFM_100_SGMII
+                        case IFM_100_SGMII:
+                        #endif
+                        #ifdef IFM_100_T
+                        case IFM_100_T:
+                        #endif
+                        #ifdef IFM_100_T2
+                        case IFM_100_T2:
+                        #endif
+                        #ifdef IFM_100_T4
+                        case IFM_100_T4:
+                        #endif
+                        #ifdef IFM_100_TX
+                        case IFM_100_TX:
+                        #endif
+                        #ifdef IFM_100_VG
+                        case IFM_100_VG:
+                        #endif
+                            iface->speed = 100; break;
+                        #ifdef IFM_10G_AOC
+                        case IFM_10G_AOC:
+                        #endif
+                        #ifdef IFM_10G_CR1
+                        case IFM_10G_CR1:
+                        #endif
+                        #ifdef IFM_10G_CX4
+                        case IFM_10G_CX4:
+                        #endif
+                        #ifdef IFM_10G_ER
+                        case IFM_10G_ER:
+                        #endif
+                        #ifdef IFM_10G_KR
+                        case IFM_10G_KR:
+                        #endif
+                        #ifdef IFM_10G_KX4
+                        case IFM_10G_KX4:
+                        #endif
+                        #ifdef IFM_10G_LR
+                        case IFM_10G_LR:
+                        #endif
+                        #ifdef IFM_10G_LRM
+                        case IFM_10G_LRM:
+                        #endif
+                        #ifdef IFM_10G_SFI
+                        case IFM_10G_SFI:
+                        #endif
+                        #ifdef IFM_10G_SR
+                        case IFM_10G_SR:
+                        #endif
+                        #ifdef IFM_10G_T
+                        case IFM_10G_T:
+                        #endif
+                        #ifdef IFM_10G_TWINAX
+                        case IFM_10G_TWINAX:
+                        #endif
+                        #ifdef IFM_10G_TWINAX_LONG
+                        case IFM_10G_TWINAX_LONG:
+                        #endif
+                            iface->speed = 10000; break;
+                        #ifdef IFM_10_2
+                        case IFM_10_2:
+                        #endif
+                        #ifdef IFM_10_5
+                        case IFM_10_5:
+                        #endif
+                        #ifdef IFM_10_FL
+                        case IFM_10_FL:
+                        #endif
+                        #ifdef IFM_10_STP
+                        case IFM_10_STP:
+                        #endif
+                        #ifdef IFM_10_T
+                        case IFM_10_T:
+                        #endif
+                            iface->speed = 10; break;
+                        #ifdef IFM_200G_AUI4
+                        case IFM_200G_AUI4:
+                        #endif
+                        #ifdef IFM_200G_AUI4_AC
+                        case IFM_200G_AUI4_AC:
+                        #endif
+                        #ifdef IFM_200G_AUI8
+                        case IFM_200G_AUI8:
+                        #endif
+                        #ifdef IFM_200G_AUI8_AC
+                        case IFM_200G_AUI8_AC:
+                        #endif
+                        #ifdef IFM_200G_CR4_PAM4
+                        case IFM_200G_CR4_PAM4:
+                        #endif
+                        #ifdef IFM_200G_DR4
+                        case IFM_200G_DR4:
+                        #endif
+                        #ifdef IFM_200G_FR4
+                        case IFM_200G_FR4:
+                        #endif
+                        #ifdef IFM_200G_KR4_PAM4
+                        case IFM_200G_KR4_PAM4:
+                        #endif
+                        #ifdef IFM_200G_LR4
+                        case IFM_200G_LR4:
+                        #endif
+                        #ifdef IFM_200G_SR4
+                        case IFM_200G_SR4:
+                        #endif
+                            iface->speed = 200000; break;
+                        #ifdef IFM_20G_KR2
+                        case IFM_20G_KR2:
+                        #endif
+                            iface->speed = 20000; break;
+                        #ifdef IFM_2500_KX
+                        case IFM_2500_KX:
+                        #endif
+                        #ifdef IFM_2500_SX
+                        case IFM_2500_SX:
+                        #endif
+                        #ifdef IFM_2500_T
+                        case IFM_2500_T:
+                        #endif
+                        #ifdef IFM_2500_X
+                        case IFM_2500_X:
+                        #endif
+                            iface->speed = 2500; break;
+                        #ifdef IFM_25G_ACC
+                        case IFM_25G_ACC:
+                        #endif
+                        #ifdef IFM_25G_AOC
+                        case IFM_25G_AOC:
+                        #endif
+                        #ifdef IFM_25G_AUI
+                        case IFM_25G_AUI:
+                        #endif
+                        #ifdef IFM_25G_CR
+                        case IFM_25G_CR:
+                        #endif
+                        #ifdef IFM_25G_CR1
+                        case IFM_25G_CR1:
+                        #endif
+                        #ifdef IFM_25G_CR_S
+                        case IFM_25G_CR_S:
+                        #endif
+                        #ifdef IFM_25G_KR
+                        case IFM_25G_KR:
+                        #endif
+                        #ifdef IFM_25G_KR1
+                        case IFM_25G_KR1:
+                        #endif
+                        #ifdef IFM_25G_KR_S
+                        case IFM_25G_KR_S:
+                        #endif
+                        #ifdef IFM_25G_LR
+                        case IFM_25G_LR:
+                        #endif
+                        #ifdef IFM_25G_PCIE
+                        case IFM_25G_PCIE:
+                        #endif
+                        #ifdef IFM_25G_SR
+                        case IFM_25G_SR:
+                        #endif
+                        #ifdef IFM_25G_T
+                        case IFM_25G_T:
+                        #endif
+                            iface->speed = 25000; break;
+                        #ifdef IFM_400G_AUI8
+                        case IFM_400G_AUI8:
+                        #endif
+                        #ifdef IFM_400G_AUI8_AC
+                        case IFM_400G_AUI8_AC:
+                        #endif
+                        #ifdef IFM_400G_DR4
+                        case IFM_400G_DR4:
+                        #endif
+                        #ifdef IFM_400G_FR8
+                        case IFM_400G_FR8:
+                        #endif
+                        #ifdef IFM_400G_LR8
+                        case IFM_400G_LR8:
+                        #endif
+                            iface->speed = 400000; break;
+                        #ifdef IFM_40G_CR4
+                        case IFM_40G_CR4:
+                        #endif
+                        #ifdef IFM_40G_ER4
+                        case IFM_40G_ER4:
+                        #endif
+                        #ifdef IFM_40G_KR4
+                        case IFM_40G_KR4:
+                        #endif
+                        #ifdef IFM_40G_LR4
+                        case IFM_40G_LR4:
+                        #endif
+                        #ifdef IFM_40G_SR4
+                        case IFM_40G_SR4:
+                        #endif
+                        #ifdef IFM_40G_XLAUI
+                        case IFM_40G_XLAUI:
+                        #endif
+                        #ifdef IFM_40G_XLAUI_AC
+                        case IFM_40G_XLAUI_AC:
+                        #endif
+                        #ifdef IFM_40G_XLPPI
+                        case IFM_40G_XLPPI:
+                        #endif
+                        #ifdef IFM_40G_LM4
+                        case IFM_40G_LM4:
+                        #endif
+                            iface->speed = 40000; break;
+                        #ifdef IFM_5000_KR
+                        case IFM_5000_KR:
+                        #endif
+                        #ifdef IFM_5000_KR1
+                        case IFM_5000_KR1:
+                        #endif
+                        #ifdef IFM_5000_KR_S
+                        case IFM_5000_KR_S:
+                        #endif
+                        #ifdef IFM_5000_T
+                        case IFM_5000_T:
+                        #endif
+                            iface->speed = 5000; break;
+                        #ifdef IFM_50G_AUI1
+                        case IFM_50G_AUI1:
+                        #endif
+                        #ifdef IFM_50G_AUI1_AC
+                        case IFM_50G_AUI1_AC:
+                        #endif
+                        #ifdef IFM_50G_AUI2
+                        case IFM_50G_AUI2:
+                        #endif
+                        #ifdef IFM_50G_AUI2_AC
+                        case IFM_50G_AUI2_AC:
+                        #endif
+                        #ifdef IFM_50G_CP
+                        case IFM_50G_CP:
+                        #endif
+                        #ifdef IFM_50G_CR2
+                        case IFM_50G_CR2:
+                        #endif
+                        #ifdef IFM_50G_FR
+                        case IFM_50G_FR:
+                        #endif
+                        #ifdef IFM_50G_KR2
+                        case IFM_50G_KR2:
+                        #endif
+                        #ifdef IFM_50G_KR_PAM4
+                        case IFM_50G_KR_PAM4:
+                        #endif
+                        #ifdef IFM_50G_LAUI2
+                        case IFM_50G_LAUI2:
+                        #endif
+                        #ifdef IFM_50G_LAUI2_AC
+                        case IFM_50G_LAUI2_AC:
+                        #endif
+                        #ifdef IFM_50G_LR
+                        case IFM_50G_LR:
+                        #endif
+                        #ifdef IFM_50G_LR2
+                        case IFM_50G_LR2:
+                        #endif
+                        #ifdef IFM_50G_PCIE
+                        case IFM_50G_PCIE:
+                        #endif
+                        #ifdef IFM_50G_SR
+                        case IFM_50G_SR:
+                        #endif
+                        #ifdef IFM_50G_SR2
+                        case IFM_50G_SR2:
+                        #endif
+                        #ifdef IFM_50G_KR4
+                        case IFM_50G_KR4:
+                        #endif
+                            iface->speed = 50000; break;
+                        #ifdef IFM_56G_R4
+                        case IFM_56G_R4:
+                        #endif
+                            iface->speed = 56000; break;
+                        default:
+                            iface->speed = -1;
+                        }
+                    }
+                    #endif
+                }
+
+                #ifdef __sun
+                if ((options->showType & FF_LOCALIP_TYPE_MAC_BIT) && ioctl(sockfd, SIOCGIFHWADDR, &ifr) == 0)
+                {
+                    const uint8_t* ptr = (uint8_t*) ifr.ifr_addr.sa_data; // NOT ifr_enaddr
+                    ffStrbufSetF(&iface->mac, "%02x:%02x:%02x:%02x:%02x:%02x",
+                                ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
+                }
+                #endif
             }
-            #endif
         }
     }
 

src/detection/localip/localip_windows.c

@@ -153,8 +153,10 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
         if (!newIp)
         {
             FFLocalIpResult* result = FF_LIST_GET(FFLocalIpResult, *results, results->length - 1);
-            result->speed = (int32_t) (adapter->ReceiveLinkSpeed / 1000);
-            result->mtu = (int32_t) adapter->Mtu;
+            if (options->showType & FF_LOCALIP_TYPE_SPEED_BIT)
+                result->speed = (int32_t) (adapter->ReceiveLinkSpeed / 1000);
+            if (options->showType & FF_LOCALIP_TYPE_MTU_BIT)
+                result->mtu = (int32_t) adapter->Mtu;
         }
     }
 

src/detection/media/media_windows.c

@@ -5,7 +5,7 @@
 
 static const char* getMedia(FFMediaResult* media)
 {
-    FF_LIBRARY_LOAD(libffwinrt, NULL, "dlopen libffwinrt" FF_LIBRARY_EXTENSION " failed", "libffwinrt" FF_LIBRARY_EXTENSION, 0)
+    FF_LIBRARY_LOAD(libffwinrt, "dlopen libffwinrt" FF_LIBRARY_EXTENSION " failed", "libffwinrt" FF_LIBRARY_EXTENSION, 0)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libffwinrt, ffWinrtDetectMedia)
     libffwinrt = NULL; // Don't close libffwinrt or it may crash
 

src/detection/monitor/monitor_linux.c

@@ -135,7 +135,7 @@ static const char* xrandrHandleMonitors(XrandrData* data, Screen* screen, FFlist
 
 static const char* detectByXrandr(FFlist* results)
 {
-    FF_LIBRARY_LOAD(xrandr, &instance.config.library.libXrandr, "dlopen libXrandr" FF_LIBRARY_EXTENSION " failed", "libXrandr" FF_LIBRARY_EXTENSION, 3)
+    FF_LIBRARY_LOAD(xrandr, "dlopen libXrandr" FF_LIBRARY_EXTENSION " failed", "libXrandr" FF_LIBRARY_EXTENSION, 3)
 
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xrandr, XOpenDisplay)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(xrandr, XCloseDisplay)

src/detection/opencl/opencl.c

@@ -148,7 +148,7 @@ static const char* detectOpenCL(FFOpenCLResult* result)
 
     #ifndef __APPLE__
 
-    FF_LIBRARY_LOAD(opencl, &instance.config.library.libOpenCL, "dlopen libOpenCL" FF_LIBRARY_EXTENSION" failed",
+    FF_LIBRARY_LOAD(opencl, "dlopen libOpenCL" FF_LIBRARY_EXTENSION" failed",
     #ifdef _WIN32
         "OpenCL"FF_LIBRARY_EXTENSION, -1,
     #endif

src/detection/opengl/opengl_apple.c

@@ -34,7 +34,7 @@ static const char* cglHandlePixelFormat(FFOpenGLResult* result, CGLPixelFormatOb
     return error;
 }
 
-const char* ffDetectOpenGL(FF_MAYBE_UNUSED FFOpenGLOptions* options, FFOpenGLResult* result)
+const char* cglDetectOpenGL(FFOpenGLResult* result)
 {
     CGLPixelFormatObj pixelFormat;
     CGLPixelFormatAttribute attrs[] = {
@@ -51,3 +51,20 @@ const char* ffDetectOpenGL(FF_MAYBE_UNUSED FFOpenGLOptions* options, FFOpenGLRes
     CGLDestroyPixelFormat(pixelFormat);
     return error;
 }
+
+const char* ffDetectOpenGL(FFOpenGLOptions* options, FFOpenGLResult* result)
+{
+    if (options->library == FF_OPENGL_LIBRARY_AUTO)
+        return cglDetectOpenGL(result);
+    else if (options->library == FF_OPENGL_LIBRARY_EGL)
+    {
+        #if __has_include(<EGL/egl.h>)
+        const char* ffOpenGLDetectByEGL(FFOpenGLResult* result);
+        return ffOpenGLDetectByEGL(result);
+        #else
+        return "fastfetch was compiled without egl support";
+        #endif
+    }
+    else
+        return "Unsupported OpenGL library";
+}

src/detection/opengl/opengl_linux.c

@@ -120,7 +120,7 @@ static const char* detectByGlx(FFOpenGLResult* result)
 {
     GLXData data;
 
-    FF_LIBRARY_LOAD(glx, &instance.config.library.libGLX, "dlopen glx failed", "libGLX" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_LOAD(glx, "dlopen glx failed", "libGLX" FF_LIBRARY_EXTENSION, 1);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(glx, data, glXGetProcAddress);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(glx, data, glXQueryVersion);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(glx, data, XOpenDisplay);
@@ -189,7 +189,7 @@ static const char* detectByOsMesa(FFOpenGLResult* result)
 {
     OSMesaData data;
 
-    FF_LIBRARY_LOAD(osmesa, &instance.config.library.libOSMesa, "dlopen osmesa failed", "libOSMesa" FF_LIBRARY_EXTENSION, 8);
+    FF_LIBRARY_LOAD(osmesa, "dlopen osmesa failed", "libOSMesa" FF_LIBRARY_EXTENSION, 8);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(osmesa, data, OSMesaGetProcAddress);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(osmesa, data, OSMesaCreateContext);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(osmesa, data, OSMesaMakeCurrent);

src/detection/opengl/opengl_shared.c

@@ -74,14 +74,8 @@ static const char* eglHandleSurface(FFOpenGLResult* result, EGLData* data)
 
 static const char* eglHandleDisplay(FFOpenGLResult* result, EGLData* data)
 {
-    if(data->ffeglBindAPI(
-        #ifdef _WIN32
-        EGL_OPENGL_ES_API
-        #else
-        EGL_OPENGL_API
-        #endif
-    ) != EGL_TRUE)
-        return "eglBindAPI returned EGL_FALSE";
+    // try use OpenGL API. If failed, use the default API (usually OpenGL ES)
+    data->ffeglBindAPI(EGL_OPENGL_API);
 
     EGLint eglConfigCount;
     data->ffeglGetConfigs(data->display, &data->config, 1, &eglConfigCount);
@@ -121,11 +115,12 @@ static const char* eglHandleData(FFOpenGLResult* result, EGLData* data)
     return error;
 }
 
+
 const char* ffOpenGLDetectByEGL(FFOpenGLResult* result)
 {
     EGLData eglData;
 
-    FF_LIBRARY_LOAD(egl, &instance.config.library.libEGL, "dlopen egl failed", "libEGL" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_LOAD(egl, "dlopen libEGL" FF_LIBRARY_EXTENSION " failed", "libEGL" FF_LIBRARY_EXTENSION, 1);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglGetProcAddress);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglGetDisplay);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglQueryString);

src/detection/opengl/opengl_windows.c

@@ -81,7 +81,7 @@ static LRESULT CALLBACK wglHandleWndProc(HWND hWnd, UINT message, WPARAM wParam,
 
 static const char* wglDetectOpenGL(FFOpenGLResult* result)
 {
-    FF_LIBRARY_LOAD(opengl32, NULL, "dlopen opengl32" FF_LIBRARY_EXTENSION " failed", "opengl32" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_LOAD(opengl32, "dlopen opengl32" FF_LIBRARY_EXTENSION " failed", "opengl32" FF_LIBRARY_EXTENSION, 1);
 
     WGLData data = { .result = result };
 

src/detection/os/os_linux.c

@@ -132,6 +132,15 @@ static void getUbuntuFlavour(FFOSResult* result)
         ffStrbufSetS(&result->idLike, "ubuntu");
         return;
     }
+
+    if(ffStrContains(xdgConfigDirs, "lliurex"))
+    {
+        ffStrbufSetS(&result->name, "LliureX");
+        ffStrbufSetS(&result->prettyName, "LliureX");
+        ffStrbufSetS(&result->id, "lliurex");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
 }
 
 static void getDebianVersion(FFOSResult* result)
@@ -163,6 +172,13 @@ static bool detectDebianDerived(FFOSResult* result)
         ffStrbufSetS(&result->idLike, "debian");
         return true;
     }
+    else if (ffStrbufEqualS(&result->name, "Parrot Security"))
+    {
+        // https://github.com/ParrotSec/base-files/blob/c06f6d42ddf8d79564882306576576eddab7d907/etc/os-release
+        ffStrbufSetS(&result->id, "parrot");
+        ffStrbufSetS(&result->idLike, "debian");
+        return true;
+    }
     else if (ffPathExists("/usr/bin/pveversion", FF_PATHTYPE_FILE))
     {
         ffStrbufSetS(&result->id, "pve");

src/detection/os/os_windows.cpp

@@ -31,7 +31,7 @@ PWSTR WINAPI BrandingFormatString(PCWSTR format);
 static const char* getOsNameByWinbrand(FFstrbuf* osName)
 {
     //https://dennisbabkin.com/blog/?t=how-to-tell-the-real-version-of-windows-your-app-is-running-on#ver_string
-    FF_LIBRARY_LOAD(winbrand, nullptr, "dlopen winbrand" FF_LIBRARY_EXTENSION " failed", "winbrand" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_LOAD(winbrand, "dlopen winbrand" FF_LIBRARY_EXTENSION " failed", "winbrand" FF_LIBRARY_EXTENSION, 1);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(winbrand, BrandingFormatString);
 
     const wchar_t* rawName = ffBrandingFormatString(L"%WINDOWS_LONG%");

src/detection/packages/packages.c

@@ -1,7 +1,13 @@
 #include "packages.h"
+#include "common/io/io.h"
 
+#include <inttypes.h>
 #include <stddef.h>
 
+#ifdef __APPLE__
+#define st_mtim st_mtimespec
+#endif
+
 void ffDetectPackagesImpl(FFPackagesResult* result, FFPackagesOptions* options);
 
 const char* ffDetectPackages(FFPackagesResult* result, FFPackagesOptions* options)
@@ -16,3 +22,66 @@ const char* ffDetectPackages(FFPackagesResult* result, FFPackagesOptions* option
 
     return NULL;
 }
+
+bool ffPackagesReadCache(FFstrbuf* cacheDir, FFstrbuf* cacheContent, const char* filePath, const char* packageId, uint32_t* result)
+{
+    #ifndef _WIN32
+    struct stat st;
+    if (stat(filePath, &st) < 0) // file doesn't exist or isn't accessible
+    {
+        *result = 0;
+        return true;
+    }
+
+    if (__builtin_expect(st.st_mtim.tv_sec <= 0, false))
+        return false;
+
+    uint64_t mtime_current = (uint64_t) st.st_mtim.tv_sec * 1000ull + (uint64_t) st.st_mtim.tv_nsec / 1000000ull;
+    #else
+    FF_AUTO_CLOSE_FD HANDLE handle = CreateFileA(filePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+    if (handle == INVALID_HANDLE_VALUE) // file doesn't exist or isn't accessible
+    {
+        *result = 0;
+        return true;
+    }
+
+    uint64_t mtime_current;
+    if (!GetFileTime(handle, NULL, NULL, (FILETIME*) &mtime_current))
+        return false;
+
+    mtime_current = (mtime_current - 116444736000000000ull) / 10000ull;
+
+    if (__builtin_expect(mtime_current == 0, false))
+        return false;
+    #endif
+
+    ffStrbufSet(cacheDir, &instance.state.platform.cacheDir);
+    ffStrbufEnsureEndsWithC(cacheDir, '/');
+    ffStrbufAppendF(cacheDir, "fastfetch/packages/%s.txt", packageId);
+
+    if (ffReadFileBuffer(cacheDir->chars, cacheContent))
+    {
+        uint64_t mtime_cached;
+        uint32_t num_cached;
+        if (sscanf(cacheContent->chars, "%" SCNu64 " %" SCNu32, &mtime_cached, &num_cached) == 2 &&
+            mtime_cached == mtime_current && num_cached > 0)
+        {
+            *result = num_cached;
+            return true;
+        }
+    }
+
+    ffStrbufSetF(cacheContent, "%" PRIu64 " ", mtime_current);
+
+    return false;
+}
+
+bool ffPackagesWriteCache(FFstrbuf* cacheDir, FFstrbuf* cacheContent, uint32_t num_elements)
+{
+    if (__builtin_expect(cacheContent->length == 0, false))
+        return false;
+
+    ffStrbufAppendF(cacheContent, "%" PRIu32, num_elements);
+    return ffWriteFileBuffer(cacheDir->chars, cacheContent);
+}

src/detection/packages/packages.h

@@ -42,3 +42,5 @@ typedef struct FFPackagesResult
 } FFPackagesResult;
 
 const char* ffDetectPackages(FFPackagesResult* result, FFPackagesOptions* options);
+bool ffPackagesReadCache(FFstrbuf* cacheDir, FFstrbuf* cacheContent, const char* filePath, const char* packageId, uint32_t* result);
+bool ffPackagesWriteCache(FFstrbuf* cacheDir, FFstrbuf* cacheContent, uint32_t num_elements);

src/detection/packages/packages_bsd.c

@@ -2,8 +2,26 @@
 
 #include "common/settings.h"
 
+static uint32_t getSQLite3Int(const char* dbPath, const char* query, const char* packageId)
+{
+    FF_STRBUF_AUTO_DESTROY cacheDir = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY cacheContent = ffStrbufCreate();
+
+    uint32_t num_elements;
+    if (ffPackagesReadCache(&cacheDir, &cacheContent, dbPath, packageId, &num_elements))
+        return num_elements;
+
+    num_elements = (uint32_t) ffSettingsGetSQLite3Int(dbPath, query);
+
+    ffPackagesWriteCache(&cacheDir, &cacheContent, num_elements);
+
+    return num_elements;
+}
+
 void ffDetectPackagesImpl(FFPackagesResult* result, FF_MAYBE_UNUSED FFPackagesOptions* options)
 {
     if (!(options->disabled & FF_PACKAGES_FLAG_PKG_BIT))
-        result->pkg = (uint32_t) ffSettingsGetSQLite3Int(FASTFETCH_TARGET_DIR_ROOT "/var/db/pkg/local.sqlite", "SELECT count(*) FROM packages");
+    {
+        result->pkg = getSQLite3Int(FASTFETCH_TARGET_DIR_ROOT "/var/db/pkg/local.sqlite", "SELECT count(*) FROM packages", "pkg");
+    }
 }

src/detection/packages/packages_linux.c

@@ -56,21 +56,49 @@ static uint32_t getNumStringsImpl(const char* filename, const char* needle)
     return count;
 }
 
-static uint32_t getNumStrings(FFstrbuf* baseDir, const char* filename, const char* needle)
+static uint32_t getNumStrings(FFstrbuf* baseDir, const char* filename, const char* needle, const char* packageId)
 {
     uint32_t baseDirLength = baseDir->length;
     ffStrbufAppendS(baseDir, filename);
-    uint32_t num_elements = getNumStringsImpl(baseDir->chars, needle);
+
+    FF_STRBUF_AUTO_DESTROY cacheDir = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY cacheContent = ffStrbufCreate();
+
+    uint32_t num_elements;
+    if (ffPackagesReadCache(&cacheDir, &cacheContent, baseDir->chars, packageId, &num_elements))
+    {
+        ffStrbufSubstrBefore(baseDir, baseDirLength);
+        return num_elements;
+    }
+
+    num_elements = getNumStringsImpl(baseDir->chars, needle);
     ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    ffPackagesWriteCache(&cacheDir, &cacheContent, num_elements);
+
     return num_elements;
 }
 
-static uint32_t getSQLite3Int(FFstrbuf* baseDir, const char* dbPath, const char* query)
+static uint32_t getSQLite3Int(FFstrbuf* baseDir, const char* dbPath, const char* query, const char* packageId)
 {
     uint32_t baseDirLength = baseDir->length;
     ffStrbufAppendS(baseDir, dbPath);
-    uint32_t num_elements = (uint32_t) ffSettingsGetSQLite3Int(baseDir->chars, query);
+
+    FF_STRBUF_AUTO_DESTROY cacheDir = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY cacheContent = ffStrbufCreate();
+
+    uint32_t num_elements;
+    if (ffPackagesReadCache(&cacheDir, &cacheContent, baseDir->chars, packageId, &num_elements))
+    {
+        ffStrbufSubstrBefore(baseDir, baseDirLength);
+        return num_elements;
+    }
+
+    num_elements = (uint32_t) ffSettingsGetSQLite3Int(baseDir->chars, query);
     ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    ffPackagesWriteCache(&cacheDir, &cacheContent, num_elements);
+
     return num_elements;
 }
 
@@ -322,7 +350,7 @@ static uint32_t getSnap(FFstrbuf* baseDir)
 
 static uint32_t getRpmFromLibrpm(void)
 {
-    FF_LIBRARY_LOAD(rpm, &instance.config.library.librpm, 0, "librpm" FF_LIBRARY_EXTENSION, 12)
+    FF_LIBRARY_LOAD(rpm, 0, "librpm" FF_LIBRARY_EXTENSION, 12)
     FF_LIBRARY_LOAD_SYMBOL(rpm, rpmReadConfigFiles, 0)
     FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsCreate, 0)
     FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsInitIterator, 0)
@@ -441,9 +469,9 @@ static uint32_t getGuixPackages(FFstrbuf* baseDir, const char* dirname)
 
 static void getPackageCounts(FFstrbuf* baseDir, FFPackagesResult* packageCounts, FFPackagesOptions* options)
 {
-    if (!(options->disabled & FF_PACKAGES_FLAG_APK_BIT)) packageCounts->apk += getNumStrings(baseDir, "/lib/apk/db/installed", "C:Q");
-    if (!(options->disabled & FF_PACKAGES_FLAG_DPKG_BIT)) packageCounts->dpkg += getNumStrings(baseDir, "/var/lib/dpkg/status", "Status: install ok installed");
-    if (!(options->disabled & FF_PACKAGES_FLAG_LPKG_BIT)) packageCounts->lpkg += getNumStrings(baseDir, "/opt/Loc-OS-LPKG/installed-lpkg/Listinstalled-lpkg.list", "\n");
+    if (!(options->disabled & FF_PACKAGES_FLAG_APK_BIT)) packageCounts->apk += getNumStrings(baseDir, "/lib/apk/db/installed", "C:Q", "apk");
+    if (!(options->disabled & FF_PACKAGES_FLAG_DPKG_BIT)) packageCounts->dpkg += getNumStrings(baseDir, "/var/lib/dpkg/status", "Status: install ok installed", "dpkg");
+    if (!(options->disabled & FF_PACKAGES_FLAG_LPKG_BIT)) packageCounts->lpkg += getNumStrings(baseDir, "/opt/Loc-OS-LPKG/installed-lpkg/Listinstalled-lpkg.list", "\n", "lpkg");
     if (!(options->disabled & FF_PACKAGES_FLAG_EMERGE_BIT)) packageCounts->emerge += countFilesRecursive(baseDir, "/var/db/pkg", "SIZE");
     if (!(options->disabled & FF_PACKAGES_FLAG_EOPKG_BIT)) packageCounts->eopkg += getNumElements(baseDir, "/var/lib/eopkg/package", DT_DIR);
     if (!(options->disabled & FF_PACKAGES_FLAG_FLATPAK_BIT)) packageCounts->flatpakSystem += getNumElements(baseDir, "/var/lib/flatpak/app", DT_DIR);
@@ -455,7 +483,7 @@ static void getPackageCounts(FFstrbuf* baseDir, FFPackagesResult* packageCounts,
     if (!(options->disabled & FF_PACKAGES_FLAG_PACMAN_BIT)) packageCounts->pacman += getNumElements(baseDir, "/var/lib/pacman/local", DT_DIR);
     if (!(options->disabled & FF_PACKAGES_FLAG_LPKGBUILD_BIT)) packageCounts->lpkgbuild += getNumElements(baseDir, "/opt/Loc-OS-LPKG/lpkgbuild/remove", DT_REG);
     if (!(options->disabled & FF_PACKAGES_FLAG_PKGTOOL_BIT)) packageCounts->pkgtool += getNumElements(baseDir, "/var/log/packages", DT_REG);
-    if (!(options->disabled & FF_PACKAGES_FLAG_RPM_BIT)) packageCounts->rpm += getSQLite3Int(baseDir, "/var/lib/rpm/rpmdb.sqlite", "SELECT count(*) FROM Packages");
+    if (!(options->disabled & FF_PACKAGES_FLAG_RPM_BIT)) packageCounts->rpm += getSQLite3Int(baseDir, "/var/lib/rpm/rpmdb.sqlite", "SELECT count(*) FROM Packages", "rpm");
     if (!(options->disabled & FF_PACKAGES_FLAG_SNAP_BIT)) packageCounts->snap += getSnap(baseDir);
     if (!(options->disabled & FF_PACKAGES_FLAG_XBPS_BIT)) packageCounts->xbps += getXBPS(baseDir, "/var/db/xbps");
     if (!(options->disabled & FF_PACKAGES_FLAG_BREW_BIT))
@@ -464,9 +492,9 @@ static void getPackageCounts(FFstrbuf* baseDir, FFPackagesResult* packageCounts,
         packageCounts->brew += getNumElements(baseDir, "/home/linuxbrew/.linuxbrew/Cellar", DT_DIR);
     }
     if (!(options->disabled & FF_PACKAGES_FLAG_PALUDIS_BIT)) packageCounts->paludis += countFilesRecursive(baseDir, "/var/db/paludis/repositories", "environment.bz2");
-    if (!(options->disabled & FF_PACKAGES_FLAG_OPKG_BIT)) packageCounts->opkg += getNumStrings(baseDir, "/usr/lib/opkg/status", "Package:"); // openwrt
+    if (!(options->disabled & FF_PACKAGES_FLAG_OPKG_BIT)) packageCounts->opkg += getNumStrings(baseDir, "/usr/lib/opkg/status", "Package:", "opkg"); // openwrt
     if (!(options->disabled & FF_PACKAGES_FLAG_AM_BIT)) packageCounts->am = getAM(baseDir);
-    if (!(options->disabled & FF_PACKAGES_FLAG_SORCERY_BIT)) packageCounts->sorcery += getNumStrings(baseDir, "/var/state/sorcery/packages", ":installed:");
+    if (!(options->disabled & FF_PACKAGES_FLAG_SORCERY_BIT)) packageCounts->sorcery += getNumStrings(baseDir, "/var/state/sorcery/packages", ":installed:", "sorcery");
     if (!(options->disabled & FF_PACKAGES_FLAG_GUIX_BIT))
     {
       packageCounts->guixSystem += getGuixPackages(baseDir, "/run/current-system/profile");

src/detection/sound/sound_linux.c

@@ -41,7 +41,7 @@ static void paServerInfoCallback(pa_context *c, const pa_server_info *i, void *u
 
 static const char* detectSound(FFlist* devices)
 {
-    FF_LIBRARY_LOAD(pulse, &instance.config.library.libPulse, "Failed to load libpulse" FF_LIBRARY_EXTENSION, "libpulse" FF_LIBRARY_EXTENSION, 0)
+    FF_LIBRARY_LOAD(pulse, "Failed to load libpulse" FF_LIBRARY_EXTENSION, "libpulse" FF_LIBRARY_EXTENSION, 0)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(pulse, pa_mainloop_new)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(pulse, pa_mainloop_get_api)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(pulse, pa_mainloop_iterate)

src/detection/temps/temps_bsd.c

@@ -7,8 +7,8 @@ const char* ffDetectCpuTemp(double* current)
     if (temp == -999999)
         return "ffSysctlGetInt(\"dev.cpu.0.temperature\") failed";
 
-    // In tenth of degrees Celsius
-    *current = (double) temp / 10;
+    // In tenth of degrees Kelvin
+    *current = (double) temp / 10 - 273.15;
     return NULL;
 }
 

src/detection/terminalfont/terminalfont.c

@@ -72,35 +72,32 @@ FF_MAYBE_UNUSED static void detectTTY(FFTerminalFontResult* terminalFont)
         ffStrbufAppendS(&terminalFont->error, "Couldn't find Font in "FASTFETCH_TARGET_DIR_ETC"/vconsole.conf");
 }
 
-static bool queryKittyTerm(const char* query, FFstrbuf* res)
-{
-    // https://github.com/fastfetch-cli/fastfetch/discussions/1030#discussioncomment-9845233
-    char buffer[256] = "";
-    if (ffGetTerminalResponse(
-        query, // kitty-query-font_family;kitty-query-font_size
-        "\eP1+r%*[^=]=%255[^\e]\e\\", buffer) == NULL)
-    {
-        // decode hex string
-        for (const char* p = buffer; p[0] && p[1]; p += 2)
-        {
-            unsigned value;
-            if (sscanf(p, "%2x", &value) == 1)
-                ffStrbufAppendC(res, (char) value);
-        }
-        return true;
-    }
-    return false;
-}
-
 FF_MAYBE_UNUSED static bool detectKitty(const FFstrbuf* exe, FFTerminalFontResult* result)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
 
-    // Kitty generates response independently even if we query font family and size in one query
-    // which may result in short read in `ffGetTerminalResponse`
-    if (queryKittyTerm("\eP+q6b697474792d71756572792d666f6e745f66616d696c79\e\\", &fontName)) // kitty-query-font_family
-        queryKittyTerm("\eP+q6b697474792d71756572792d666f6e745f73697a65\e\\", &fontSize); // kitty-query-font_size
+    char fontHex[512] = "", sizeHex[512] = "";
+    // https://github.com/fastfetch-cli/fastfetch/discussions/1030#discussioncomment-9845233
+    if (ffGetTerminalResponse(
+        "\eP+q6b697474792d71756572792d666f6e745f66616d696c79;6b697474792d71756572792d666f6e745f73697a65\e\\", // kitty-query-font_family;kitty-query-font_size
+        2,
+        "\eP1+r%*[^=]=%64[^\e]\e\\\eP1+r%*[^=]=%64[^\e]\e\\", fontHex, sizeHex) == NULL && *fontHex && *sizeHex)
+    {
+        // decode hex string
+        for (const char* p = fontHex; p[0] && p[1]; p += 2)
+        {
+            unsigned value;
+            if (sscanf(p, "%2x", &value) == 1)
+                ffStrbufAppendC(&fontName, (char) value);
+        }
+        for (const char* p = sizeHex; p[0] && p[1]; p += 2)
+        {
+            unsigned value;
+            if (sscanf(p, "%2x", &value) == 1)
+                ffStrbufAppendC(&fontSize, (char) value);
+        }
+    }
     else
     {
         FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();

src/detection/terminalfont/terminalfont_android.c

@@ -15,7 +15,7 @@ const char* detectTermux(FFTerminalFontResult* terminalFont)
 {
     #ifdef FF_HAVE_FREETYPE
 
-    FF_LIBRARY_LOAD(freetype, &instance.config.library.libfreetype, "dlopen libfreetype"FF_LIBRARY_EXTENSION " failed", "libfreetype"FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(freetype, "dlopen libfreetype"FF_LIBRARY_EXTENSION " failed", "libfreetype"FF_LIBRARY_EXTENSION, 2)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(freetype, FT_Init_FreeType);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(freetype, FT_New_Face);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(freetype, FT_Done_Face);

src/detection/terminalshell/terminalshell.c

@@ -375,6 +375,9 @@ FF_MAYBE_UNUSED static bool getTerminalVersionFoot(FFstrbuf* exe, FFstrbuf* vers
 
 FF_MAYBE_UNUSED static bool getTerminalVersionMateTerminal(FFstrbuf* exe, FFstrbuf* version)
 {
+    ffBinaryExtractStrings(exe->chars, extractGeneralVersion, version, (uint32_t) strlen("0.0.0"));
+    if (version->length > 0) return true;
+
     if(!getExeVersionRaw(exe, version)) return false;
 
     //MATE Terminal 1.26.1
@@ -580,6 +583,7 @@ static bool getTerminalVersionKitty(FFstrbuf* exe, FFstrbuf* version)
     // https://github.com/fastfetch-cli/fastfetch/discussions/1030#discussioncomment-9845233
     if (ffGetTerminalResponse(
         "\eP+q6b697474792d71756572792d76657273696f6e\e\\", // kitty-query-version
+        1,
         "\eP1+r%*[^=]=%63[^\e]\e\\\\", versionHex) == NULL)
     {
         // decode hex string

src/detection/terminalsize/terminalsize_linux.c

@@ -14,10 +14,10 @@ bool ffDetectTerminalSize(FFTerminalSizeResult* result)
     ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
 
     if (winsize.ws_row == 0 || winsize.ws_col == 0)
-        ffGetTerminalResponse("\e[18t", "\e[8;%hu;%hut", &winsize.ws_row, &winsize.ws_col);
+        ffGetTerminalResponse("\e[18t", 2, "\e[8;%hu;%hut", &winsize.ws_row, &winsize.ws_col);
 
     if (winsize.ws_ypixel == 0 || winsize.ws_xpixel == 0)
-        ffGetTerminalResponse("\e[14t", "\e[4;%hu;%hut", &winsize.ws_ypixel, &winsize.ws_xpixel);
+        ffGetTerminalResponse("\e[14t", 2, "\e[4;%hu;%hut", &winsize.ws_ypixel, &winsize.ws_xpixel);
 
     if (winsize.ws_row == 0 && winsize.ws_col == 0)
         return false;

src/detection/terminalsize/terminalsize_windows.c

@@ -24,7 +24,8 @@ bool ffDetectTerminalSize(FFTerminalSizeResult* result)
         }
         else
         {
-            ffGetTerminalResponse("\e[18t", "\e[8;%hu;%hut", &result->rows, &result->columns);
+            // Windows Terminal doesn't report `\e` for some reason
+            ffGetTerminalResponse("\e[18t", 2, "%*[^;];%hu;%hut", &result->rows, &result->columns);
         }
     }
 
@@ -38,12 +39,10 @@ bool ffDetectTerminalSize(FFTerminalSizeResult* result)
             result->width = result->columns * (uint16_t) cfi.dwFontSize.X;
             result->height = result->rows * (uint16_t) cfi.dwFontSize.Y;
         }
-        else
+        if (result->width == 0 || result->height == 0)
         {
-            // Pending https://github.com/microsoft/terminal/issues/8581
-            // if (result->width == 0 && result->height == 0)
-            //     ffGetTerminalResponse("\033[14t", "\033[4;%hu;%hut", &result->height, &result->width);
-            return false;
+            // Windows Terminal doesn't report `\e` for some reason
+            ffGetTerminalResponse("\e[14t", 2, "%*[^;];%hu;%hut", &result->height, &result->width);
         }
     }
 

src/detection/terminaltheme/terminaltheme.c

@@ -6,22 +6,15 @@
 
 static bool detectByEscapeCode(FFTerminalThemeResult* result)
 {
-    int command = 0;
-
-    if (ffGetTerminalResponse("\e]10;?\e\\", "\e]%d;rgb:%" SCNx16 "/%" SCNx16 "/%" SCNx16 "\e\\", &command, &result->fg.r, &result->fg.g, &result->fg.b) == NULL)
+    // Windows Terminal removes all `\e`s in its output
+    if (ffGetTerminalResponse("\e]10;?\e\\" /*fg*/ "\e]11;?\e\\" /*bg*/,
+        6,
+        "%*[^0-9]10;rgb:%" SCNx16 "/%" SCNx16 "/%" SCNx16 /*"\e\\"*/ "%*[^0-9]11;rgb:%" SCNx16 "/%" SCNx16 "/%" SCNx16 /*"\e\\"*/,
+        &result->fg.r, &result->fg.g, &result->fg.b,
+        &result->bg.r, &result->bg.g, &result->bg.b) == NULL)
     {
-        if (command != 10)
-            return false;
         if (result->fg.r > 0x0100 || result->fg.g > 0x0100 || result->fg.b > 0x0100)
             result->fg.r /= 0x0100, result->fg.g /= 0x0100, result->fg.b /= 0x0100;
-    }
-    else
-        return false;
-
-    if (ffGetTerminalResponse("\e]11;?\e\\", "\e]%d;rgb:%" SCNx16 "/%" SCNx16 "/%" SCNx16 "\e\\", &command, &result->bg.r, &result->bg.g, &result->bg.b) == NULL)
-    {
-        if (command != 11)
-            return false;
         if (result->bg.r > 0x0100 || result->bg.g > 0x0100 || result->bg.b > 0x0100)
             result->bg.r /= 0x0100, result->bg.g /= 0x0100, result->bg.b /= 0x0100;
     }

src/detection/uptime/uptime_linux.c

@@ -20,7 +20,7 @@ const char* ffDetectUptime(FFUptimeResult* result)
         if(err != buf)
         {
             result->uptime = (uint64_t) (sec * 1000);
-            result->bootTime = ffTimeGetNow() + result->uptime;
+            result->bootTime = ffTimeGetNow() - result->uptime;
             return NULL;
         }
     }
@@ -32,7 +32,7 @@ const char* ffDetectUptime(FFUptimeResult* result)
         return "clock_gettime(CLOCK_BOOTTIME) failed";
 
     result->uptime = (uint64_t) uptime.tv_sec * 1000 + (uint64_t) uptime.tv_nsec / 1000000;
-    result->bootTime = ffTimeGetNow() + result->uptime;
+    result->bootTime = ffTimeGetNow() - result->uptime;
 
     return NULL;
 }

src/detection/vulkan/vulkan.c

@@ -39,7 +39,7 @@ static void applyDriverName(VkPhysicalDeviceDriverPropertiesKHR* properties, FFs
 
 static const char* detectVulkan(FFVulkanResult* result)
 {
-    FF_LIBRARY_LOAD(vulkan, &instance.config.library.libVulkan, "dlopen libvulkan"FF_LIBRARY_EXTENSION " failed",
+    FF_LIBRARY_LOAD(vulkan, "dlopen libvulkan"FF_LIBRARY_EXTENSION " failed",
         #ifdef __APPLE__
             "libMoltenVK"FF_LIBRARY_EXTENSION, -1
         #elif defined(_WIN32)

src/detection/wifi/wifi_apple.m

@@ -1,5 +1,6 @@
 #include "wifi.h"
 #include "common/processing.h"
+#include "util/stringUtils.h"
 
 #import <CoreWLAN/CoreWLAN.h>
 
@@ -12,21 +13,61 @@ int Apple80211GetInfoCopy(struct Apple80211 *handle, CFDictionaryRef *info) __at
 @property (readonly) struct Apple80211* device;
 @end
 
-static NSDictionary* getWifiInfoByApple80211(CWInterface* inf)
+inline static NSDictionary* getWifiInfoByApple80211(CWInterface* inf)
 {
-    if (!Apple80211GetInfoCopy) return NULL;
+    if (!inf.device || !Apple80211GetInfoCopy) return NULL;
     CFDictionaryRef result = NULL;
     if (Apple80211GetInfoCopy(inf.device, &result) < 0) return NULL;
     return CFBridgingRelease(result);
 }
 
+static NSDictionary* getWifiInfoBySystemProfiler(NSString* ifName)
+{
+    // Warning: costs about 2s on my machine
+    static NSArray* spData;
+    static bool inited;
+    if (!inited)
+    {
+        inited = true;
+        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+        if (ffProcessAppendStdOut(&buffer, (char* const[]) {
+            "system_profiler",
+            "SPAirPortDataType",
+            "-xml",
+            "-detailLevel",
+            "basic",
+            NULL
+        }) != NULL)
+            return nil;
+
+        spData = [NSPropertyListSerialization propertyListWithData:[NSData dataWithBytes:buffer.chars length:buffer.length]
+                                              options:NSPropertyListImmutable
+                                              format:nil
+                                              error:nil];
+    }
+
+    if (spData)
+    {
+        for (NSDictionary* data in spData[0][@"_items"])
+        {
+            for (NSDictionary* inf in data[@"spairport_airport_interfaces"])
+            {
+                if ([ifName isEqualToString:inf[@"_name"]])
+                    return inf[@"spairport_current_network_information"];
+            }
+        }
+    }
+
+    return NULL;
+}
+
 const char* ffDetectWifi(FFlist* result)
 {
     NSArray<CWInterface*>* interfaces = CWWiFiClient.sharedWiFiClient.interfaces;
-    if(!interfaces)
+    if (!interfaces)
         return "CWWiFiClient.sharedWiFiClient.interfaces is nil";
 
-    for(CWInterface* inf in interfaces)
+    for (CWInterface* inf in interfaces)
     {
         FFWifiResult* item = (FFWifiResult*)ffListAdd(result);
         ffStrbufInit(&item->inf.description);
@@ -46,22 +87,25 @@ const char* ffDetectWifi(FFlist* result)
             continue;
 
         ffStrbufSetStatic(&item->conn.status, inf.interfaceMode != kCWInterfaceModeNone ? "Active" : "Inactive");
-        if(!inf.serviceActive)
+        if(inf.interfaceMode == kCWInterfaceModeNone)
             continue;
 
-        NSDictionary* apple = NULL;
+        NSDictionary* apple = nil; // For getWifiInfoByApple80211
+        NSDictionary* sp = nil; // For getWifiInfoBySystemProfiler
 
         if (inf.ssid) // https://developer.apple.com/forums/thread/732431
             ffStrbufAppendS(&item->conn.ssid, inf.ssid.UTF8String);
         else if (apple || (apple = getWifiInfoByApple80211(inf)))
-            ffStrbufAppendS(&item->conn.ssid, [[apple valueForKey:@"SSID_STR"] UTF8String]);
+            ffStrbufAppendS(&item->conn.ssid, [apple[@"SSID_STR"] UTF8String]);
+        else if (sp || (sp = getWifiInfoBySystemProfiler(inf.interfaceName)))
+            ffStrbufAppendS(&item->conn.ssid, [sp[@"_name"] UTF8String]);
         else
             ffStrbufSetStatic(&item->conn.ssid, "<unknown ssid>"); // https://developer.apple.com/forums/thread/732431
 
         if (inf.bssid)
             ffStrbufAppendS(&item->conn.bssid, inf.bssid.UTF8String);
         else if (apple || (apple = getWifiInfoByApple80211(inf)))
-            ffStrbufAppendS(&item->conn.bssid, [[apple valueForKey:@"BSSID"] UTF8String]);
+            ffStrbufAppendS(&item->conn.bssid, [apple[@"BSSID"] UTF8String]);
 
         switch(inf.activePHYMode)
         {
@@ -90,7 +134,24 @@ const char* ffDetectWifi(FFlist* result)
                 ffStrbufSetStatic(&item->conn.protocol, "802.11be (Wi-Fi 7)");
                 break;
             default:
-                ffStrbufAppendF(&item->conn.protocol, "Unknown (%ld)", inf.activePHYMode);
+                if (inf.activePHYMode < 64)
+                    ffStrbufAppendF(&item->conn.protocol, "Unknown (%ld)", inf.activePHYMode);
+                else if (sp || (sp = getWifiInfoBySystemProfiler(inf.interfaceName)))
+                {
+                    ffStrbufSetS(&item->conn.protocol, [sp[@"spairport_network_phymode"] UTF8String]);
+                    if (ffStrbufStartsWithS(&item->conn.protocol, "802.11"))
+                    {
+                        const char* subProtocol = item->conn.protocol.chars + strlen("802.11");
+                        if (ffStrEquals(subProtocol, "be"))
+                            ffStrbufSetStatic(&item->conn.protocol, "802.11be (Wi-Fi 7)");
+                        else if (ffStrEquals(subProtocol, "ax"))
+                            ffStrbufSetStatic(&item->conn.protocol, "802.11ax (Wi-Fi 6)");
+                        else if (ffStrEquals(subProtocol, "ac"))
+                            ffStrbufSetStatic(&item->conn.protocol, "802.11ac (Wi-Fi 5)");
+                        else if (ffStrEquals(subProtocol, "n"))
+                            ffStrbufSetStatic(&item->conn.protocol, "802.11n (Wi-Fi 4)");
+                    }
+                }
                 break;
         }
         item->conn.signalQuality = (double) (inf.rssiValue >= -50 ? 100 : inf.rssiValue <= -100 ? 0 : (inf.rssiValue + 100) * 2);
@@ -150,17 +211,17 @@ const char* ffDetectWifi(FFlist* result)
                 // Sonoma...
                 if (apple || (apple = getWifiInfoByApple80211(inf)))
                 {
-                    NSDictionary* authType = [apple valueForKey:@"AUTH_TYPE"];
+                    NSDictionary* authType = apple[@"AUTH_TYPE"];
                     if (authType)
                     {
                         // AUTH_LOWER seems useless. `airport` verifies if its value is between 1 and 3, and prints `unknown` if not
 
-                        NSNumber* authUpper = [authType valueForKey:@"AUTH_UPPER"];
+                        NSNumber* authUpper = authType[@"AUTH_UPPER"];
                         if (!authUpper)
                             ffStrbufSetStatic(&item->conn.security, "Insecure");
                         else
                         {
-                            int authUpperValue = [authUpper intValue];
+                            int authUpperValue = authUpper.intValue;
                             switch (authUpperValue)
                             {
                                 case 1:
@@ -203,6 +264,26 @@ const char* ffDetectWifi(FFlist* result)
                         }
                     }
                 }
+                else if (sp || (sp = getWifiInfoBySystemProfiler(inf.interfaceName)))
+                {
+                    ffStrbufSetS(&item->conn.security, [sp[@"spairport_security_mode"] UTF8String]);
+                    ffStrbufSubstrAfterFirstS(&item->conn.security, "_mode_");
+                    if (ffStrbufEqualS(&item->conn.security, "none"))
+                        ffStrbufSetStatic(&item->conn.security, "Insecure");
+                    else
+                    {
+                        ffStrbufReplaceAllC(&item->conn.security, '_', ' ');
+                        if (ffStrbufStartsWithS(&item->conn.security, "wpa"))
+                        {
+                            item->conn.security.chars[0] = 'W';
+                            item->conn.security.chars[1] = 'P';
+                            item->conn.security.chars[2] = 'A';
+                            char* sub = strchr(item->conn.security.chars, ' ');
+                            if (sub && sub[1])
+                                sub[1] = (char) toupper(sub[1]);
+                        }
+                    }
+                }
                 break;
             default:
                 ffStrbufAppendF(&item->conn.security, "Unknown (%ld)", inf.security);

src/detection/wifi/wifi_windows.c

@@ -43,7 +43,7 @@ static void convertIfStateToString(WLAN_INTERFACE_STATE state, FFstrbuf* result)
 
 const char* ffDetectWifi(FFlist* result)
 {
-    FF_LIBRARY_LOAD(wlanapi, NULL, "dlopen wlanapi"FF_LIBRARY_EXTENSION" failed", "wlanapi"FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD(wlanapi, "dlopen wlanapi" FF_LIBRARY_EXTENSION " failed", "wlanapi" FF_LIBRARY_EXTENSION, 1)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(wlanapi, WlanOpenHandle)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(wlanapi, WlanEnumInterfaces)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(wlanapi, WlanQueryInterface)

src/detection/zpool/zpool_linux.c

@@ -78,7 +78,7 @@ static int enumZpoolCallback(zpool_handle_t* zpool, void* param)
 
 const char* ffDetectZpool(FFlist* result /* list of FFZpoolResult */)
 {
-    FF_LIBRARY_LOAD(libzfs, NULL, "dlopen libzfs" FF_LIBRARY_EXTENSION " failed", "libzfs" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_LOAD(libzfs, "dlopen libzfs" FF_LIBRARY_EXTENSION " failed", "libzfs" FF_LIBRARY_EXTENSION, 4);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libzfs, libzfs_init);
 
     libzfs_handle_t* handle = fflibzfs_init();

src/fastfetch.c

@@ -353,7 +353,6 @@ static bool parseJsoncFile(const char* path)
             (error = ffOptionsParseLogoJsonConfig(&instance.config.logo, root)) ||
             (error = ffOptionsParseGeneralJsonConfig(&instance.config.general, root)) ||
             (error = ffOptionsParseDisplayJsonConfig(&instance.config.display, root)) ||
-            (error = ffOptionsParseLibraryJsonConfig(&instance.config.library, root)) ||
             false
         ) {
             fprintf(stderr, "JsonConfig Error: %s\n", error);
@@ -596,7 +595,6 @@ static void parseOption(FFdata* data, const char* key, const char* value)
         ffOptionsParseGeneralCommandLine(&instance.config.general, key, value) ||
         ffOptionsParseLogoCommandLine(&instance.config.logo, key, value) ||
         ffOptionsParseDisplayCommandLine(&instance.config.display, key, value) ||
-        ffOptionsParseLibraryCommandLine(&instance.config.library, key, value) ||
         ffParseModuleOptions(key, value)
     ) {}
 
@@ -688,7 +686,6 @@ static void writeConfigFile(FFdata* data, const FFstrbuf* filename)
     ffOptionsGenerateLogoJsonConfig(&instance.config.logo, doc);
     ffOptionsGenerateDisplayJsonConfig(&instance.config.display, doc);
     ffOptionsGenerateGeneralJsonConfig(&instance.config.general, doc);
-    ffOptionsGenerateLibraryJsonConfig(&instance.config.library, doc);
     ffMigrateCommandOptionToJsonc(data, doc);
 
     if (ffStrbufEqualS(filename, "-"))

src/fastfetch.h

@@ -27,7 +27,6 @@
 #include "options/logo.h"
 #include "options/display.h"
 #include "options/general.h"
-#include "options/library.h"
 
 typedef struct FFconfig
 {
@@ -35,7 +34,6 @@ typedef struct FFconfig
     FFOptionsDisplay display;
     FFOptionsGeneral general;
     FFOptionsModules modules;
-    FFOptionsLibrary library;
 } FFconfig;
 
 typedef struct FFstate

src/logo/ascii/lliurex.txt

@@ -0,0 +1,16 @@
+                    ~.       ........
+               ::~~ +=:    ~:========:~
+           ..~:+oo===oo:.~+oooooooooooo+~
+        .:+==ooooooooooo==ooooooooooooooo:
+      .:=oooooooooooooooooooooooooooooooo=
+..   .=oooooooooooooooooooooooooooooooooo=
+==. .+ooooooooooooooooooooooooooooooooooo=
+~+:~:oooooooooooooooooooooooooooooooooooo:
+ ~ooooooooooooooooooooooooooooooooooooo=:
+ ~oooooooooooooooooooooooooooooooooo==:.
+ .+oooooooooooooooooooooooooo=~::::~..
+  ~+oooooooooooooooooooooooo=:
+   .:=ooooooooooooooooooooo=:
+     .:==ooooooooooooooo==:.
+        ~~:===oooooo==+:~
+           ...~~:~::..

src/logo/builtin.c

@@ -2295,6 +2295,16 @@ static const FFlogo K[] = {
 };
 
 static const FFlogo L[] = {
+    // LainOS
+    {
+        .names = {"LainOS"},
+        .lines = FASTFETCH_DATATEXT_LOGO_LAINOS,
+        .colors = {
+            FF_COLOR_FG_BLUE,
+            FF_COLOR_FG_256 "14",
+            FF_COLOR_FG_WHITE,
+        },
+    },
     // LangitKetujuh
     {
         .names = {"langitketujuh", "l7"},
@@ -2469,6 +2479,16 @@ static const FFlogo L[] = {
         .colorKeys = FF_COLOR_FG_YELLOW,
         .colorTitle = FF_COLOR_FG_WHITE,
     },
+    // LliureX
+    {
+        .names = {"LliureX"},
+        .lines = FASTFETCH_DATATEXT_LOGO_LLIUREX,
+        .colors = {
+            FF_COLOR_FG_BLUE,
+        },
+        .colorKeys = FF_COLOR_FG_WHITE,
+        .colorTitle = FF_COLOR_FG_BLUE,
+    },
     // LMDE
     {
         .names = {"LMDE"},
@@ -2480,16 +2500,6 @@ static const FFlogo L[] = {
         .colorKeys = FF_COLOR_FG_GREEN,
         .colorTitle = FF_COLOR_FG_WHITE,
     },
-    // LainOS
-    {
-        .names = {"LainOS"},
-        .lines = FASTFETCH_DATATEXT_LOGO_LAINOS,
-        .colors = {
-            FF_COLOR_FG_BLUE,
-            FF_COLOR_FG_256 "14",
-            FF_COLOR_FG_WHITE,
-        },
-    },
     // Loc-OS
     {
         .names = {"locos", "loc-os", "Loc-OS Linux"},
@@ -4278,9 +4288,9 @@ static const FFlogo T[] = {
             FF_COLOR_FG_GREEN,
         },
     },
-    // TorizonCore
+    // Torizon OS
     {
-        .names = {"TorizonCore"},
+        .names = {"Torizon OS", "TorizonCore"},
         .lines = FASTFETCH_DATATEXT_LOGO_TORIZONCORE,
         .colors = {
             FF_COLOR_FG_LIGHT_WHITE,

src/logo/image/im6.c

@@ -14,7 +14,7 @@ static void* logoResize(const void* image, size_t width, size_t height, void* ex
 
 FFLogoImageResult ffLogoPrintImageIM6(FFLogoRequestData* requestData)
 {
-    FF_LIBRARY_LOAD(imageMagick, &instance.config.library.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-6.Q16HDRI" FF_LIBRARY_EXTENSION, 8, "libMagickCore-6.Q16" FF_LIBRARY_EXTENSION, 8)
+    FF_LIBRARY_LOAD(imageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-6.Q16HDRI" FF_LIBRARY_EXTENSION, 8, "libMagickCore-6.Q16" FF_LIBRARY_EXTENSION, 8)
     FF_LIBRARY_LOAD_SYMBOL_ADDRESS(imageMagick, ffResizeImage, ResizeImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
 
     FFLogoImageResult result = ffLogoPrintImageImpl(requestData, &(FFIMData) {

src/logo/image/im7.c

@@ -14,7 +14,7 @@ static void* logoResize(const void* image, size_t width, size_t height, void* ex
 
 FFLogoImageResult ffLogoPrintImageIM7(FFLogoRequestData* requestData)
 {
-    FF_LIBRARY_LOAD(imageMagick, &instance.config.library.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR,
+    FF_LIBRARY_LOAD(imageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR,
         "libMagickCore-7.Q16HDRI" FF_LIBRARY_EXTENSION, 11,
         "libMagickCore-7.Q16" FF_LIBRARY_EXTENSION, 11,
         "libMagickCore-7.Q16HDRI-10" FF_LIBRARY_EXTENSION, -1 // Required for Windows

src/logo/image/image.c

@@ -3,6 +3,7 @@
 #include "common/printing.h"
 #include "util/stringUtils.h"
 #include "util/base64.h"
+#include "detection/terminalsize/terminalsize.h"
 
 #include <limits.h>
 #include <math.h>
@@ -77,7 +78,7 @@ static bool printImageIterm(bool printError)
         if (options->position == FF_LOGO_POSITION_LEFT || options->position == FF_LOGO_POSITION_RIGHT)
         {
             uint16_t X = 0, Y = 0;
-            const char* error = ffGetTerminalResponse("\e[6n", "\e[%hu;%huR", &Y, &X);
+            const char* error = ffGetTerminalResponse("\e[6n", 2, "%*[^0-9]%hu;%huR", &Y, &X);
             if (error)
             {
                 fprintf(stderr, "\nLogo (iterm): fail to query cursor position: %s\n", error);
@@ -202,7 +203,7 @@ static bool printImageKittyDirect(bool printError)
         if (options->position == FF_LOGO_POSITION_LEFT || options->position == FF_LOGO_POSITION_RIGHT)
         {
             uint16_t X = 0, Y = 0;
-            const char* error = ffGetTerminalResponse("\e[6n", "\e[%hu;%huR", &Y, &X);
+            const char* error = ffGetTerminalResponse("\e[6n", 2, "%*[^0-9]%hu;%huR", &Y, &X);
             if (error)
             {
                 if (printError)
@@ -304,7 +305,7 @@ static inline char* realpath(const char* restrict file_name, char* restrict reso
 
 static bool compressBlob(void** blob, size_t* length)
 {
-    FF_LIBRARY_LOAD(zlib, &instance.config.library.libZ, false, "libz" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(zlib, false, "libz" FF_LIBRARY_EXTENSION, 2)
     FF_LIBRARY_LOAD_SYMBOL(zlib, compressBound, false)
     FF_LIBRARY_LOAD_SYMBOL(zlib, compress2, false)
 
@@ -489,7 +490,7 @@ static bool printImageKitty(FFLogoRequestData* requestData, const ImageData* ima
 #include <chafa.h>
 static bool printImageChafa(FFLogoRequestData* requestData, const ImageData* imageData)
 {
-    FF_LIBRARY_LOAD(chafa, &instance.config.library.libChafa, false,
+    FF_LIBRARY_LOAD(chafa, false,
         "libchafa" FF_LIBRARY_EXTENSION, 1,
         "libchafa-0" FF_LIBRARY_EXTENSION, -1 // Required for Windows
     )
@@ -835,38 +836,25 @@ static bool printCached(FFLogoRequestData* requestData)
 
 static bool getCharacterPixelDimensions(FFLogoRequestData* requestData)
 {
-    #ifndef _WIN32
-
-    struct winsize winsize;
-
-    //Initialize every member to 0, because it isn't guaranteed that every terminal sets them all
-    memset(&winsize, 0, sizeof(struct winsize));
-
-    ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
-
-    if(winsize.ws_row == 0 || winsize.ws_col == 0)
-        ffGetTerminalResponse("\033[18t", "\033[8;%hu;%hut", &winsize.ws_row, &winsize.ws_col);
-
-    if(winsize.ws_row == 0 || winsize.ws_col == 0)
-        return false;
-
-    if(winsize.ws_ypixel == 0 || winsize.ws_xpixel == 0)
-        ffGetTerminalResponse("\033[14t", "\033[4;%hu;%hut", &winsize.ws_ypixel, &winsize.ws_xpixel);
-
-    requestData->characterPixelWidth = winsize.ws_xpixel / (double) winsize.ws_col;
-    requestData->characterPixelHeight = winsize.ws_ypixel / (double) winsize.ws_row;
-
-    #else
+    #ifdef _WIN32
 
     CONSOLE_FONT_INFO cfi;
-    if(GetCurrentConsoleFont(GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &cfi) == FALSE) // Only works for ConHost
-        return false;
-
-    requestData->characterPixelWidth = cfi.dwFontSize.X;
-    requestData->characterPixelHeight = cfi.dwFontSize.Y;
-
+    if(GetCurrentConsoleFont(GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &cfi)) // Only works for ConHost
+    {
+        requestData->characterPixelWidth = cfi.dwFontSize.X;
+        requestData->characterPixelHeight = cfi.dwFontSize.Y;
+    }
+    if (requestData->characterPixelWidth > 1.0 && requestData->characterPixelHeight > 1.0)
+        return true;
     #endif
 
+    FFTerminalSizeResult termSize = {};
+    if (ffDetectTerminalSize(&termSize))
+    {
+        requestData->characterPixelWidth = termSize.width / (double) termSize.columns;
+        requestData->characterPixelHeight = termSize.height / (double) termSize.rows;
+    }
+
     return requestData->characterPixelWidth > 1.0 && requestData->characterPixelHeight > 1.0;
 }
 

src/logo/logo.c

@@ -40,7 +40,7 @@ static bool ffLogoPrintCharsRaw(const char* data, size_t length, bool printError
             if (!options->width)
             {
                 if (printError)
-                    fputs("Logo (iterm): Must set logo width when using position right\n", stderr);
+                    fputs("Logo (image-raw): Must set logo width when using position right\n", stderr);
                 return false;
             }
             ffStrbufAppendF(&buf, "\e[2J\e[3J\e[%u;9999999H\e[%uD", (unsigned) options->paddingTop + 1, (unsigned) options->paddingRight + options->width);
@@ -51,7 +51,8 @@ static bool ffLogoPrintCharsRaw(const char* data, size_t length, bool printError
         if (options->position == FF_LOGO_POSITION_LEFT || options->position == FF_LOGO_POSITION_RIGHT)
         {
             uint16_t X = 0, Y = 0;
-            const char* error = ffGetTerminalResponse("\e[6n", "\e[%hu;%huR", &Y, &X);
+            // Windows Terminal doesn't report `\e` for some reason
+            const char* error = ffGetTerminalResponse("\e[6n", 2, "%*[^0-9]%hu;%huR", &Y, &X); // %*[^0-9]: ignore optional \e[
             if (error)
             {
                 if (printError)
@@ -59,7 +60,11 @@ static bool ffLogoPrintCharsRaw(const char* data, size_t length, bool printError
                 return true;
             }
             if (options->position == FF_LOGO_POSITION_LEFT)
+            {
+                if (options->width + options->paddingLeft > X)
+                    X = (uint16_t) (options->width + options->paddingLeft);
                 instance.state.logoWidth = X + instance.config.logo.paddingRight - 1;
+            }
             instance.state.logoHeight = Y;
             fputs("\e[H", stdout);
         }

src/modules/battery/battery.c

@@ -23,8 +23,8 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
     {
         ffStrbufClear(&key);
         FF_PARSE_FORMAT_STRING_CHECKED(&key, &options->moduleArgs.key, 2, ((FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_UINT8, &index, "index"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName, "name"},
+            FF_FORMAT_ARG(index, "index"),
+            FF_FORMAT_ARG(result->modelName, "name"),
         }));
     }
 
@@ -81,16 +81,16 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
         FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
         ffTempsAppendNum(result->temperature, &tempStr, options->tempConfig, &options->moduleArgs);
         FF_PRINT_FORMAT_CHECKED(key.chars, index, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_BATTERY_NUM_FORMAT_ARGS, ((FFformatarg[]) {
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer, "manufacturer"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName, "model-name"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result->technology, "technology"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &capacityNum, "capacity"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result->status, "status"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr, "temperature"},
-            {FF_FORMAT_ARG_TYPE_UINT, &result->cycleCount, "cycle-count"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result->serial, "serial"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufactureDate, "manufacture-date"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &capacityBar, "capacity-bar"},
+            FF_FORMAT_ARG(result->manufacturer, "manufacturer"),
+            FF_FORMAT_ARG(result->modelName, "model-name"),
+            FF_FORMAT_ARG(result->technology, "technology"),
+            FF_FORMAT_ARG(capacityNum, "capacity"),
+            FF_FORMAT_ARG(result->status, "status"),
+            FF_FORMAT_ARG(tempStr, "temperature"),
+            FF_FORMAT_ARG(result->cycleCount, "cycle-count"),
+            FF_FORMAT_ARG(result->serial, "serial"),
+            FF_FORMAT_ARG(result->manufactureDate, "manufacture-date"),
+            FF_FORMAT_ARG(capacityBar, "capacity-bar"),
         }));
     }
 }

src/modules/bios/bios.c

@@ -44,8 +44,8 @@ void ffPrintBios(FFBiosOptions* options)
     {
         ffStrbufClear(&key);
         FF_PARSE_FORMAT_STRING_CHECKED(&key, &options->moduleArgs.key, 2, ((FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.type, "type"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &options->moduleArgs.keyIcon, "icon"},
+            FF_FORMAT_ARG(bios.type, "type"),
+            FF_FORMAT_ARG(options->moduleArgs.keyIcon, "icon"),
         }));
     }
 
@@ -61,11 +61,11 @@ void ffPrintBios(FFBiosOptions* options)
     else
     {
         FF_PRINT_FORMAT_CHECKED(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_BIOS_NUM_FORMAT_ARGS, ((FFformatarg[]) {
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.date, "date"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.release, "release"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.vendor, "vendor"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.version, "version"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.type, "type"},
+            FF_FORMAT_ARG(bios.date, "date"),
+            FF_FORMAT_ARG(bios.release, "release"),
+            FF_FORMAT_ARG(bios.vendor, "vendor"),
+            FF_FORMAT_ARG(bios.version, "version"),
+            FF_FORMAT_ARG(bios.type, "type"),
         }));
     }
 

src/modules/bluetooth/bluetooth.c

@@ -35,12 +35,12 @@ static void printDevice(FFBluetoothOptions* options, const FFBluetoothResult* de
         ffPercentAppendBar(&percentageBar, device->battery, options->percent, &options->moduleArgs);
 
         FF_PRINT_FORMAT_CHECKED(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_BLUETOOTH_NUM_FORMAT_ARGS, ((FFformatarg[]) {
-            {FF_FORMAT_ARG_TYPE_STRBUF, &device->name, "name"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &device->address, "address"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &device->type, "type"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &percentageNum, "battery-percentage"},
-            {FF_FORMAT_ARG_TYPE_BOOL, &device->connected, "connected"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &percentageBar, "battery-percentage-bar"},
+            FF_FORMAT_ARG(device->name, "name"),
+            FF_FORMAT_ARG(device->address, "address"),
+            FF_FORMAT_ARG(device->type, "type"),
+            FF_FORMAT_ARG(percentageNum, "battery-percentage"),
+            FF_FORMAT_ARG(device->connected, "connected"),
+            FF_FORMAT_ARG(percentageBar, "battery-percentage-bar"),
         }));
     }
 }

src/modules/bluetoothradio/bluetoothradio.c

@@ -18,9 +18,9 @@ static void printDevice(FFBluetoothRadioOptions* options, const FFBluetoothRadio
     else
     {
         FF_PARSE_FORMAT_STRING_CHECKED(&key, &options->moduleArgs.key, 3, ((FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_UINT, &index, "index"},
-            {FF_FORMAT_ARG_TYPE_STRING, radio->name.chars, "name"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &options->moduleArgs.keyIcon, "icon"},
+            FF_FORMAT_ARG(index, "index"),
+            FF_FORMAT_ARG(radio->name, "name"),
+            FF_FORMAT_ARG(options->moduleArgs.keyIcon, "icon"),
         }));
     }
 
@@ -56,14 +56,14 @@ static void printDevice(FFBluetoothRadioOptions* options, const FFBluetoothRadio
     else
     {
         FF_PRINT_FORMAT_CHECKED(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_BLUETOOTHRADIO_NUM_FORMAT_ARGS, ((FFformatarg[]) {
-            {FF_FORMAT_ARG_TYPE_STRBUF, &radio->name, "name"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &radio->address, "address"},
-            {FF_FORMAT_ARG_TYPE_INT, &radio->lmpVersion, "lmp-version"},
-            {FF_FORMAT_ARG_TYPE_INT, &radio->lmpSubversion, "lmp-subversion"},
-            {FF_FORMAT_ARG_TYPE_STRING, version, "version"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &radio->vendor, "vendor"},
-            {FF_FORMAT_ARG_TYPE_BOOL, &radio->discoverable, "discoverable"},
-            {FF_FORMAT_ARG_TYPE_BOOL, &radio->connectable, "connectable"},
+            FF_FORMAT_ARG(radio->name, "name"),
+            FF_FORMAT_ARG(radio->address, "address"),
+            FF_FORMAT_ARG(radio->lmpVersion, "lmp-version"),
+            FF_FORMAT_ARG(radio->lmpSubversion, "lmp-subversion"),
+            FF_FORMAT_ARG(version, "version"),
+            FF_FORMAT_ARG(radio->vendor, "vendor"),
+            FF_FORMAT_ARG(radio->discoverable, "discoverable"),
+            FF_FORMAT_ARG(radio->connectable, "connectable"),
         }));
     }
 }

src/modules/board/board.c

@@ -38,10 +38,10 @@ void ffPrintBoard(FFBoardOptions* options)
     else
     {
         FF_PRINT_FORMAT_CHECKED(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_BOARD_NUM_FORMAT_ARGS, ((FFformatarg[]) {
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result.name, "name"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result.vendor, "vendor"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result.version, "version"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &result.serial, "serial"},
+            FF_FORMAT_ARG(result.name, "name"),
+            FF_FORMAT_ARG(result.vendor, "vendor"),
+            FF_FORMAT_ARG(result.version, "version"),
+            FF_FORMAT_ARG(result.serial, "serial"),
         }));
     }
 

src/modules/bootmgr/bootmgr.c

@@ -40,10 +40,10 @@ void ffPrintBootmgr(FFBootmgrOptions* options)
     else
     {
         FF_PRINT_FORMAT_CHECKED(FF_BOOTMGR_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_BOOTMGR_NUM_FORMAT_ARGS, ((FFformatarg[]) {
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bootmgr.name, "name"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &bootmgr.firmware, "firmware-path"},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &firmwareName, "firmware-name"},
-            {FF_FORMAT_ARG_TYPE_BOOL, &bootmgr.secureBoot, "secure-boot"},
+            FF_FORMAT_ARG(bootmgr.name, "name"),
+            FF_FORMAT_ARG(bootmgr.firmware, "firmware-path"),
+            FF_FORMAT_ARG(firmwareName, "firmware-name"),
+            FF_FORMAT_ARG(bootmgr.secureBoot, "secure-boot"),
         }));
     }