Merge pull request #1056 from fastfetch-cli/dev

Release: v2.17.1

.github/workflows/ci.yml

@@ -197,6 +197,41 @@ jobs:
           name: fastfetch-linux-armv7
           path: ./fastfetch-*.*
 
+  linux-riscv64:
+    name: Linux-riscv64
+    runs-on: ubuntu-22.04
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@v2
+        id: runcmd
+        with:
+          arch: riscv64
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y cmake make g++ libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libdrm-dev libddcutil-dev libchafa-dev directx-headers-dev rpm
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-linux-riscv64
+          path: ./fastfetch-*.*
+
   musl-amd64:
     name: Musl-amd64
     runs-on: ubuntu-latest
@@ -333,6 +368,40 @@ jobs:
           name: fastfetch-macos-universal
           path: ./fastfetch-*.*
 
+  sunos-amd64:
+    runs-on: ubuntu-latest
+    name: SunOS-amd64
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - uses: actions/checkout@v4
+      - name: run VM
+        uses: vmactions/omnios-vm@v1
+        with:
+          usesh: true
+          prepare: |
+            uname -a
+            pkg update --accept
+            pkg install gcc13 cmake git pkg-config glib2 dbus sqlite-3 imagemagick
+
+          run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch
+            time ./fastfetch --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+            cpack
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-sunos-amd64
+          path: ./fastfetch-*.*
+
   freebsd-amd64:
     name: FreeBSD-amd64
     runs-on: ubuntu-latest
@@ -425,7 +494,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
+          install: git mingw-w64-clang-x86_64-7zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-vulkan-headers mingw-w64-clang-x86_64-opencl-icd mingw-w64-clang-x86_64-opencl-headers mingw-w64-clang-x86_64-cppwinrt
 
       - name: print msys version
         run: uname -a
@@ -439,6 +508,9 @@ jobs:
       - name: copy necessary dlls
         run: cp /clang64/bin/{OpenCL,vulkan-1}.dll .
 
+      - name: download amd_ags
+        run: curl -LO https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/raw/master/ags_lib/lib/amd_ags_x64.dll
+
       - name: list features
         run: ./fastfetch --list-features
 
@@ -458,10 +530,10 @@ jobs:
         run: ctest
 
       - name: create zip archive
-        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-amd64.zip *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-amd64.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets
 
       - name: create 7z archive
-        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-amd64.7z *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-amd64.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets
 
       - name: upload artifacts
         uses: actions/upload-artifact@v4
@@ -487,7 +559,7 @@ jobs:
         with:
           msystem: CLANG32
           update: true
-          install: git p7zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-vulkan-headers mingw-w64-clang-i686-opencl-icd
+          install: git p7zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-vulkan-headers mingw-w64-clang-i686-opencl-icd mingw-w64-clang-i686-opencl-headers
 
       - name: print msys version
         run: uname -a
@@ -509,6 +581,9 @@ jobs:
       - name: copy necessary dlls
         run: cp /clang32/bin/{OpenCL,vulkan-1}.dll .
 
+      - name: download amd_ags
+        run: curl -LO https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/raw/master/ags_lib/lib/amd_ags_x86.dll
+
       - name: run fastfetch
         run: time ./fastfetch -c presets/ci.jsonc
 
@@ -525,10 +600,10 @@ jobs:
         run: ctest
 
       - name: create zip archive
-        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-i686.zip *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-i686.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets
 
       - name: create 7z archive
-        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-i686.7z *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-i686.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets
 
       - name: upload artifacts
         uses: actions/upload-artifact@v4
@@ -544,11 +619,13 @@ jobs:
       - linux-amd64
       - linux-aarch64
       - linux-armv7
+      - linux-riscv64
       - musl-amd64
       - musl-aarch64
       - macos-universal
       - freebsd-amd64
       - freebsd-aarch64
+      - sunos-amd64
       - windows-amd64
       - windows-i686
     permissions:

CHANGELOG.md

@@ -1,3 +1,93 @@
+# 2.17.1
+
+Hotfix for a regression that breaks Qt font detection
+
+Bugfixes:
+* Don't generate and install `libffwinrt.dll.a` on MinGW (Windows)
+* Fix building on Windows when imagemagick support is enabled (Logo, Windows)
+* Don't print GPU frequency with `--gpu-temp` for Nvidia cards (#1052, GPU)
+    * `--gpu-driver-specific` needs to be specified
+* Print formatted size when `--gpu-format` is used (#1052, GPU)
+* Ignore QVariant format; fix unreadable Qt font (#1053, Theme, Linux)
+* Fix segfaults with `--show-errors` and an invalid module (#1055)
+
+# 2.17.0
+
+Changes:
+* CMake option `ENABLE_PROPRIETARY_GPU_DRIVER_API` is removed. The GPU driver APIs are now enabled by default.
+    * The option was introduced to reduce the license concerns. Since all non MIT proprietary code has been rewritten manually from scratch, it is no longer necessary.
+    * See <https://github.com/fastfetch-cli/fastfetch/issues/533#issuecomment-2122830958> for detail
+* Option `--logo-separate true` is changed to `--logo-position top` for better readability
+    * Builtin ascii logos can be positioned on the right side now with`--logo-position right`
+
+Features:
+* Add support for `--gpu-detection-method opencl` which uses OpenCL to detect GPUs.
+* Support detecting CPU cache size by using SMBIOS as fallback (CPUCache)
+* Support GPU detection (SunOS)
+* Support GPU type detection with AMD GPU driver (GPU, Windows)
+* Add fast path of version and font detection for kitty (Terminal / TerminalFont)
+* Make sure `stdin` and `stdout` are TTYs when querying terminal
+    * So modules like `TerminalSize` should work when `stdin` or `stdout` is redirected
+* Support argument truncation in `--<module>-format` (#1043)
+    * See `fastfetch --help format` for detail
+* Improve Qt theme detection (#1047, Theme, Linux)
+* Add new JSON config option `general.preRun`, which is executed before fastfetch prints output.
+    * It can be used to generate a temp logo file. For example  
+```jsonc
+{
+    "general": {
+        "preRun": "kitten icat --align=left /path/to/image > /tmp/logo.kitty"
+    },
+    "logo": {
+        "source": "/tmp/logo.kitty",
+        "type": "raw"
+    }
+}
+```
+
+Bugfixes:
+* Fix invalid path (#1031, LM, Linux)
+* Fix VMEM detection for Nvidia GPU (requires `--gpu-driver-specific`) (GPU)
+* Fix AMD `--gpu-driver-specific` for AMD cards (#1032, GPU, Windows)
+* Use Coordinated Universal Time rather than timezone-varying local date (#1046)
+
+Logo:
+* Fix colors of Asahi Linux
+
+# 2.16.0
+
+This release added basic support for SunOS (Solaris, illumos). The binaries provided in the release lack a few useful features (such as Display detection). People who use SunOS should consider building fastfetch themselves.
+
+Changes:
+* Fastfetch now prefers `/etc/os-release` over `/etc/lsb-release` when detecting distro info. 
+    * This may break some distros (notably some debian based distros). File a bug with the content of `os-release` and `lsb-release` if it breaks your distro.
+
+Features:
+* Support Media detection in Windows (Media / Player, Windows)
+    * Requires Windows 10 and later
+* Add new option `--users-myself-only` to display current login user only (Users)
+* Add code name of macOS Sequoia (OS, macOS)
+* Add new module `DNS` to show active DNS servers (DNS)
+* Add new option `--loadavg-compact`. Defaults to true (Loadavg)
+    * Use `--loadavg-compact false` to display load averages in different lines
+* Detect MTU size (LocalIP)
+* Support version detection of pluma, which is the default editor of OpenIndiana (Editor)
+* Print used OGL library, eg EGL, GLX or OSMesa (OpenGL)
+
+Bugfixes:
+* Report error if cache size is unavailable (CPUCache, Android)
+* Trim white spaces in device name (Sound, Linux, #1005)
+* Fix `display.bar.border{Left,Right}` doesn't work in JSON config files (Config)
+* Fix invalid call to `realpath(3)` (Platform, Linux)
+* Fix result calculation (CPUUsage, FreeBSD)
+
+Logos:
+* Add Mauna
+* Add Tuxdeo
+* Add Manjaro ARM
+* Add RedOS
+* Add Arch3
+
 # 2.15.0
 
 Changes:

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.15.0
+    VERSION 2.17.1
     LANGUAGES C
     DESCRIPTION "Fast neofetch-like system information tool"
     HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -18,6 +18,8 @@ elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
     set(LINUX TRUE CACHE BOOL "..." FORCE) # LINUX means GNU/Linux, not just the kernel
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
     set(BSD TRUE CACHE BOOL "..." FORCE)
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
+    set(SunOS TRUE CACHE BOOL "..." FORCE)
 elseif(NOT APPLE AND NOT WIN32)
     message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}")
 endif()
@@ -42,37 +44,36 @@ include(CheckIncludeFile)
 
 include(CMakeDependentOption)
 
-cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE OR BSD OR WIN32 OR ANDROID" OFF)
+cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE OR BSD OR WIN32 OR ANDROID OR SunOS" OFF)
 cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XCB "Enable xcb" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_X11 "Enable x11" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_DRM "Enable libdrm" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR BSD OR APPLE" OFF)
+cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_XCB "Enable xcb" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_X11 "Enable x11" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_DRM "Enable libdrm" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR BSD OR APPLE OR SunOS" OFF)
 cmake_dependent_option(ENABLE_RPM "Enable rpm" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR BSD OR APPLE OR WIN32" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR BSD OR APPLE" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR BSD OR APPLE OR WIN32 OR SunOS" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR BSD OR APPLE OR SunOS" OFF)
 cmake_dependent_option(ENABLE_CHAFA "Enable chafa" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
 cmake_dependent_option(ENABLE_ZLIB "Enable zlib" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
-cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR BSD OR WIN32" OFF)
+cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR BSD OR WIN32 OR ANDROID OR SunOS" OFF)
 cmake_dependent_option(ENABLE_LIBNM "Enable libnm" ON "LINUX" OFF)
 cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)
-cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR SunOS" OFF)
 cmake_dependent_option(ENABLE_DDCUTIL "Enable ddcutil" ON "LINUX" OFF)
 cmake_dependent_option(ENABLE_DIRECTX_HEADERS "Enable DirectX headers for WSL" ON "LINUX" OFF)
 cmake_dependent_option(ENABLE_THREADS "Enable multithreading" ON "Threads_FOUND" OFF)
 
 option(ENABLE_SYSTEM_YYJSON "Use system provided (instead of fastfetch embedded) yyjson library" OFF)
 option(ENABLE_ASAN "Build fastfetch with ASAN (address sanitizer)" OFF)
-option(ENABLE_PROPRIETARY_GPU_DRIVER_API "Enable proprietary GPU driver API (NVML, IGCL and AGS)" ON)
 option(BUILD_TESTS "Build tests" OFF) # Also create test executables
 option(SET_TWEAK "Add tweak to project version" ON) # This is set to off by github actions for release builds
 option(IS_MUSL "Build with musl libc" OFF) # Used by Github Actions
@@ -118,7 +119,7 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} -Werror=incompatible-pointe
 if(WIN32 OR ENABLE_DIRECTX_HEADERS)
     enable_language(CXX)
     set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} -fno-exceptions -fno-rtti")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS}")
 endif()
 
 if(WIN32)
@@ -254,7 +255,7 @@ if(APPLE)
     configure_file(src/util/apple/Info.plist.in Info.plist @ONLY)
 endif()
 
-string(TIMESTAMP FASTFETCH_BUILD_DATE "%d %B %Y")
+string(TIMESTAMP FASTFETCH_BUILD_DATE "%d %B %Y" UTC)
 configure_file(doc/fastfetch.1.in fastfetch.1 @ONLY)
 
 ####################
@@ -340,6 +341,7 @@ set(LIBFASTFETCH_SRC
     src/modules/de/de.c
     src/modules/disk/disk.c
     src/modules/diskio/diskio.c
+    src/modules/dns/dns.c
     src/modules/editor/editor.c
     src/modules/font/font.c
     src/modules/gpu/gpu.c
@@ -417,6 +419,7 @@ if(LINUX)
         src/detection/cursor/cursor_linux.c
         src/detection/bluetooth/bluetooth_linux.c
         src/detection/disk/disk_linux.c
+        src/detection/dns/dns_linux.c
         src/detection/physicaldisk/physicaldisk_linux.c
         src/detection/physicalmemory/physicalmemory_linux.c
         src/detection/diskio/diskio_linux.c
@@ -487,6 +490,7 @@ elseif(ANDROID)
         src/detection/cursor/cursor_nosupport.c
         src/detection/cpuusage/cpuusage_linux.c
         src/detection/disk/disk_linux.c
+        src/detection/dns/dns_linux.c
         src/detection/physicaldisk/physicaldisk_linux.c
         src/detection/physicalmemory/physicalmemory_nosupport.c
         src/detection/diskio/diskio_linux.c
@@ -544,10 +548,11 @@ elseif(BSD)
         src/detection/brightness/brightness_bsd.c
         src/detection/chassis/chassis_bsd.c
         src/detection/cpu/cpu_bsd.c
-        src/detection/cpucache/cpucache_nosupport.c
+        src/detection/cpucache/cpucache_shared.c
         src/detection/cpuusage/cpuusage_bsd.c
         src/detection/cursor/cursor_linux.c
         src/detection/disk/disk_bsd.c
+        src/detection/dns/dns_linux.c
         src/detection/physicaldisk/physicaldisk_bsd.c
         src/detection/physicalmemory/physicalmemory_linux.c
         src/detection/diskio/diskio_bsd.c
@@ -619,6 +624,7 @@ elseif(APPLE)
         src/detection/cpuusage/cpuusage_apple.c
         src/detection/cursor/cursor_apple.m
         src/detection/disk/disk_bsd.c
+        src/detection/dns/dns_linux.c
         src/detection/physicaldisk/physicaldisk_apple.c
         src/detection/physicalmemory/physicalmemory_apple.m
         src/detection/diskio/diskio_apple.c
@@ -684,6 +690,7 @@ elseif(WIN32)
         src/detection/physicaldisk/physicaldisk_windows.c
         src/detection/diskio/diskio_windows.c
         src/detection/displayserver/displayserver_windows.c
+        src/detection/dns/dns_windows.c
         src/detection/font/font_windows.c
         src/detection/gpu/gpu_windows.c
         src/detection/host/host_windows.c
@@ -695,7 +702,7 @@ elseif(WIN32)
         src/detection/locale/locale_windows.c
         src/detection/localip/localip_windows.c
         src/detection/gamepad/gamepad_windows.c
-        src/detection/media/media_nosupport.c
+        src/detection/media/media_windows.c
         src/detection/memory/memory_windows.c
         src/detection/physicalmemory/physicalmemory_linux.c
         src/detection/monitor/monitor_windows.c
@@ -727,6 +734,77 @@ elseif(WIN32)
         src/util/windows/wmi.cpp
         src/util/platform/FFPlatform_windows.c
     )
+elseif(SunOS)
+    list(APPEND LIBFASTFETCH_SRC
+        src/common/dbus.c
+        src/common/io/io_unix.c
+        src/common/netif/netif_bsd.c
+        src/common/networking_linux.c
+        src/common/processing_linux.c
+        src/detection/battery/battery_nosupport.c
+        src/detection/bios/bios_windows.c
+        src/detection/board/board_windows.c
+        src/detection/bootmgr/bootmgr_nosupport.c
+        src/detection/brightness/brightness_nosupport.c
+        src/detection/chassis/chassis_windows.c
+        src/detection/cpu/cpu_sunos.c
+        src/detection/cpucache/cpucache_shared.c
+        src/detection/cpuusage/cpuusage_sunos.c
+        src/detection/cursor/cursor_linux.c
+        src/detection/bluetooth/bluetooth_nosupport.c
+        src/detection/disk/disk_sunos.c
+        src/detection/dns/dns_linux.c
+        src/detection/physicaldisk/physicaldisk_nosupport.c
+        src/detection/physicalmemory/physicalmemory_linux.c
+        src/detection/diskio/diskio_sunos.c
+        src/detection/displayserver/linux/displayserver_linux.c
+        src/detection/displayserver/linux/drm.c
+        src/detection/displayserver/linux/wayland/wayland.c
+        src/detection/displayserver/linux/wayland/global-output.c
+        src/detection/displayserver/linux/wayland/zwlr-output.c
+        src/detection/displayserver/linux/wayland/wlr-output-management-unstable-v1-protocol.c
+        src/detection/displayserver/linux/wmde.c
+        src/detection/displayserver/linux/xcb.c
+        src/detection/displayserver/linux/xlib.c
+        src/detection/font/font_linux.c
+        src/detection/gpu/gpu_sunos.c
+        src/detection/gpu/gpu_pci.c
+        src/detection/gtk_qt/gtk.c
+        src/detection/host/host_windows.c
+        src/detection/icons/icons_linux.c
+        src/detection/initsystem/initsystem_linux.c
+        src/detection/libc/libc_nosupport.c
+        src/detection/lm/lm_nosupport.c
+        src/detection/loadavg/loadavg_sunos.c
+        src/detection/locale/locale_linux.c
+        src/detection/localip/localip_linux.c
+        src/detection/gamepad/gamepad_nosupport.c
+        src/detection/media/media_linux.c
+        src/detection/memory/memory_sunos.c
+        src/detection/monitor/monitor_nosupport.c
+        src/detection/netio/netio_sunos.c
+        src/detection/opengl/opengl_linux.c
+        src/detection/os/os_sunos.c
+        src/detection/packages/packages_sunos.c
+        src/detection/poweradapter/poweradapter_nosupport.c
+        src/detection/processes/processes_linux.c
+        src/detection/gtk_qt/qt.c
+        src/detection/sound/sound_linux.c
+        src/detection/swap/swap_sunos.c
+        src/detection/terminalfont/terminalfont_linux.c
+        src/detection/terminalshell/terminalshell_linux.c
+        src/detection/terminalsize/terminalsize_linux.c
+        src/detection/theme/theme_linux.c
+        src/detection/uptime/uptime_sunos.c
+        src/detection/users/users_linux.c
+        src/detection/wallpaper/wallpaper_linux.c
+        src/detection/wifi/wifi_nosupport.c
+        src/detection/wm/wm_nosupport.c
+        src/detection/de/de_linux.c
+        src/detection/wmtheme/wmtheme_linux.c
+        src/detection/camera/camera_nosupport.c
+        src/util/platform/FFPlatform_unix.c
+    )
 endif()
 
 if(ENABLE_DIRECTX_HEADERS)
@@ -734,15 +812,13 @@ if(ENABLE_DIRECTX_HEADERS)
     list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_wsl.cpp)
 endif()
 
-if(ENABLE_PROPRIETARY_GPU_DRIVER_API AND (LINUX OR BSD OR WIN32))
-    message(STATUS "Enabling proprietary GPU driver API")
-    if(LINUX OR BSD OR WIN32)
-        list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_nvidia.c)
-    endif()
-    if(WIN32)
-        list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_intel.c)
-        list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_amd.c)
-    endif()
+# Proprietary GPU driver APIs
+if(LINUX OR BSD OR WIN32)
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_nvidia.c)
+endif()
+if(WIN32)
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_intel.c)
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_amd.c)
 endif()
 
 include(CheckFunctionExists)
@@ -771,10 +847,6 @@ add_library(libfastfetch OBJECT
     ${LIBFASTFETCH_SRC}
 )
 
-if(ENABLE_PROPRIETARY_GPU_DRIVER_API AND (LINUX OR BSD OR WIN32))
-    target_compile_definitions(libfastfetch PRIVATE FF_USE_PROPRIETARY_GPU_DRIVER_API)
-endif()
-
 if(yyjson_FOUND)
     target_compile_definitions(libfastfetch PRIVATE FF_USE_SYSTEM_YYJSON)
     target_link_libraries(libfastfetch PRIVATE yyjson::yyjson)
@@ -814,6 +886,8 @@ if(WIN32)
     target_compile_definitions(libfastfetch PUBLIC WIN32_LEAN_AND_MEAN=1)
 elseif(APPLE)
     target_compile_definitions(libfastfetch PUBLIC _DARWIN_C_SOURCE)
+elseif(SunOS)
+    target_compile_definitions(libfastfetch PUBLIC __EXTENSIONS__ _POSIX_C_SOURCE=1)
 endif()
 
 if(HAVE_STATX)
@@ -1042,6 +1116,13 @@ elseif(BSD)
         PRIVATE "usbhid"
         PRIVATE "geom"
     )
+elseif(SunOS)
+    target_link_libraries(libfastfetch
+        PRIVATE "m"
+        PRIVATE "socket"
+        PRIVATE "kstat"
+        PRIVATE "proc"
+    )
 elseif(ANDROID)
     CHECK_LIBRARY_EXISTS(-l:libandroid-wordexp.a wordexp "" HAVE_LIBANDROID_WORDEXP_STATIC)
     if(HAVE_LIBANDROID_WORDEXP_STATIC)
@@ -1067,6 +1148,24 @@ target_link_libraries(libfastfetch
     PRIVATE ${CMAKE_DL_LIBS}
 )
 
+target_compile_options(libfastfetch PRIVATE
+    $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-rtti>)
+
+if(WIN32)
+    set(CMAKE_CXX_STANDARD 20)
+    include(CheckIncludeFileCXX)
+    CHECK_INCLUDE_FILE_CXX("winrt/Windows.Foundation.h" HAVE_WINRT)
+    if(HAVE_WINRT)
+        add_library(ffwinrt MODULE src/detection/media/media_windows.dll.cpp)
+        target_link_libraries(ffwinrt PRIVATE "RuntimeObject")
+        target_compile_definitions(ffwinrt PRIVATE WIN32_LEAN_AND_MEAN=1 WINRT_LEAN_AND_MEAN=1)
+        target_link_options(ffwinrt
+            PRIVATE "-static" # stdc++, winpthread, gcc_s, etc.
+        )
+    endif()
+        set(CMAKE_CXX_STANDARD 17)
+endif()
+
 ######################
 # Executable targets #
 ######################
@@ -1105,12 +1204,9 @@ if(yyjson_FOUND)
 endif()
 
 if(WIN32)
-    set(TARGET_NAME fastfetch)
     target_sources(fastfetch
         PRIVATE src/util/windows/version.rc
     )
-
-    set(TARGET_NAME flashfetch)
     target_sources(flashfetch
         PRIVATE src/util/windows/version.rc
     )
@@ -1163,6 +1259,13 @@ install(
     DESTINATION "${CMAKE_INSTALL_BINDIR}"
 )
 
+if (TARGET ffwinrt)
+    install(
+        TARGETS ffwinrt
+        DESTINATION "${CMAKE_INSTALL_BINDIR}"
+    )
+endif()
+
 install(
     FILES "${CMAKE_SOURCE_DIR}/completions/${CMAKE_PROJECT_NAME}.bash"
     DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions"

README.md

@@ -11,7 +11,7 @@
 [![latest packaged version(s)](https://repology.org/badge/latest-versions/fastfetch.svg)](https://repology.org/project/fastfetch/versions)
 [![Packaging status](https://repology.org/badge/tiny-repos/fastfetch.svg)](https://repology.org/project/fastfetch/versions)
 
-Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying them in a pretty way. It is written mainly in C, with performance and customizability in mind. Currently, Linux, Android, FreeBSD, MacOS and Windows 7+ are supported.
+Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying them in a pretty way. It is written mainly in C, with performance and customizability in mind. Currently, Linux, Android, FreeBSD, macOS, SunOS and Windows 7+ are supported.
 
 <img src="screenshots/example1.png" width="49%" align="left" />
 <img src="https://upload.wikimedia.org/wikipedia/commons/2/24/Transparent_Square_Tiles_Texture.png" width="49%" height="16px" align="left" />
@@ -30,6 +30,7 @@ There are [screenshots on different platforms](https://github.com/fastfetch-cli/
 Some distros packaged an outdated fastfetch version. Older version is not supported, please always ensure that the latest version is used.
 
 * Ubuntu: [`ppa:zhangsongcui3371/fastfetch`](https://launchpad.net/~zhangsongcui3371/+archive/ubuntu/fastfetch) (for Ubuntu 22.04 or newer)
+* Debian: `sudo apt install fastfetch` (for Debian 13 or newer)
 * Debian / Ubuntu: Download `fastfetch-linux-<proper architecture>.deb` from [Github release page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and double-click it (for Ubuntu 20.04 or newer and Debian 11 or newer).
 * Arch Linux: `sudo pacman -S fastfetch`
 * Fedora: `sudo dnf install fastfetch`

completions/fastfetch.bash

@@ -347,6 +347,7 @@ __fastfetch_completion()
         "--users-key"
         "--users-format"
         "--users-key-color"
+        "--users-myself-only"
         "--bluetooth-key"
         "--bluetooth-format"
         "--bluetooth-key-color"

debian/changelog

@@ -1,3 +1,21 @@
+fastfetch (2.16.0) jammy; urgency=medium
+
+  * Update to 2.16.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 19 Jun 2024 14:53:43 +0800
+
+fastfetch (2.15.0) jammy; urgency=medium
+
+  * Update to 2.15.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 07 Jun 2024 13:52:43 +0800
+
+fastfetch (2.14.0) jammy; urgency=medium
+
+  * Update to 2.14.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 30 May 2024 14:27:54 +0800
+
 fastfetch (2.13.2) jammy; urgency=medium
 
   * Update to 2.13.2

debian/files

@@ -1 +1 @@
-fastfetch_2.13.2_source.buildinfo universe/utils optional
+fastfetch_2.16.0_source.buildinfo universe/utils optional

doc/json_schema.json

@@ -23,7 +23,7 @@
             "default": 0
         },
         "format": {
-            "description": "Output format of the module. See `-h <module>-format` for detail",
+            "description": "Output format of the module. See `-h <module>-format` for detail. I.e: fastfetch -h disk-format",
             "type": "string"
         },
         "outputColor": {
@@ -89,10 +89,12 @@
             "default": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json"
         },
         "logo": {
+            "description": "Fastfetch logo configurations\nSee also https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options",
             "oneOf": [
                 {
                     "description": "Disable logo",
-                    "type": "null"
+                    "type": "null",
+                    "const": null
                 },
                 {
                     "description": "Set the source file of the logo",
@@ -217,10 +219,15 @@
                             "description": "If true, regenerate image logo cache",
                             "default": false
                         },
-                        "separate": {
-                            "type": "boolean",
-                            "description": "If true, print modules at bottom of the logo",
-                            "default": false
+                        "position": {
+                            "type": "string",
+                            "description": "Set the position of the logo should be displayed",
+                            "enum": [
+                                "left",
+                                "top",
+                                "right"
+                            ],
+                            "default": "left"
                         },
                         "chafa": {
                             "type": "object",
@@ -327,6 +334,11 @@
                     "type": "integer",
                     "description": "Set the timeout (ms) when waiting for child processes, `-1` for no timeout",
                     "default": 1000
+                },
+                "preRun": {
+                    "type": "string",
+                    "description": "Set the command to be executed before printing logos",
+                    "default": ""
                 }
             }
         },
@@ -705,6 +717,7 @@
                             "disk",
                             "diskio",
                             "de",
+                            "dns",
                             "editor",
                             "font",
                             "gamepad",
@@ -903,10 +916,6 @@
                                                 "const": "uptime",
                                                 "description": "Print how long system has been running"
                                             },
-                                            {
-                                                "const": "users",
-                                                "description": "Print users currently logged in"
-                                            },
                                             {
                                                 "const": "version",
                                                 "description": "Print Fastfetch version"
@@ -1438,6 +1447,41 @@
                                     }
                                 }
                             },
+                            {
+                                "title": "DNS",
+                                "type": "object",
+                                "additionalProperties": false,
+                                "properties": {
+                                    "type": {
+                                        "const": "dns",
+                                        "description": "Print DNS servers"
+                                    },
+                                    "showType": {
+                                        "enum": [
+                                            "ipv4",
+                                            "ipv6",
+                                            "both"
+                                        ],
+                                        "default": "both",
+                                        "description": "Specify the type of DNS servers should be detected"
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
+                                    },
+                                    "keyColor": {
+                                        "$ref": "#/$defs/keyColor"
+                                    },
+                                    "outputColor": {
+                                        "$ref": "#/$defs/outputColor"
+                                    },
+                                    "keyWidth": {
+                                        "$ref": "#/$defs/keyWidth"
+                                    },
+                                    "format": {
+                                        "$ref": "#/$defs/format"
+                                    }
+                                }
+                            },
                             {
                                 "title": "Gamepad",
                                 "type": "object",
@@ -1491,6 +1535,7 @@
                                             "auto",
                                             "pci",
                                             "vulkan",
+                                            "opencl",
                                             "opengl"
                                         ],
                                         "default": "auto"
@@ -1636,6 +1681,14 @@
                                         "maximum": 9,
                                         "default": 2
                                     },
+                                    "compact": {
+                                        "type": "boolean",
+                                        "description": "Show values in one line",
+                                        "default": true
+                                    },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
                                     "key": {
                                         "$ref": "#/$defs/key"
                                     },
@@ -1999,6 +2052,42 @@
                                     }
                                 }
                             },
+                            {
+                                "title": "Users",
+                                "type": "object",
+                                "additionalProperties": false,
+                                "properties": {
+                                    "type": {
+                                        "const": "users",
+                                        "description": "Print users currently logged in"
+                                    },
+                                    "compact": {
+                                        "type": "boolean",
+                                        "description": "Show all active users in one line",
+                                        "default": false
+                                    },
+                                    "myselfOnly": {
+                                        "type": "boolean",
+                                        "description": "Show only the current user",
+                                        "default": false
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
+                                    },
+                                    "keyColor": {
+                                        "$ref": "#/$defs/keyColor"
+                                    },
+                                    "outputColor": {
+                                        "$ref": "#/$defs/outputColor"
+                                    },
+                                    "keyWidth": {
+                                        "$ref": "#/$defs/keyWidth"
+                                    },
+                                    "format": {
+                                        "$ref": "#/$defs/format"
+                                    }
+                                }
+                            },
                             {
                                 "title": "Weather",
                                 "type": "object",

presets/examples/13.jsonc

@@ -1,3 +1,4 @@
+// Inspired by Catnap
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/examples/14.jsonc

@@ -1,3 +1,4 @@
+// Inspired by Catnap
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/examples/15.jsonc

@@ -1,3 +1,4 @@
+// Inspired by Catnap
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/examples/16.jsonc

@@ -1,3 +1,4 @@
+// Inspired by Catnap
 {
     "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {

presets/examples/19.jsonc

@@ -0,0 +1,188 @@
+//   _____ _____ _____ _____ _____ _____ _____ _____ _____
+//  |   __|  _  |   __|_   _|   __|   __|_   _|     |  |  |
+//  |   __|     |__   | | | |   __|   __| | | |   --|     |
+//  |__|  |__|__|_____| |_| |__|  |_____| |_| |_____|__|__|
+//
+//  By CarterLi - https://github.com/CarterLi
+//  Homepage - https://github.com/fastfetch-cli/fastfetch
+//  config.jsonc - ニリ @niri-san
+//  pokemon-colorscripts - https://gitlab.com/phoneybadger/pokemon-colorscripts
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "source": " _____ _____ _____ _____ _____ _____ _____ _____ _____\n|   __|  _  |   __|_   _|   __|   __|_   _|     |  |  |\n|   __|     |__   | | | |   __|   __| | | |   --|     |\n|__|  |__|__|_____| |_| |__|  |_____| |_| |_____|__|__|",
+        "type": "data",
+        "separate": true,
+        "padding": {
+            "right": 2
+        }
+    },
+    "display": {
+        "separator": " - "
+    },
+    "modules": [
+        {
+            "type": "custom", // HardwareInfo
+            "format": "• {#green}SYSTEM INFORMATION"
+        },
+        {
+            "type": "host",
+            "key": "HOST",
+            "format": "{name}{?vendor} ({vendor}){?}",
+            "keyColor": "green"
+        },
+        {
+            "type": "chassis",
+            "key": "COMPUTER TYPE",
+            "keyColor": "green"
+        },
+        {
+            "type": "cpu",
+            "key": "CPU",
+            "keyColor": "green"
+        },
+        {
+            "type": "gpu",
+            "key": "GPU",
+            "keyColor": "green"
+        },
+        {
+            "type": "memory",
+            "key": "MEMORY USED",
+            "keyColor": "green"
+        },
+        {
+            "type": "swap",
+            "key": "SWAP USED",
+            "keyColor": "green"
+        },
+        {
+            "type": "disk",
+            "key": "DISK",
+            "folders": "/",
+            "keyColor": "green"
+        },
+        {
+            "type": "custom", // SoftwareInfo
+            "format": "• {#red}SOFTWARE INFORMATION"
+        },
+        {
+            "type": "os",
+            "key": "DISTRO",
+            "keyColor": "red"
+        },
+        {
+            "type": "disk",
+            "folders": "/", // Use "/System/Volumes/VM" or something else on macOS
+            "format": "{create-time}",
+            "key": "INSTALLED DATE",
+            "keyColor": "red"
+        },
+        {
+            "type": "kernel",
+            "key": "KERNEL",
+            "keyColor": "red"
+        },
+        {
+            "type": "packages",
+            "key": "PACKAGES",
+            "keyColor": "red"
+        },
+        {
+            "type": "uptime",
+            "key": "UPTIME",
+            "keyColor": "red"
+        },
+        {
+            "type": "custom", // DisplayInfo
+            "format": "• {#blue}DISPLAY INFORMATION"
+        },
+        {
+            "type": "de",
+            "key": "DESKTOP ENVIRONMENT",
+            "keyColor": "blue"
+        },
+        {
+            "type": "lm",
+            "key": "LOGIN MANAGER",
+            "format": "{type}",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wm",
+            "key": "WM",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wmtheme",
+            "key": "WM THEME",
+            "keyColor": "blue"
+        },
+        {
+            "type": "monitor",
+            "key": "MONITOR ({name})",
+            "keyColor": "blue"
+        },
+        {
+            "type": "custom", // DesignInfo
+            "format": "• {#yellow}DESIGN INFORMATION"
+        },
+        {
+            "type": "wallpaper",
+            "key": "WALLPAPER",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "theme",
+            "key": "KDE THEME",
+            "format": "{1}",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "icons",
+            "key": "ICON THEME",
+            "format": "{1}",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "font",
+            "key": "FONT",
+            "format": "{?1}{1} [QT]{?}{/1}Unknown", // Remove "[QT]" if not using Qt
+            "keyColor": "yellow"
+        },
+        {
+            "type": "terminalfont",
+            "key": "TERMINAL FONT",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "cursor",
+            "key": "CURSOR",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "custom", // OtherInfo
+            "format": "• {#cyan}VARIOUS INFORMATION"
+        },
+        {
+            "type": "media",
+            "key": "NOW PLAYING",
+            "format": "{?artist}{artist} - {?}{title}",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "weather",
+            "key": "WEATHER",
+            "timeout": 1000,
+            "keyColor": "cyan"
+        },
+        {
+            "type": "version",
+            "key": "INFO",
+            "keyColor": "cyan"
+        },
+        "break",
+        "colors",
+        "break"
+    ]
+}

presets/examples/20.jsonc

@@ -0,0 +1,160 @@
+// Inspired by https://github.com/usgraphics/TR-100
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": null,
+    "display": {
+        "pipe": true,
+        "keyWidth": 16,
+        "separator": "│ ",
+        "percent": {
+            "type": 6
+        },
+        "bar": {
+            "borderLeft": "",
+            "borderRight": "",
+            "charElapsed": "█",
+            "charTotal": "░",
+            "width": 40
+        }
+    },
+    "modules": [
+        {
+            "type": "custom",
+            "format": "┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐"
+        },
+        {
+            "type": "custom",
+            "format": "├┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┤"
+        },
+        {
+            "type": "version",
+            "key": " ",
+            "format": "│                   FASTFETCH v{version}                   │"
+        },
+        {
+            "type": "custom",
+            "format": "│                 TR-100 MACHINE REPORT                 │"
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┬──────────────────────────────────────────┤"
+        },
+        {
+            "type": "os",
+            "key": "│ OS         │\u001b[42C"
+        },
+        {
+            "type": "kernel",
+            "key": "│ KERNEL     │\u001b[42C"
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "title",
+            "key": "│ HOSTNAME   │\u001b[42C",
+            "format": "{host-name}"
+        },
+        {
+            "type": "localip",
+            "key": "│ CLIENT IP  │\u001b[42C",
+            "format": "{ipv4}"
+        },
+        {
+            "type": "localip",
+            "key": "│ MAC ADDR   │\u001b[42C",
+            "format": "{mac} ({ifname})",
+            "showIPv4": false,
+            "showMac": true
+        },
+        {
+            "type": "dns",
+            "key": "│ DNS        │\u001b[42C",
+            "showType": "ipv4"
+        },
+        {
+            "type": "title",
+            "key": "│ USER       │\u001b[42C",
+            "format": "{user-name}"
+        },
+        {
+            "type": "host",
+            "key": "│ MACHINE    │\u001b[42C",
+            "format": "{name}"
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "cpu",
+            "key": "│ PROCESSOR  │\u001b[42C",
+            "format": "{name}"
+        },
+        {
+            "type": "cpu",
+            "key": "│ CORES      │\u001b[42C",
+            "format": "{cores-physical} PHYSICAL CORES / {cores-logical} THREADS",
+            "showPeCoreCount": false
+        },
+        {
+            "type": "cpu",
+            "key": "│ CPU FREQ   │\u001b[42C",
+            "format": "{freq-max}{/freq-max}{freq-base}{/} GHz"
+        },
+        {
+            "type": "loadavg",
+            "compact": false,
+            // {duration} is not fixed length, hack it
+            "key": "│ LOAD \u001b[s{duration}m\u001b[u\u001b[6C│\u001b[42C"
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "memory",
+            "key": "│ MEMORY     │\u001b[42C",
+            "format": "{used} / {total} [{percentage}]"
+        },
+        {
+            "type": "memory",
+            "key": "│ USAGE      │\u001b[42C",
+            "format": ""
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "disk",
+            "key": "│ VOLUME     │\u001b[42C",
+            "format": "{size-used} / {size-total} [{size-percentage}]",
+            "folders": "/"
+        },
+        {
+            "type": "disk",
+            "key": "│ DISK USAGE │\u001b[42C",
+            "format": ""
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "users",
+            "key": "│ LAST LOGIN │\u001b[42C",
+            "format": "{login-time}{?client-ip} ({client-ip})",
+            "myselfOnly": true
+        },
+        {
+            "type": "uptime",
+            "key": "│ UPTIME     │\u001b[42C"
+        },
+        {
+            "type": "custom",
+            "format": "└────────────┴──────────────────────────────────────────┘"
+        }
+    ]
+  }

presets/examples/21.jsonc

@@ -0,0 +1,43 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "modules": [
+        {
+            "key": "██ Distro",
+            "keyColor": "38;5;210",
+            "type": "os"
+        },
+        {
+            "key": "██ Kernel",
+            "keyColor": "38;5;84",
+            "type": "kernel"
+        },
+        {
+            "key": "██ Shell",
+            "keyColor": "38;5;147",
+            "type": "shell"
+        },
+        {
+            "key": "██ Packages",
+            "keyColor": "38;5;200",
+            "type": "packages"
+        },
+        {
+            "key": "██ WM",
+            "keyColor": "38;5;44",
+            "type": "wm"
+        },
+        {
+            "key": "██ CPU",
+            "keyColor": "38;5;75",
+            "type": "cpu"
+        },
+        {
+            "key": "██ Memory",
+            "keyColor": "38;5;123",
+            "type": "memory"
+        }
+    ]
+}

presets/examples/22.jsonc

@@ -0,0 +1,109 @@
+// Modified from: https://github.com/fastfetch-cli/fastfetch/pull/1025#issuecomment-2177566138
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "source": "arch3",
+        "color": {
+            "1": "red",
+            "2": "yellow"
+        }
+    },
+    "display": {
+        "color": {
+            "separator": "blue"
+        },
+        "separator": " | "
+    },
+    "modules": [
+        {
+            "type": "kernel",
+            "key": " /\\rch Linux",
+            "keyColor": "magenta"
+        },
+        {
+            "type": "custom",
+            "format": ">-----------<+>------------------------------------------<",
+            "outputColor": "separator"
+        },
+        {
+            "type": "uptime",
+            "key": "   Uptime   ",
+            "keyColor": "green"
+        },
+        {
+            "type": "shell",
+            "key": "   Shell    ",
+            "keyColor": "green"
+        },
+        {
+            "type": "terminal",
+            "key": "   Terminal ",
+            "keyColor": "green"
+        },
+        {
+            "type": "terminalfont",
+            "key": "   Font     ",
+            "keyColor": "green"
+        },
+        {
+            "type": "packages",
+            "key": "   Packages ",
+            "keyColor": "green"
+        },
+        {
+            "type": "localip",
+            "key": "   Local IP ",
+            "keyColor": "green"
+        },
+        {
+            "type": "custom",
+            "format": ">-----------<+>------------------------------------------<",
+            "outputColor": "separator"
+        },
+        {
+            "type": "display",
+            "key": "   Display  ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "cpu",
+            "key": "   CPU      ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "gpu",
+            "key": "   GPU      ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "memory",
+            "key": "   RAM      ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "swap",
+            "key": "   SWAP     ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "disk",
+            "key": "   Disk     ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "battery",
+            "key": "   Battery  ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "custom",
+            "format": ">-----------<+>------------------------------------------<",
+            "outputColor": "separator"
+        },
+        "break",
+        {
+            "type": "colors",
+            "paddingLeft": 15
+        }
+    ]
+}

src/common/format.c

@@ -52,24 +52,28 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
  * @param placeholderValue the string to parse
  * @return uint32_t the parsed value
  */
-static uint32_t getArgumentIndex(const FFstrbuf* placeholderValue, uint32_t numArgs, const FFformatarg* arguments)
+static uint32_t getArgumentIndex(const char* placeholderValue, uint32_t numArgs, const FFformatarg* arguments)
 {
-    char firstChar = placeholderValue->chars[0];
+    char firstChar = placeholderValue[0];
+    if (firstChar == '\0')
+        return 0; // use arg counter
 
-    if(firstChar >= '1' && firstChar <= '9')
+    if (firstChar >= '0' && firstChar <= '9')
     {
         char* pEnd = NULL;
-        unsigned long result = strtoul(placeholderValue->chars, &pEnd, 10);
-        if (pEnd != placeholderValue->chars + placeholderValue->length || result > numArgs)
+        uint32_t result = (uint32_t) strtoul(placeholderValue, &pEnd, 10);
+        if (result > numArgs)
             return UINT32_MAX;
-        return (uint32_t) result;
+        if (*pEnd != '\0')
+            return UINT32_MAX;
+        return result;
     }
     else if (ffCharIsEnglishAlphabet(firstChar))
     {
         for (uint32_t i = 0; i < numArgs; ++i)
         {
             const FFformatarg* arg = &arguments[i];
-            if(arg->name && ffStrbufIgnCaseEqualS(placeholderValue, arg->name))
+            if (arg->name && strcasecmp(placeholderValue, arg->name) == 0)
                 return i + 1;
         }
     }
@@ -86,16 +90,6 @@ static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start,
         ffStrbufAppendC(buffer, '}');
 }
 
-static inline void appendEmptyPlaceholder(FFstrbuf* buffer, const char* placeholder, uint32_t* argCounter, uint32_t numArgs, const FFformatarg* arguments)
-{
-    if(*argCounter >= numArgs)
-        ffStrbufAppendS(buffer, placeholder);
-    else
-        ffFormatAppendFormatArg(buffer, arguments + *argCounter);
-
-    (*argCounter)++;
-}
-
 static inline bool formatArgSet(const FFformatarg* arg)
 {
     return arg->value != NULL && (
@@ -128,13 +122,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             continue;
         }
 
-        // if we have an { at the end handle it as {}
-        if(i == formatstr->length - 1)
-        {
-            appendEmptyPlaceholder(buffer, "{", &argCounter, numArgs, arguments);
-            continue;
-        }
-
         // jump to next char, the start of the placeholder value
         ++i;
 
@@ -145,13 +132,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             continue;
         }
 
-        // placeholder is {}
-        if(formatstr->chars[i] == '}')
-        {
-            appendEmptyPlaceholder(buffer, "{}", &argCounter, numArgs, arguments);
-            continue;
-        }
-
         ffStrbufClear(&placeholderValue);
 
         {
@@ -205,7 +185,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            uint32_t index = getArgumentIndex(&placeholderValue, numArgs, arguments);
+            uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);
 
             // testing for an invalid index
             if (index > numArgs)
@@ -231,7 +211,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            uint32_t index = getArgumentIndex(&placeholderValue, numArgs, arguments);
+            uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);
 
             // testing for an invalid index
             if (index > numArgs)
@@ -264,16 +244,49 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
             continue;
         }
 
-        uint32_t index = getArgumentIndex(&placeholderValue, numArgs, arguments);
+        int32_t truncLength = INT32_MAX;
+        char* pColon = memchr(placeholderValue.chars, ':', placeholderValue.length);
+        if (pColon != NULL)
+        {
+            char* pEnd = NULL;
+            truncLength = (int32_t) strtol(pColon + 1, &pEnd, 10);
+            if (*pEnd != '\0')
+            {
+                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
+                continue;
+            }
+            *pColon = '\0';
+        }
+
+        uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);
 
         // test for invalid index
+        if (index == 0)
+            index = ++argCounter;
+
         if (index > numArgs)
         {
+            if (pColon) *pColon = ':';
             appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
             continue;
         }
 
+        bool ellipsis = false;
+        if (truncLength < 0)
+        {
+            ellipsis = true;
+            truncLength = -truncLength;
+        }
+
+        uint32_t oldLength = buffer->length;
         ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
+        if (buffer->length - oldLength > (uint32_t) truncLength)
+        {
+            ffStrbufSubstrBefore(buffer, oldLength + (uint32_t) truncLength);
+            ffStrbufTrimRightSpace(buffer);
+            if (ellipsis)
+                ffStrbufAppendS(buffer, "…");
+        }
     }
 
     if (!instance.config.display.pipe)

src/common/init.c

@@ -254,9 +254,6 @@ void ffListFeatures(void)
         #ifdef FF_HAVE_DIRECTX_HEADERS
             "Directx Headers\n"
         #endif
-        #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
-            "Proprietary GPU driver API\n"
-        #endif
         #ifdef FF_USE_SYSTEM_YYJSON
             "System yyjson\n"
         #endif

src/common/io/io.h

@@ -8,11 +8,13 @@
     #include <handleapi.h>
     #include <io.h>
     typedef HANDLE FFNativeFD;
+    #define FF_INVALID_FD INVALID_HANDLE_VALUE
 #else
     #include <unistd.h>
     #include <dirent.h>
     #include <sys/stat.h>
     typedef int FFNativeFD;
+    #define FF_INVALID_FD (-1)
     // procfs's file can be changed between read calls such as /proc/meminfo and /proc/uptime.
     // one safe way to read correct data is reading the whole file in a single read syscall
     // 8192 comes from procps-ng: https://gitlab.com/procps-ng/procps/-/blob/master/library/meminfo.c?ref_type=heads#L39

src/common/io/io_unix.c

@@ -133,32 +133,44 @@ bool ffPathExpandEnv(FF_MAYBE_UNUSED const char* in, FF_MAYBE_UNUSED FFstrbuf* o
 
 const char* ffGetTerminalResponse(const char* request, const char* format, ...)
 {
-    if (instance.config.display.pipe)
-        return "Not supported in --pipe mode";
+    int fin = STDIN_FILENO, fout = STDOUT_FILENO;
+    FF_AUTO_CLOSE_FD int ftty = -1;
 
-    struct termios oldTerm, newTerm;
-    if(tcgetattr(STDIN_FILENO, &oldTerm) == -1)
+    if (!isatty(STDIN_FILENO))
+    {
+        if (ftty < 0)
+            ftty = open("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
+        fin = ftty;
+    }
+    if (!isatty(STDOUT_FILENO))
+    {
+        if (ftty < 0)
+            ftty = open("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
+        fout = ftty;
+    }
+
+    struct termios oldTerm;
+    if(tcgetattr(fin, &oldTerm) == -1)
         return "tcgetattr(STDIN_FILENO, &oldTerm) failed";
 
-    newTerm = oldTerm;
+    struct termios newTerm = oldTerm;
     newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
-    if(tcsetattr(STDIN_FILENO, TCSANOW, &newTerm) == -1)
-        return "tcsetattr(STDIN_FILENO, TCSANOW, &newTerm)";
+    if(tcsetattr(fin, TCSAFLUSH, &newTerm) == -1)
+        return "tcsetattr(STDIN_FILENO, TCSAFLUSH, &newTerm)";
 
-    fputs(request, stdout);
-    fflush(stdout);
+    ffWriteFDData(fout, strlen(request), request);
 
-    //Give the terminal 35ms to respond
-    if(poll(&(struct pollfd) { .fd = STDIN_FILENO, .events = POLLIN }, 1, FF_IO_TERM_RESP_WAIT_MS) <= 0)
+    //Give the terminal some time to respond
+    if(poll(&(struct pollfd) { .fd = fin, .events = POLLIN }, 1, FF_IO_TERM_RESP_WAIT_MS) <= 0)
     {
-        tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+        tcsetattr(fin, TCSANOW, &oldTerm);
         return "poll() timeout or failed";
     }
 
     char buffer[512];
-    ssize_t bytesRead = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
+    ssize_t bytesRead = read(fin, buffer, sizeof(buffer) - 1);
 
-    tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+    tcsetattr(fin, TCSANOW, &oldTerm);
 
     if(bytesRead <= 0)
         return "read(STDIN_FILENO, buffer, sizeof(buffer) - 1) failed";
@@ -204,7 +216,11 @@ bool ffSuppressIO(bool suppress)
 
 void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indentation, const char* folderName, bool pretty)
 {
-    DIR* dir = opendir(folder->chars);
+    FF_AUTO_CLOSE_FD int dfd = open(folder->chars, O_RDONLY);
+    if (dfd < 0)
+        return;
+
+    DIR* dir = fdopendir(dfd);
     if(dir == NULL)
         return;
 
@@ -221,7 +237,21 @@ void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indenta
 
     while((entry = readdir(dir)) != NULL)
     {
-        if(entry->d_type == DT_DIR)
+        bool isDir = false;
+#ifdef _DIRENT_HAVE_D_TYPE
+        if(entry->d_type != DT_UNKNOWN && entry->d_type != DT_LNK)
+            isDir = entry->d_type == DT_DIR;
+        else
+#else
+        {
+            struct stat stbuf;
+            if (fstatat(dfd, entry->d_name, &stbuf, 0) < 0)
+                isDir = false;
+            else
+                isDir = S_ISDIR(stbuf.st_mode);
+        }
+#endif
+        if (isDir)
         {
             if(ffStrEquals(entry->d_name, ".") || ffStrEquals(entry->d_name, ".."))
                 continue;

src/common/io/io_windows.c

@@ -114,8 +114,40 @@ bool ffPathExpandEnv(const char* in, FFstrbuf* out)
 
 bool ffSuppressIO(bool suppress)
 {
-    (void) suppress; //Not implemented.
-    return false;
+    static bool init = false;
+    static HANDLE hOrigOut = INVALID_HANDLE_VALUE;
+    static HANDLE hOrigErr = INVALID_HANDLE_VALUE;
+    static HANDLE hNullFile = INVALID_HANDLE_VALUE;
+    static int fOrigOut = -1;
+    static int fOrigErr = -1;
+    static int fNullFile = -1;
+
+    if (!init)
+    {
+        if(!suppress)
+            return true;
+
+        hOrigOut = GetStdHandle(STD_OUTPUT_HANDLE);
+        hOrigErr = GetStdHandle(STD_ERROR_HANDLE);
+        hNullFile = CreateFileW(L"NUL", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, NULL);
+        fOrigOut = _dup(STDOUT_FILENO);
+        fOrigErr = _dup(STDERR_FILENO);
+        fNullFile = _open_osfhandle((intptr_t) hNullFile, 0);
+
+        init = true;
+    }
+    if (hNullFile == INVALID_HANDLE_VALUE || fNullFile == -1)
+        return false;
+
+    fflush(stdout);
+    fflush(stderr);
+
+    SetStdHandle(STD_OUTPUT_HANDLE, suppress ? hNullFile : hOrigOut);
+    SetStdHandle(STD_ERROR_HANDLE, suppress ? hNullFile : hOrigErr);
+    _dup2(suppress ? fNullFile : fOrigOut, STDOUT_FILENO);
+    _dup2(suppress ? fNullFile : fOrigErr, STDERR_FILENO);
+
+    return true;
 }
 
 void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indentation, const char* folderName, bool pretty)
@@ -175,24 +207,37 @@ void ffListFilesRecursively(const char* path, bool pretty)
 
 const char* ffGetTerminalResponse(const char* request, const char* format, ...)
 {
-    if (instance.config.display.pipe)
-        return "Not supported in --pipe mode";
-
     HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
-    DWORD prev_mode;
-    GetConsoleMode(hInput, &prev_mode);
+    FF_AUTO_CLOSE_FD HANDLE hConin = INVALID_HANDLE_VALUE;
+    DWORD inputMode;
+    if (!GetConsoleMode(hInput, &inputMode))
+    {
+        hConin = CreateFileW(L"CONIN$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, NULL);
+        hInput = hConin;
+    }
     SetConsoleMode(hInput, 0);
 
     FlushConsoleInputBuffer(hInput);
 
-    DWORD bytes = 0;
-    WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), request, (DWORD) strlen(request), &bytes, NULL);
+    {
+        DWORD bytes = 0;
+        HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+        FF_AUTO_CLOSE_FD HANDLE hConout = INVALID_HANDLE_VALUE;
+        DWORD outputMode;
+        if (!GetConsoleMode(hOutput, &outputMode))
+        {
+            hConout = CreateFileW(L"CONOUT$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, NULL);
+            hOutput = hConout;
+        }
+        WriteFile(hOutput, "TEST\n", 5, &bytes, NULL);
+        WriteFile(hOutput, request, (DWORD) strlen(request), &bytes, NULL);
+    }
 
     while (true)
     {
         if (WaitForSingleObjectEx(hInput, FF_IO_TERM_RESP_WAIT_MS, TRUE) != WAIT_OBJECT_0)
         {
-            SetConsoleMode(hInput, prev_mode);
+            SetConsoleMode(hInput, inputMode);
             return "WaitForSingleObject() failed or timeout";
         }
 
@@ -213,10 +258,10 @@ const char* ffGetTerminalResponse(const char* request, const char* format, ...)
     }
 
     char buffer[512];
-    bytes = 0;
+    DWORD bytes = 0;
     ReadFile(hInput, buffer, sizeof(buffer) - 1, &bytes, NULL);
 
-    SetConsoleMode(hInput, prev_mode);
+    SetConsoleMode(hInput, inputMode);
 
     if(bytes <= 0)
         return "ReadFile() failed";

src/common/modules.c

@@ -34,6 +34,7 @@ static FFModuleBaseInfo* D[] = {
     (void*) &instance.config.modules.display,
     (void*) &instance.config.modules.disk,
     (void*) &instance.config.modules.diskIo,
+    (void*) &instance.config.modules.dns,
     NULL,
 };
 

src/common/netif/netif_bsd.c

@@ -18,6 +18,8 @@
 # define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
 #elif defined(__OpenBSD__)
 # define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
+#elif defined(__sun)
+# define ROUNDUP(a)           ROUNDUP2((a), _SS_ALIGNSIZE)
 #else
 # error unknown platform
 #endif
@@ -31,9 +33,13 @@ get_rt_address(struct rt_msghdr *rtm, int desired)
     {
         if (rtm->rtm_addrs & (1 << i))
         {
-            if ((1 <<i ) == desired)
+            if ((1 << i) == desired)
                 return sa;
+#ifdef __sun
+            sa = (struct sockaddr *)(ROUNDUP(sizeof(struct sockaddr)) + (char *)sa);
+#else
             sa = (struct sockaddr *)(ROUNDUP(sa->sa_len) + (char *)sa);
+#endif
         }
     }
     return NULL;
@@ -71,7 +77,9 @@ bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
         },
         .dst = {
             .sin_family = AF_INET,
+            #ifndef __sun
             .sin_len = sizeof(rtmsg.dst),
+            #endif
         },
     };
 

src/common/printing.c

@@ -64,7 +64,7 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModu
     if(!instance.config.display.pipe)
     {
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
-        if (moduleArgs->outputColor.length)
+        if (moduleArgs && moduleArgs->outputColor.length)
             ffPrintColor(&moduleArgs->outputColor);
         else if (instance.config.display.colorOutput.length)
             ffPrintColor(&instance.config.display.colorOutput);

src/common/printing.h

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

src/common/processing_linux.c

@@ -18,8 +18,10 @@
     #include <sys/user.h>
     #include <sys/sysctl.h>
 #endif
-#ifdef __APPLE__
+#if defined(__APPLE__)
     #include <libproc.h>
+#elif defined(__sun)
+    #include <procfs.h>
 #endif
 
 enum { FF_PIPE_BUFSIZ = 8192 };
@@ -234,6 +236,29 @@ void ffProcessGetInfoLinux(pid_t pid, FFstrbuf* processName, FFstrbuf* exe, cons
         ffStrbufSetS(exe, arg0);
     }
 
+    #elif defined(__sun)
+
+    char filePath[PATH_MAX];
+    snprintf(filePath, sizeof(filePath), "/proc/%d/psinfo", (int) pid);
+    psinfo_t proc;
+    if (ffReadFileData(filePath, sizeof(proc), &proc) == sizeof(proc))
+    {
+        ffStrbufSetS(exe, proc.pr_psargs);
+        ffStrbufSubstrBeforeFirstC(exe, ' ');
+    }
+
+    if (exePath)
+    {
+        snprintf(filePath, sizeof(filePath), "/proc/%d/path/a.out", (int) pid);
+        ffStrbufEnsureFixedLengthFree(exePath, PATH_MAX);
+        ssize_t length = readlink(filePath, exePath->chars, exePath->allocated - 1);
+        if (length > 0) // doesn't contain trailing NUL
+        {
+            exePath->chars[length] = '\0';
+            exePath->length = (uint32_t) length;
+        }
+    }
+
     #endif
 
     if(exe->length == 0)
@@ -335,6 +360,19 @@ const char* ffProcessGetBasicInfoLinux(pid_t pid, FFstrbuf* name, pid_t* ppid, i
             *tty = -1;
     }
 
+    #elif defined(__sun)
+    char path[128];
+    snprintf(path, sizeof(path), "/proc/%d/psinfo", (int) pid);
+    psinfo_t proc;
+    if (ffReadFileData(path, sizeof(proc), &proc) != sizeof(proc))
+        return "ffReadFileData(psinfo) failed";
+
+    ffStrbufSetS(name, proc.pr_fname);
+    if (ppid)
+        *ppid = proc.pr_ppid;
+    if (tty)
+        *tty = (int) proc.pr_ttydev;
+
     #else
 
     return "Unsupported platform";

src/data/help.json

@@ -257,12 +257,15 @@
             }
         },
         {
-            "long": "logo-separate",
-            "desc": "If true, print modules at bottom of the logo",
+            "long": "logo-position",
+            "desc": "Set the position of the logo should be displayed",
             "arg": {
-                "type": "bool",
-                "optional": true,
-                "default": false
+                "type": "enum",
+                "enum": {
+                    "left": "Left",
+                    "top": "Top",
+                    "right": "Right"
+                }
             }
         },
         {
@@ -1251,7 +1254,8 @@
                 "enum": {
                     "auto": "Query platform specific graphic APIs. Requires proper GPU drivers installed. Not supported on FreeBSD",
                     "pci": "Search PCI devices, which do not requires GPU driver installed. Not supported on Windows and macOS",
-                    "vulkan": "Use Vulkan API. Slow and requires vulkan driver installed. Used for Android",
+                    "vulkan": "Use Vulkan API. Slow and requires proper vulkan driver installed. Used for Android",
+                    "opencl": "Use OpenCL API. Slow and requires proper OpenCL driver installed",
                     "opengl": "Use OpenGL API. Slow and only detects one GPU"
                 },
                 "default": "auto"
@@ -1287,6 +1291,15 @@
                 "default": 2
             }
         },
+        {
+            "long": "loadavg-compact",
+            "desc": "Show load average values in one line",
+            "arg": {
+                "type": "bool",
+                "optional": true,
+                "default": true
+            }
+        },
         {
             "long": "localip-show-ipv4",
             "desc": "Show IPv4 addresses in local ip module",
@@ -1367,6 +1380,19 @@
                 "default": false
             }
         },
+        {
+            "long": "dns-show-type",
+            "desc": "Specify the type of DNS servers should be detected",
+            "arg": {
+                "type": "enum",
+                "enum": {
+                    "ipv4": "Show IPv4 addresses only",
+                    "ipv6": "Show IPv6 addresses only",
+                    "both": "Show both IPv4 and IPv6 addresses"
+                },
+                "default": "both"
+            }
+        },
         {
             "long": "netio-name-prefix",
             "desc": "Show interfaces with given name prefix only",
@@ -1450,6 +1476,24 @@
                 "default": false
             }
         },
+        {
+            "long": "users-compact",
+            "desc": "Show all active users in one line",
+            "arg": {
+                "type": "bool",
+                "optional": true,
+                "default": false
+            }
+        },
+        {
+            "long": "users-myself-only",
+            "desc": "Show only current user",
+            "arg": {
+                "type": "bool",
+                "optional": true,
+                "default": false
+            }
+        },
         {
             "long": "player-name",
             "desc": "The name of the player to use for module Media and Player",

src/data/help_format.txt

@@ -8,6 +8,11 @@ In 2.14.0 or newer, the value indices can be meaningful named tags.
 For example: "--title-format '{user-name-colored}{at-symbol-colored}{host-name-colored}'" is equivalent to "--title-format '{6}{7}{8}'"
 See "fastfetch -h title-format" for all supported tags.
 
+In 2.17.0 or newer, a truncation length can be specified using syntax '<arg>:<trunc-length>`
+For example: "--title-format '{user-name:5}'" will truncate user name into 5-length string.
+If '<trunc-length>' is negative, an ellipsis … will be appended at the end when the original string is truncated.
+Note: The string length is counted in raw bytes. Multi-byte unicode characters and ANSI escape codes are not taken into account.
+
 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/battery/battery_windows.c

@@ -172,7 +172,7 @@ typedef struct FFSmbiosPortableBattery
 static_assert(offsetof(FFSmbiosPortableBattery, OEMSpecific) == 0x16,
     "FFSmbiosPortableBattery: Wrong struct alignment");
 
-const char* detectBySmbios(FFBatteryResult* battery)
+static const char* detectBySmbios(FFBatteryResult* battery)
 {
     const FFSmbiosHeaderTable* smbiosTable = ffGetSmbiosHeaderTable();
     if (!smbiosTable)

src/detection/bios/bios_nosupport.c

@@ -0,0 +1,6 @@
+#include "bios.h"
+
+const char* ffDetectBios(FFBiosResult* bios)
+{
+    return "Not supported on this platform";
+}

src/detection/bios/bios_windows.c

@@ -1,5 +1,7 @@
 #include "bios.h"
 #include "util/smbiosHelper.h"
+
+#ifdef _WIN32
 #include "util/windows/registry.h"
 
 #include <ntstatus.h>
@@ -25,7 +27,7 @@ typedef struct _SYSTEM_BOOT_ENVIRONMENT_INFORMATION
         };
     };
 } SYSTEM_BOOT_ENVIRONMENT_INFORMATION;
-
+#endif
 
 typedef struct FFSmbiosBios
 {
@@ -74,6 +76,7 @@ const char* ffDetectBios(FFBiosResult* bios)
     if (data->Header.Length > offsetof(FFSmbiosBios, SystemBiosMajorRelease))
         ffStrbufSetF(&bios->release, "%u.%u", data->SystemBiosMajorRelease, data->SystemBiosMinorRelease);
 
+    #ifdef _WIN32
     // Same as GetFirmwareType, but support (?) Windows 7
     // https://ntdoc.m417z.com/system_information_class
     SYSTEM_BOOT_ENVIRONMENT_INFORMATION sbei;
@@ -86,6 +89,7 @@ const char* ffDetectBios(FFBiosResult* bios)
             default: break;
         }
     }
+    #endif
 
     return NULL;
 }

src/detection/camera/camera_nosupport.c

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

src/detection/cpu/cpu_nosupport.c

@@ -0,0 +1,6 @@
+#include "cpu.h"
+
+const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
+{
+    return "Not supported on this platform";
+}

src/detection/cpu/cpu_sunos.c

@@ -0,0 +1,45 @@
+#include "cpu.h"
+#include <kstat.h>
+
+static inline void kstatFreeWrap(kstat_ctl_t** pkc)
+{
+    assert(pkc);
+    if (*pkc)
+        kstat_close(*pkc);
+}
+
+const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFCPUOptions* options, FFCPUResult* cpu)
+{
+    __attribute__((__cleanup__(kstatFreeWrap))) kstat_ctl_t* kc = kstat_open();
+    if (!kc)
+        return "kstat_open() failed";
+
+    kstat_t* ks = kstat_lookup(kc, "cpu_info", -1, NULL);
+    if (!ks)
+        return "kstat_lookup() failed";
+
+    if (kstat_read(kc, ks, NULL) < 0)
+        return "kstat_read() failed";
+
+    {
+        kstat_named_t* kn = kstat_data_lookup(ks, "brand");
+        ffStrbufSetNS(&cpu->name, KSTAT_NAMED_STR_BUFLEN(kn) - 1, KSTAT_NAMED_STR_PTR(kn));
+    }
+    {
+        kstat_named_t* kn = kstat_data_lookup(ks, "vendor_id");
+        ffStrbufSetNS(&cpu->vendor, KSTAT_NAMED_STR_BUFLEN(kn) - 1, KSTAT_NAMED_STR_PTR(kn));
+    }
+    {
+        kstat_named_t* kn = kstat_data_lookup(ks, "clock_MHz");
+        cpu->frequencyBase = kn->value.ui32 / 1000.;
+    }
+
+    ks = kstat_lookup(kc, "unix", -1, "system_misc");
+    if (ks && kstat_read(kc, ks, NULL) >= 0)
+    {
+        kstat_named_t* kn = kstat_data_lookup(ks, "ncpus");
+        cpu->coresLogical = cpu->coresPhysical = cpu->coresOnline = (uint16_t) kn->value.ui32;
+    }
+
+    return NULL;
+}

src/detection/cpucache/cpucache_linux.c

@@ -50,7 +50,7 @@ static const char* parseCpuCacheIndex(FFstrbuf* path, FFCPUCacheResult* result,
 
     // deduplicate shared caches
     ffStrbufAppendF(buffer, "_%u_%u_%u_%u\n", level, sizeKb, lineSize, cacheType);
-    if (ffStrbufContain(added, buffer)) return "cache already added";
+    if (ffStrbufContain(added, buffer)) return NULL;
     ffStrbufAppend(added, buffer);
     ffCPUCacheAddItem(result, level, sizeKb * 1024, lineSize, cacheType);
     return NULL;
@@ -71,7 +71,8 @@ static const char* parseCpuCache(FFstrbuf* path, FFCPUCacheResult* result, FFstr
             || !ffCharIsDigit(pathCacheEntry->d_name[strlen("index")])) continue;
 
         ffStrbufAppendS(path, pathCacheEntry->d_name);
-        parseCpuCacheIndex(path, result, buffer, added);
+        const char* error = parseCpuCacheIndex(path, result, buffer, added);
+        if (error) return error;
         ffStrbufSubstrBefore(path, baseLen);
     }
 
@@ -97,7 +98,8 @@ const char* ffDetectCPUCache(FFCPUCacheResult* result)
             !ffCharIsDigit(pathCpuEntry->d_name[strlen("cpu")])) continue;
 
         ffStrbufAppendS(&path, pathCpuEntry->d_name);
-        parseCpuCache(&path, result, &buffer, &added);
+        const char* error = parseCpuCache(&path, result, &buffer, &added);
+        if (error) return error;
         ffStrbufSubstrBefore(&path, baseLen);
     }
     return NULL;

src/detection/cpucache/cpucache_nosupport.c

@@ -1,5 +1,4 @@
 #include "cpucache.h"
-#include "common/sysctl.h"
 
 const char* ffDetectCPUCache(FF_MAYBE_UNUSED FFCPUCacheResult* result)
 {

src/detection/cpucache/cpucache_shared.c

@@ -0,0 +1,75 @@
+#include "cpucache.h"
+#include "util/smbiosHelper.h"
+#include "util/stringUtils.h"
+
+typedef struct FFSmbiosCacheInfo
+{
+    FFSmbiosHeader Header;
+
+    uint8_t SocketDesignation; // string
+    uint16_t CacheConfiguration; // varies
+    uint16_t MaximumCacheSize; // varies
+    uint16_t InstalledSize; // varies
+    uint16_t SupportedSramType; // bit field
+    uint16_t CurrentSramType; // bit field
+
+    // 2.1+
+    uint8_t CacheSpeed; // varies
+    uint8_t ErrorCorrectionType; // enum
+    uint8_t SystemCacheType; // enum
+    uint8_t Associativity; // enum
+
+    // 3.1+
+    uint32_t MaximumCacheSize2; // bit field
+    uint32_t InstalledCacheSize2; // bit field
+} __attribute__((__packed__)) FFSmbiosCacheInfo;
+
+static_assert(offsetof(FFSmbiosCacheInfo, InstalledCacheSize2) == 0x17,
+    "FFSmbiosCacheInfo: Wrong struct alignment");
+
+const char* ffDetectCPUCache(FFCPUCacheResult* result)
+{
+    const FFSmbiosHeaderTable* smbiosTable = ffGetSmbiosHeaderTable();
+    if (!smbiosTable)
+        return "Failed to get SMBIOS data";
+
+    const FFSmbiosCacheInfo* data = (const FFSmbiosCacheInfo*) (*smbiosTable)[FF_SMBIOS_TYPE_CACHE_INFO];
+    if (!data)
+        return "Cache information is not found in SMBIOS data";
+
+    for (; data->Header.Type == FF_SMBIOS_TYPE_CACHE_INFO;
+           data = (const FFSmbiosCacheInfo*) ffSmbiosNextEntry(&data->Header))
+    {
+        bool enabled = !!(data->CacheConfiguration & (1 << 7));
+        if (!enabled)
+            continue;
+
+        uint32_t size = data->InstalledSize;
+        if (size == 0)
+            continue;
+
+        if (data->InstalledSize != 0xFFFF)
+        {
+            size *= (size >> 15 ? 64 : 1) * 1024u;
+        }
+        else if (data->Header.Length > offsetof(FFSmbiosCacheInfo, InstalledCacheSize2))
+        {
+            size = data->InstalledCacheSize2;
+            size *= (size >> 31 ? 64 : 1) * 1024u;
+        }
+
+        uint32_t level = (data->CacheConfiguration & 0b111u) + 1;
+
+        FFCPUCacheType type;
+        switch (data->SystemCacheType)
+        {
+            case 3: type = FF_CPU_CACHE_TYPE_INSTRUCTION; break;
+            case 4: type = FF_CPU_CACHE_TYPE_DATA; break;
+            default: type = FF_CPU_CACHE_TYPE_UNIFIED; break;
+        }
+
+        ffCPUCacheAddItem(result, level, size, 0, type);
+    }
+
+    return NULL;
+}

src/detection/cpuusage/cpuusage_bsd.c

@@ -23,12 +23,12 @@ const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
     {
         uint64_t* cpTime = cpTimes[i];
         uint64_t inUse = cpTime[CP_USER] + cpTime[CP_NICE] + cpTime[CP_SYS];
-        uint64_t total = cpTime[CP_INTR] + cpTime[CP_IDLE];
+        uint64_t total = inUse + cpTime[CP_INTR] + cpTime[CP_IDLE];
 
         FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
         *info = (FFCpuUsageInfo) {
-            .inUseAll = (uint64_t)inUse,
-            .totalAll = (uint64_t)total,
+            .inUseAll = inUse,
+            .totalAll = total,
         };
     }
 

src/detection/cpuusage/cpuusage_linux.c

@@ -36,8 +36,8 @@ const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
 
             FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
             *info = (FFCpuUsageInfo) {
-                .inUseAll = (uint64_t)inUse,
-                .totalAll = (uint64_t)total,
+                .inUseAll = inUse,
+                .totalAll = total,
             };
         }
         else

src/detection/cpuusage/cpuusage_nosupport.c

@@ -0,0 +1,7 @@
+#include "fastfetch.h"
+#include "detection/cpuusage/cpuusage.h"
+
+const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
+{
+    return "Not support on this platform";
+}

src/detection/cpuusage/cpuusage_sunos.c

@@ -0,0 +1,38 @@
+#include "fastfetch.h"
+#include "detection/cpuusage/cpuusage.h"
+
+#include <kstat.h>
+#include <sys/sysinfo.h>
+
+static inline void kstatFreeWrap(kstat_ctl_t** pkc)
+{
+    assert(pkc);
+    if (*pkc)
+        kstat_close(*pkc);
+}
+
+const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
+{
+    __attribute__((__cleanup__(kstatFreeWrap))) kstat_ctl_t* kc = kstat_open();
+    if (!kc)
+        return "kstat_open() failed";
+
+    for (int i = 0;; ++i)
+    {
+        kstat_t* ks = kstat_lookup(kc, "cpu_stat", i, NULL);
+
+        cpu_stat_t cs;
+        if (!ks || kstat_read(kc, ks, &cs) < 0)
+            break;
+
+        uint64_t inUse = cs.cpu_sysinfo.cpu[CPU_USER] + cs.cpu_sysinfo.cpu[CPU_KERNEL];
+        uint64_t total = inUse + cs.cpu_sysinfo.cpu[CPU_IDLE] + cs.cpu_sysinfo.cpu[CPU_WAIT];
+
+        FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
+        *info = (FFCpuUsageInfo) {
+            .inUseAll = inUse,
+            .totalAll = total,
+        };
+    }
+    return NULL;
+}

src/detection/cpuusage/cpuusage_windows.c

@@ -31,8 +31,8 @@ const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
 
         FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
         *info = (FFCpuUsageInfo) {
-            .inUseAll = (uint64_t)inUse,
-            .totalAll = (uint64_t)total,
+            .inUseAll = inUse,
+            .totalAll = total,
         };
     }
 

src/detection/disk/disk_nosupport.c

@@ -0,0 +1,6 @@
+#include "disk.h"
+
+const char* ffDetectDisksImpl(FFDiskOptions* options, FFlist* disks)
+{
+    return "Not supported on this platform";
+}

src/detection/disk/disk_sunos.c

@@ -0,0 +1,138 @@
+#include "disk.h"
+#include "common/io/io.h"
+#include "util/stringUtils.h"
+
+#include <sys/mntent.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/mount.h>
+#include <sys/mnttab.h>
+
+static bool isPhysicalDevice(const struct mnttab* device)
+{
+    //Always show the root path
+    if(ffStrEquals(device->mnt_mountp, "/"))
+        return true;
+
+    if(ffStrEquals(device->mnt_special, "none"))
+        return false;
+
+    //ZFS pool
+    if(ffStrEquals(device->mnt_fstype, "zfs"))
+        return true;
+
+    //Pseudo filesystems don't have a device in /dev
+    if(!ffStrStartsWith(device->mnt_special, "/dev/"))
+        return false;
+
+    struct stat deviceStat;
+    if(stat(device->mnt_special, &deviceStat) != 0)
+        return false;
+
+    //Ignore all devices that are not block devices
+    if(!S_ISBLK(deviceStat.st_mode))
+        return false;
+
+    return true;
+}
+
+static bool isSubvolume(const FFlist* disks, FFDisk* currentDisk)
+{
+    if(ffStrbufEqualS(&currentDisk->filesystem, "zfs"))
+    {
+        //ZFS subvolumes
+        uint32_t index = ffStrbufFirstIndexC(&currentDisk->mountFrom, '/');
+        if (index == currentDisk->mountFrom.length)
+            return false;
+
+        FF_STRBUF_AUTO_DESTROY zpoolName = ffStrbufCreateNS(index, currentDisk->mountFrom.chars);
+        for(uint32_t i = 0; i < disks->length - 1; i++)
+        {
+            const FFDisk* otherDevice = ffListGet(disks, i);
+            if(ffStrbufEqualS(&otherDevice->filesystem, "zfs") && ffStrbufStartsWith(&otherDevice->mountFrom, &zpoolName))
+                return true;
+        }
+
+        return false;
+    }
+    else
+    {
+        //Filter all disks which device was already found. This catches BTRFS subvolumes.
+        for(uint32_t i = 0; i < disks->length - 1; i++)
+        {
+            const FFDisk* otherDevice = ffListGet(disks, i);
+
+            if(ffStrbufEqual(&currentDisk->mountFrom, &otherDevice->mountFrom))
+                return true;
+        }
+    }
+
+    return false;
+}
+
+static void detectType(const FFlist* disks, FFDisk* currentDisk, struct mnttab* device)
+{
+    if(ffStrContains(device->mnt_mntopts, MNTOPT_NOBROWSE))
+        currentDisk->type = FF_DISK_VOLUME_TYPE_HIDDEN_BIT;
+    else if(isSubvolume(disks, currentDisk))
+        currentDisk->type = FF_DISK_VOLUME_TYPE_SUBVOLUME_BIT;
+    else
+        currentDisk->type = FF_DISK_VOLUME_TYPE_REGULAR_BIT;
+}
+
+static void detectStats(FFDisk* disk)
+{
+    struct statvfs fs;
+    if(statvfs(disk->mountpoint.chars, &fs) != 0)
+        memset(&fs, 0, sizeof(struct statvfs));
+
+    disk->bytesTotal = fs.f_blocks * fs.f_frsize;
+    disk->bytesFree = fs.f_bfree * fs.f_frsize;
+    disk->bytesAvailable = fs.f_bavail * fs.f_frsize;
+    disk->bytesUsed = 0; // To be filled in ./disk.c
+
+    disk->filesTotal = (uint32_t) fs.f_files;
+    disk->filesUsed = (uint32_t) (disk->filesTotal - fs.f_ffree);
+
+    if(fs.f_flag & ST_RDONLY)
+        disk->type |= FF_DISK_VOLUME_TYPE_READONLY_BIT;
+
+    ffStrbufSetS(&disk->name, fs.f_fstr);
+
+    disk->createTime = 0;
+    struct stat deviceStat;
+    if(stat(disk->mountpoint.chars, &deviceStat) == 0)
+        disk->createTime = (uint64_t) deviceStat.st_ctim.tv_sec * 1000 + (uint64_t) deviceStat.st_ctim.tv_nsec / 1000000000;
+}
+
+const char* ffDetectDisksImpl(FFDiskOptions* options, FFlist* disks)
+{
+    FF_AUTO_CLOSE_FILE FILE* mountsFile = fopen(MNTTAB, "r");
+    if(mountsFile == NULL)
+        return "fopen(\"" MNTTAB "\", \"r\") == NULL";
+
+    struct mnttab device;
+
+    while (getmntent(mountsFile, &device) == 0)
+    {
+        if (__builtin_expect(options->folders.length, 0))
+        {
+            if (!ffDiskMatchMountpoint(options, device.mnt_mountp))
+                continue;
+        }
+        else if(!isPhysicalDevice(&device))
+            continue;
+
+        //We have a valid device, add it to the list
+        FFDisk* disk = ffListAdd(disks);
+        disk->type = FF_DISK_VOLUME_TYPE_NONE;
+        ffStrbufInitS(&disk->mountFrom, device.mnt_special);
+        ffStrbufInitS(&disk->mountpoint, device.mnt_mountp);
+        ffStrbufInitS(&disk->filesystem, device.mnt_fstype);
+        ffStrbufInit(&disk->name);
+        detectType(disks, disk, &device);
+        detectStats(disk);
+    }
+
+    return NULL;
+}

src/detection/diskio/diskio_nosupport.c

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

src/detection/diskio/diskio_sunos.c

@@ -0,0 +1,39 @@
+#include "diskio.h"
+#include "util/stringUtils.h"
+#include <kstat.h>
+
+static inline void kstatFreeWrap(kstat_ctl_t** pkc)
+{
+    assert(pkc);
+    if (*pkc)
+        kstat_close(*pkc);
+}
+
+const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
+{
+    __attribute__((__cleanup__(kstatFreeWrap))) kstat_ctl_t* kc = kstat_open();
+    if (!kc)
+        return "kstat_open() failed";
+
+    for (kstat_t* ks = kc->kc_chain; ks; ks = ks->ks_next)
+    {
+        if (ks->ks_type != KSTAT_TYPE_IO || !ffStrEquals(ks->ks_class, "disk")) continue;
+
+        if (options->namePrefix.length && strncmp(ks->ks_name, options->namePrefix.chars, options->namePrefix.length) != 0)
+            continue;
+
+        kstat_io_t kio;
+        if (kstat_read(kc, ks, &kio) < 0)
+            continue;
+
+        FFDiskIOResult* device = (FFDiskIOResult*) ffListAdd(result);
+        ffStrbufInitS(&device->devPath, ks->ks_name);
+        device->bytesRead = kio.nread;
+        device->readCount = kio.reads;
+        device->bytesWritten = kio.nwritten;
+        device->writeCount = kio.writes;
+        ffStrbufInitS(&device->name, ks->ks_name);
+    }
+
+    return NULL;
+}

src/detection/displayserver/linux/drm.c

@@ -3,6 +3,7 @@
 #include "util/edidHelper.h"
 #include "util/stringUtils.h"
 
+#ifdef __linux__
 #include <dirent.h>
 
 static const char* drmParseSysfs(FFDisplayServerResult* result)
@@ -85,6 +86,7 @@ static const char* drmParseSysfs(FFDisplayServerResult* result)
 
     return NULL;
 }
+#endif
 
 #ifdef FF_HAVE_DRM
 
@@ -369,5 +371,7 @@ void ffdsConnectDrm(FFDisplayServerResult* result)
     }
     #endif
 
+    #ifdef __linux__
     drmParseSysfs(result);
+    #endif
 }

src/detection/displayserver/linux/wmde.c

@@ -1,4 +1,5 @@
 #include "displayserver_linux.h"
+#include "common/io/io.h"
 #include "common/properties.h"
 #include "util/stringUtils.h"
 #include "util/mallocHelper.h"
@@ -11,8 +12,8 @@
     #include <sys/sysctl.h>
     #include <sys/types.h>
     #include <sys/user.h>
-#else
-    #include "common/io/io.h"
+#elif defined(__sun)
+    #include <procfs.h>
 #endif
 
 static const char* parseEnv(void)
@@ -302,6 +303,42 @@ static const char* getFromProcesses(FFDisplayServerResult* result)
         if(result->dePrettyName.length > 0 && result->wmPrettyName.length > 0)
             break;
     }
+#elif defined(__sun)
+    FF_AUTO_CLOSE_DIR DIR* procdir = opendir("/proc");
+    if(procdir == NULL)
+        return "opendir(\"/proc\") failed";
+
+    FF_STRBUF_AUTO_DESTROY procPath = ffStrbufCreateA(64);
+    ffStrbufAppendS(&procPath, "/proc/");
+
+    uint32_t procPathLength = procPath.length;
+
+    struct dirent* dirent;
+    while((dirent = readdir(procdir)) != NULL)
+    {
+        if (!ffCharIsDigit(dirent->d_name[0]))
+            continue;
+
+        ffStrbufAppendS(&procPath, dirent->d_name);
+        ffStrbufAppendS(&procPath, "/psinfo");
+        psinfo_t proc;
+        if (ffReadFileData(procPath.chars, sizeof(proc), &proc) == sizeof(proc))
+        {
+            ffStrbufSubstrBefore(&procPath, procPathLength);
+
+            if (proc.pr_uid != userId)
+                continue;
+
+            if(result->dePrettyName.length == 0)
+                applyPrettyNameIfDE(result, proc.pr_fname);
+
+            if(result->wmPrettyName.length == 0)
+                applyNameIfWM(result, proc.pr_fname);
+
+            if(result->dePrettyName.length > 0 && result->wmPrettyName.length > 0)
+                break;
+        }
+    }
 #else
     FF_AUTO_CLOSE_DIR DIR* procdir = opendir("/proc");
     if(procdir == NULL)

src/detection/dns/dns.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "fastfetch.h"
+
+const char* ffDetectDNS(FFDNSOptions* options, FFlist* results /* list of FFstrbuf */);

src/detection/dns/dns_linux.c

@@ -0,0 +1,35 @@
+#include "detection/dns/dns.h"
+
+#include "common/io/io.h"
+#include "util/mallocHelper.h"
+#include "util/stringUtils.h"
+
+const char* ffDetectDNS(FFDNSOptions* options, FFlist* results)
+{
+    FF_AUTO_CLOSE_FILE FILE* file = fopen(FASTFETCH_TARGET_DIR_ROOT "/etc/resolv.conf", "r");
+    if (!file)
+        return "fopen (" FASTFETCH_TARGET_DIR_ROOT "/etc/resolv.conf) failed";
+
+    FF_AUTO_FREE char* line = NULL;
+    size_t len = 0;
+
+    while (getline(&line, &len, file) != -1)
+    {
+        if (ffStrStartsWith(line, "nameserver"))
+        {
+            const char* nameserver = line + strlen("nameserver");
+            while (*nameserver == ' ' || *nameserver == '\t')
+                nameserver++;
+            if (*nameserver == '\0') continue;
+
+            if ((ffStrContainsC(nameserver, ':') && !(options->showType & FF_DNS_TYPE_IPV6_BIT)) ||
+                (ffStrContainsC(nameserver, '.') && !(options->showType & FF_DNS_TYPE_IPV4_BIT)))
+                continue;
+
+            FFstrbuf* item = (FFstrbuf*) ffListAdd(results);
+            ffStrbufInitS(item, nameserver);
+            ffStrbufTrimRightSpace(item);
+        }
+    }
+    return NULL;
+}

src/detection/dns/dns_windows.c

@@ -0,0 +1,67 @@
+#include "detection/dns/dns.h"
+#include "common/netif/netif.h"
+#include "util/mallocHelper.h"
+
+#include <ws2tcpip.h>
+#include <iphlpapi.h>
+
+const char* ffDetectDNS(FFDNSOptions* options, FFlist* results)
+{
+    IP_ADAPTER_ADDRESSES* FF_AUTO_FREE adapter_addresses = NULL;
+
+    // Multiple attempts in case interfaces change while
+    // we are in the middle of querying them.
+    DWORD adapter_addresses_buffer_size = 0;
+    for (int attempts = 0;; ++attempts)
+    {
+        if (adapter_addresses_buffer_size)
+        {
+            adapter_addresses = (IP_ADAPTER_ADDRESSES*)realloc(adapter_addresses, adapter_addresses_buffer_size);
+            assert(adapter_addresses);
+        }
+
+        DWORD error = GetAdaptersAddresses(
+            options->showType & FF_DNS_TYPE_IPV4_BIT
+                ? options->showType & FF_DNS_TYPE_IPV6_BIT ? AF_UNSPEC : AF_INET
+                : AF_INET6,
+            GAA_FLAG_SKIP_UNICAST | GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_FRIENDLY_NAME,
+            NULL,
+            adapter_addresses,
+            &adapter_addresses_buffer_size);
+
+        if (error == ERROR_SUCCESS)
+            break;
+        else if (ERROR_BUFFER_OVERFLOW == error && attempts < 4)
+            continue;
+        else
+            return "GetAdaptersAddresses() failed";
+    }
+
+    uint32_t defaultRouteIfIndex = ffNetifGetDefaultRouteIfIndex();
+    // Iterate through all of the adapters
+    for (IP_ADAPTER_ADDRESSES* adapter = adapter_addresses; adapter; adapter = adapter->Next)
+    {
+        if (adapter->IfIndex != defaultRouteIfIndex) continue;
+        if (adapter->OperStatus != IfOperStatusUp) continue;
+
+        for (IP_ADAPTER_DNS_SERVER_ADDRESS_XP * ifa = adapter->FirstDnsServerAddress; ifa; ifa = ifa->Next)
+        {
+            FFstrbuf* item = (FFstrbuf*) ffListAdd(results);
+            if (ifa->Address.lpSockaddr->sa_family == AF_INET)
+            {
+                SOCKADDR_IN* ipv4 = (SOCKADDR_IN*) ifa->Address.lpSockaddr;
+                ffStrbufInitA(item, INET_ADDRSTRLEN);
+                inet_ntop(AF_INET, &ipv4->sin_addr, item->chars, item->allocated);
+            }
+            else if (ifa->Address.lpSockaddr->sa_family == AF_INET6)
+            {
+                SOCKADDR_IN6* ipv6 = (SOCKADDR_IN6*) ifa->Address.lpSockaddr;
+                ffStrbufInitA(item, INET6_ADDRSTRLEN);
+                inet_ntop(AF_INET6, &ipv6->sin6_addr, item->chars, item->allocated);
+            }
+            ffStrbufRecalculateLength(item);
+        }
+        break;
+    }
+    return NULL;
+}

src/detection/editor/editor.c

@@ -90,6 +90,7 @@ const char* ffDetectEditor(FFEditorResult* result)
         ffStrbufStartsWithS(&result->exe, "emacs-") || // emacs-29.3
         ffStrbufEqualS(&result->exe, "hx") ||
         ffStrbufEqualS(&result->exe, "code") ||
+        ffStrbufEqualS(&result->exe, "pluma") ||
         ffStrbufEqualS(&result->exe, "sublime_text")
     ) param = "--version";
     else if (

src/detection/gpu/gpu.c

@@ -1,5 +1,6 @@
 #include "gpu.h"
 #include "detection/vulkan/vulkan.h"
+#include "detection/opencl/opencl.h"
 #include "detection/opengl/opengl.h"
 
 const char* FF_GPU_VENDOR_NAME_APPLE = "Apple";
@@ -94,6 +95,16 @@ const char* ffDetectGPU(const FFGPUOptions* options, FFlist* result)
             return NULL;
         }
     }
+    if (options->detectionMethod <= FF_GPU_DETECTION_METHOD_OPENCL)
+    {
+        FFOpenCLResult* opencl = ffDetectOpenCL();
+        if (!opencl->error && opencl->gpus.length > 0)
+        {
+            ffListDestroy(result);
+            ffListInitMove(result, &opencl->gpus);
+            return NULL;
+        }
+    }
     if (options->detectionMethod <= FF_GPU_DETECTION_METHOD_OPENGL)
     {
         if (detectByOpenGL(result) == NULL)

src/detection/gpu/gpu.h

@@ -43,6 +43,6 @@ const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus);
 
 const char* ffGetGPUVendorString(unsigned vendorId);
 
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__sun)
 void ffGPUParsePciIds(FFstrbuf* content, uint8_t subclass, uint16_t vendor, uint16_t device, FFGPUResult* gpu);
 #endif

src/detection/gpu/gpu_amd.c

@@ -19,13 +19,12 @@ const char* ffDetectAmdGpuInfo(const FFGpuDriverCondition* cond, FFGpuDriverResu
         inited = true;
         FF_LIBRARY_LOAD(libags, NULL, "dlopen amd_ags failed", soName , 1);
         FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libags, agsInitialize)
-        FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libags, agsDeInitialize)
 
         struct AGSContext* apiHandle;
         if (ffagsInitialize(AGS_CURRENT_VERSION, NULL, &apiHandle, &gpuInfo) != AGS_SUCCESS)
             return "loading ags library failed";
 
-        ffagsDeInitialize(apiHandle);
+        // agsDeInitialize will free pointers allocated in gpuInfo. Just leak them.
     }
 
     if (gpuInfo.numDevices == 0)
@@ -63,5 +62,8 @@ const char* ffDetectAmdGpuInfo(const FFGpuDriverCondition* cond, FFGpuDriverResu
     if (result.frequency)
         *result.frequency = device->coreClock / 1000.; // Maximum frequency
 
+    if (result.type)
+        *result.type = device->isAPU ? FF_GPU_TYPE_INTEGRATED : FF_GPU_TYPE_DISCRETE;
+
     return NULL;
 }

src/detection/gpu/gpu_bsd.c

@@ -76,7 +76,6 @@ const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
             ffGPUParsePciIds(&pciids, pc->pc_subclass, pc->pc_vendor, pc->pc_device, gpu);
         }
 
-        #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
         if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_NVIDIA && (options->temp || options->driverSpecific))
         {
             ffDetectNvidiaGpuInfo(&(FFGpuDriverCondition) {
@@ -98,7 +97,6 @@ const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
             if (gpu->dedicated.total != FF_GPU_VMEM_SIZE_UNSET)
                 gpu->type = gpu->dedicated.total > (uint64_t)1024 * 1024 * 1024 ? FF_GPU_TYPE_DISCRETE : FF_GPU_TYPE_INTEGRATED;
         }
-        #endif // FF_USE_PROPRIETARY_GPU_DRIVER_API
     }
 
     return NULL;

src/detection/gpu/gpu_linux.c

@@ -2,14 +2,11 @@
 #include "detection/vulkan/vulkan.h"
 #include "detection/temps/temps_linux.h"
 #include "detection/cpu/cpu.h"
+#include "detection/gpu/gpu_driver_specific.h"
 #include "common/io/io.h"
 #include "common/properties.h"
 #include "util/stringUtils.h"
 
-#ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
-    #include "detection/gpu/gpu_driver_specific.h"
-#endif
-
 #define FF_STR_INDIR(x) #x
 #define FF_STR(x) FF_STR_INDIR(x)
 
@@ -261,7 +258,6 @@ static const char* detectPci(const FFGPUOptions* options, FFlist* gpus, FFstrbuf
     }
     else if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_NVIDIA)
     {
-        #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
         if (options->temp || options->driverSpecific)
         {
             ffDetectNvidiaGpuInfo(&(FFGpuDriverCondition) {
@@ -277,10 +273,9 @@ static const char* detectPci(const FFGPUOptions* options, FFlist* gpus, FFstrbuf
                 .memory = options->driverSpecific ? &gpu->dedicated : NULL,
                 .coreCount = options->driverSpecific ? (uint32_t*) &gpu->coreCount : NULL,
                 .type = &gpu->type,
-                .frequency = &gpu->frequency,
+                .frequency = options->driverSpecific ? &gpu->frequency : NULL,
             }, "libnvidia-ml.so");
         }
-        #endif // FF_USE_PROPRIETARY_GPU_DRIVER_API
 
         if (gpu->type == FF_GPU_TYPE_UNKNOWN)
         {

src/detection/gpu/gpu_sunos.c

@@ -0,0 +1,83 @@
+#include "gpu.h"
+#include "common/properties.h"
+#include "common/io/io.h"
+#include "common/processing.h"
+
+const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist* gpus)
+{
+    // SunOS requires root permission to query PCI device list, except `/usr/bin/scanpci`
+    // Same behavior can be observed with `cp $(which scanpci) /tmp/ && /tmp/scanpci`
+
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+    const char* error = ffProcessAppendStdOut(&buffer, (char* const[]) {
+        "scanpci",
+        "-v",
+        NULL,
+    });
+    if (error)
+        return error;
+
+    if (!ffStrbufStartsWithS(&buffer, "\npci "))
+        return "Invalid scanpci result";
+
+    FF_STRBUF_AUTO_DESTROY pciids = ffStrbufCreate();
+
+    // pci bus 0x0000 cardnum 0x00 function 0x00: vendor 0x1414 device 0x008e
+    //  Device unknown
+    //  CardVendor 0x0000 card 0x0000 (Card unknown)
+    //   STATUS    0x0010  COMMAND 0x0007
+    //   CLASS     0x03 0x02 0x00  REVISION 0x00
+    //   BIST      0x00  HEADER 0x00  LATENCY 0x00  CACHE 0x00
+    //   MAX_LAT   0x00  MIN_GNT 0x00  INT_PIN 0x00  INT_LINE 0x00
+
+    for (
+        const char* pclass = strstr(buffer.chars, "\n  CLASS     0x03 ");
+        pclass;
+        pclass = strstr(pclass, "\n  CLASS     0x03 ")
+    )
+    {
+        // find the start of device entry
+        const char* pstart = memrchr(buffer.chars, '\n', (size_t) (pclass - buffer.chars));
+        while (pstart[1] != 'p')
+            pstart = memrchr(buffer.chars, '\n', (size_t) (pstart - buffer.chars - 1));
+        ++pstart;
+
+        uint32_t vendorId, deviceId;
+        if (sscanf(pstart, "pci %*[^:]: vendor %x device %x",
+            &vendorId, &deviceId) != 2)
+            return "PCI info not found, invalid scanpci result";
+
+        pclass += strlen("\n  CLASS     0x03 ");
+        uint32_t subclass = (uint32_t) strtoul(pclass, NULL, 16);
+        pclass += strlen("0x02 0x00  REVISION ");
+        uint32_t revision = (uint32_t) strtoul(pclass, NULL, 16);
+
+        FFGPUResult* gpu = (FFGPUResult*)ffListAdd(gpus);
+        ffStrbufInitStatic(&gpu->vendor, ffGetGPUVendorString(vendorId));
+        ffStrbufInit(&gpu->name);
+        ffStrbufInit(&gpu->driver);
+        ffStrbufInit(&gpu->platformApi);
+        gpu->temperature = FF_GPU_TEMP_UNSET;
+        gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
+        gpu->type = FF_GPU_TYPE_UNKNOWN;
+        gpu->dedicated.total = gpu->dedicated.used = gpu->shared.total = gpu->shared.used = FF_GPU_VMEM_SIZE_UNSET;
+        gpu->deviceId = 0;
+        gpu->frequency = FF_GPU_FREQUENCY_UNSET;
+
+        if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_AMD)
+        {
+            char query[32];
+            snprintf(query, sizeof(query), "%X,\t%X,", (unsigned) deviceId, (unsigned) revision);
+            ffParsePropFileData("libdrm/amdgpu.ids", query, &gpu->name);
+        }
+
+        if (gpu->name.length == 0)
+        {
+            if (pciids.length == 0)
+                ffReadFileBuffer(FASTFETCH_TARGET_DIR_ROOT "/usr/share/hwdata/pci.ids", &pciids);
+            ffGPUParsePciIds(&pciids, (uint8_t) subclass, (uint16_t) vendorId, (uint16_t) deviceId, gpu);
+        }
+    }
+
+    return NULL;
+}

src/detection/gpu/gpu_windows.c

@@ -1,11 +1,8 @@
 #include "gpu.h"
+#include "detection/gpu/gpu_driver_specific.h"
 #include "util/windows/unicode.h"
 #include "util/windows/registry.h"
 
-#ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
-    #include "detection/gpu/gpu_driver_specific.h"
-#endif
-
 #include <inttypes.h>
 
 static int isGpuNameEqual(const FFGPUResult* gpu, const FFstrbuf* name)
@@ -13,7 +10,6 @@ static int isGpuNameEqual(const FFGPUResult* gpu, const FFstrbuf* name)
     return ffStrbufEqual(&gpu->name, name);
 }
 
-#ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
 static inline bool getDriverSpecificDetectionFn(const char* vendor, __typeof__(&ffDetectNvidiaGpuInfo)* pDetectFn, const char** pDllName)
 {
     if (vendor == FF_GPU_VENDOR_NAME_NVIDIA)
@@ -48,7 +44,6 @@ static inline bool getDriverSpecificDetectionFn(const char* vendor, __typeof__(&
 
     return true;
 }
-#endif // FF_USE_PROPRIETARY_GPU_DRIVER_API
 
 const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist* gpus)
 {
@@ -144,13 +139,12 @@ const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist*
             }
         }
 
-#ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
         __typeof__(&ffDetectNvidiaGpuInfo) detectFn;
         const char* dllName;
 
         if (getDriverSpecificDetectionFn(gpu->vendor.chars, &detectFn, &dllName) && (options->temp || options->driverSpecific))
         {
-            if (vendorId && deviceId && subSystemId && revId)
+            if (vendorId && deviceId && subSystemId)
             {
                 detectFn(
                     &(FFGpuDriverCondition) {
@@ -168,13 +162,12 @@ const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist*
                         .memory = options->driverSpecific ? &gpu->dedicated : NULL,
                         .coreCount = options->driverSpecific ? (uint32_t*) &gpu->coreCount : NULL,
                         .type = &gpu->type,
-                        .frequency = &gpu->frequency,
+                        .frequency = options->driverSpecific ? &gpu->frequency : NULL,
                     },
                     dllName
                 );
             }
         }
-#endif // FF_USE_PROPRIETARY_GPU_DRIVER_API
     }
 
     return NULL;

src/detection/gpu/gpu_wsl.cpp

@@ -104,7 +104,6 @@ const char* ffGPUDetectByDirectX(FF_MAYBE_UNUSED const FFGPUOptions* options, FF
             const char* vendorStr = ffGetGPUVendorString((unsigned) hardwareId.vendorID);
             ffStrbufSetStatic(&gpu->vendor, vendorStr);
 
-            #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
             if (vendorStr == FF_GPU_VENDOR_NAME_NVIDIA && (options->driverSpecific || options->temp))
             {
                 FFGpuDriverCondition cond = {
@@ -121,10 +120,9 @@ const char* ffGPUDetectByDirectX(FF_MAYBE_UNUSED const FFGPUOptions* options, FF
                     .memory = options->driverSpecific ? &gpu->dedicated : NULL,
                     .coreCount = options->driverSpecific ? (uint32_t*) &gpu->coreCount : NULL,
                     .type = &gpu->type,
-                    .frequency = &gpu->frequency,
+                    .frequency = options->driverSpecific ? &gpu->frequency : NULL,
                 }, "/usr/lib/wsl/lib/libnvidia-ml.so");
             }
-            #endif
         }
     }
 

src/detection/gpu/nvml.h

@@ -52,7 +52,8 @@ typedef struct {
     // Allocated device memory (in bytes)
     unsigned long long used;
 } nvmlMemory_v2_t;
-enum { nvmlMemory_v2 = 2 };
+// https://github.com/NVIDIA/nvidia-settings/issues/78#issuecomment-1012837988
+enum { nvmlMemory_v2 = (unsigned int)(sizeof(nvmlMemory_v2_t) | (2 << 24U)) };
 
 // https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceEnumvs.html#group__nvmlDeviceEnumvs_1g805c0647be9996589fc5e3f6ff680c64
 // Clock types

src/detection/gtk_qt/qt.c

@@ -135,6 +135,34 @@ static void detectLXQt(FFQtResult* result)
     ffParsePropFileConfig("pcmanfm-qt/lxqt/settings.conf", "Wallpaper=", &result->wallpaper);
 }
 
+static void detectQtCt(char qver, FFQtResult* result)
+{
+    // qt5ct and qt6ct are technically separate applications, but they're both
+    // by the same author and qt6ct understands qt5ct in qt6 applications as well.
+    char file[] = "qtXct/qtXct.conf";
+    file[2] = file[8] = qver;
+    ffParsePropFileConfigValues(file, 3, (FFpropquery[]) {
+        {"style=", &result->widgetStyle},
+        {"icon_theme=", &result->icons},
+        {"general=", &result->font}
+    });
+
+    if (ffStrbufStartsWithC(&result->font, '@'))
+    {
+        // See QVariant notes on https://doc.qt.io/qt-5/qsettings.html and
+        // https://github.com/fastfetch-cli/fastfetch/issues/1053#issuecomment-2197254769
+        // Thankfully, newer versions use the more common font encoding.
+        ffStrbufSetNS(&result->font, 5, file);
+    }
+}
+
+static void detectKvantum(FFQtResult* result)
+{
+    ffParsePropFileConfigValues("Kvantum/kvantum.kvconfig", 1, (FFpropquery[]) {
+        {"theme=", &result->widgetStyle},
+    });
+}
+
 const FFQtResult* ffDetectQt(void)
 {
     static FFQtResult result;
@@ -151,11 +179,20 @@ const FFQtResult* ffDetectQt(void)
     ffStrbufInit(&result.wallpaper);
 
     const FFDisplayServerResult* wmde = ffConnectDisplayServer();
+    const char *qplatformtheme = getenv("QT_QPA_PLATFORMTHEME");
 
     if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, FF_DE_PRETTY_PLASMA))
         detectPlasma(&result);
     else if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, FF_DE_PRETTY_LXQT))
         detectLXQt(&result);
+    else if(ffStrSet(qplatformtheme) && (ffStrEquals(qplatformtheme, "qt5ct") || ffStrEquals(qplatformtheme, "qt6ct")))
+        detectQtCt(qplatformtheme[2], &result);
+
+    if(ffStrbufEqualS(&result.widgetStyle, "kvantum") || ffStrbufEqualS(&result.widgetStyle, "kvantum-dark"))
+    {
+        ffStrbufClear(&result.widgetStyle);
+        detectKvantum(&result);
+    }
 
     return &result;
 }

src/detection/host/host_nosupport.c

@@ -0,0 +1,6 @@
+#include "host.h"
+
+const char* ffDetectHost(FFHostResult* host)
+{
+    return "Not supported on this platform";
+}

src/detection/libc/libc_nosupport.c

@@ -0,0 +1,8 @@
+#include "libc.h"
+
+const char* ffDetectLibc(FFLibcResult* result)
+{
+    result->name = "Unknown";
+    result->version = NULL;
+    return NULL;
+}

src/detection/lm/lm_linux.c

@@ -6,7 +6,7 @@
 
 #include <unistd.h>
 
-#define FF_SYSTEMD_SESSIONS_PATH "/var/run/systemd/sessions/"
+#define FF_SYSTEMD_SESSIONS_PATH "/run/systemd/sessions/"
 #define FF_SYSTEMD_USERS_PATH "/run/systemd/users/"
 
 static const char* getGdmVersion(FFstrbuf* version)
@@ -143,7 +143,7 @@ const char* ffDetectLM(FFLMResult* result)
     {
         // On some incorrectly configured systems, $XDG_SESSION_ID is not set. Try finding it ourself
         // WARNING: This is private data. Do not parse
-        ffStrbufAppendF(&path, "/run/systemd/users/%d", getuid());
+        ffStrbufSetF(&path, FF_SYSTEMD_USERS_PATH "%d", getuid());
 
         // This is actually buggy, and assumes current user is using DE
         // `sd_pid_get_session` can be a better option, but we need to find a pid to use
@@ -151,10 +151,9 @@ const char* ffDetectLM(FFLMResult* result)
             {"DISPLAY=", &sessionId},
         }))
             return "Failed to get $XDG_SESSION_ID";
-        ffStrbufClear(&path);
     }
 
-    ffStrbufAppendS(&path, "/var/run/systemd/sessions/");
+    ffStrbufSetS(&path, FF_SYSTEMD_SESSIONS_PATH);
     ffStrbufAppend(&path, &sessionId);
 
     // WARNING: This is private data. Do not parse
@@ -162,7 +161,7 @@ const char* ffDetectLM(FFLMResult* result)
         {"SERVICE=", &result->service},
         {"TYPE=", &result->type},
     }))
-        return "Failed to parse /run/systemd/sessions/$XDG_SESSION_ID";
+        return "Failed to parse " FF_SYSTEMD_SESSIONS_PATH "$XDG_SESSION_ID";
 
     if (ffStrbufStartsWithS(&result->service, "gdm"))
         getGdmVersion(&result->version);

src/detection/loadavg/loadavg_sunos.c

@@ -0,0 +1,8 @@
+#include "detection/loadavg/loadavg.h"
+
+#include <sys/loadavg.h>
+
+const char* ffDetectLoadavg(double result[3])
+{
+    return getloadavg(result, 3) == 3 ? NULL : "getloadavg() failed";
+}

src/detection/localip/localip.h

@@ -8,6 +8,7 @@ typedef struct FFLocalIpResult
     FFstrbuf ipv4;
     FFstrbuf ipv6;
     FFstrbuf mac;
+    int32_t mtu;
     bool defaultRoute;
 } FFLocalIpResult;
 

src/detection/localip/localip_linux.c

@@ -10,12 +10,16 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdio.h>
+#include <sys/ioctl.h>
 
 #if defined(__FreeBSD__) || defined(__APPLE__)
 #include <net/if_dl.h>
 #else
 #include <netpacket/packet.h>
 #endif
+#ifdef __sun
+#include <sys/sockio.h>
+#endif
 
 static void addNewIp(FFlist* list, const char* name, const char* addr, int type, bool defaultRoute, bool firstOnly)
 {
@@ -35,6 +39,7 @@ static void addNewIp(FFlist* list, const char* name, const char* addr, int type,
         ffStrbufInit(&ip->ipv6);
         ffStrbufInit(&ip->mac);
         ip->defaultRoute = defaultRoute;
+        ip->mtu = -1;
     }
 
     switch (type)
@@ -160,5 +165,26 @@ 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)
+    {
+        FF_LIST_FOR_EACH(FFLocalIpResult, iface, *results)
+        {
+            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 __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
+        }
+    }
+
     return NULL;
 }

src/detection/localip/localip_windows.c

@@ -18,10 +18,11 @@ static void addNewIp(FFlist* list, const char* name, const char* addr, int type,
         ffStrbufInit(&ip->ipv6);
         ffStrbufInit(&ip->mac);
         ip->defaultRoute = defaultRoute;
+        ip->mtu = -1;
     }
     else
     {
-        ip = ffListGet(list, list->length - 1);
+        ip = FF_LIST_GET(FFLocalIpResult, *list, list->length - 1);
     }
 
     switch (type)
@@ -147,6 +148,9 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
                 if (typesToAdd == 0) break;
             }
         }
+
+        if (!newIp)
+            FF_LIST_GET(FFLocalIpResult, *results, results->length - 1)->mtu = (int32_t) adapter->Mtu;
     }
 
     return NULL;

src/detection/media/media.c

@@ -20,6 +20,10 @@ const FFMediaResult* ffDetectMedia(void)
 
         if(result.song.length == 0 && result.error.length == 0)
             ffStrbufAppendS(&result.error, "No media found");
+        ffStrbufTrimRightSpace(&result.song);
+        ffStrbufTrimRightSpace(&result.artist);
+        ffStrbufTrimRightSpace(&result.album);
+        ffStrbufTrimRightSpace(&result.player);
     }
 
     return &result;

src/detection/media/media_apple.m

@@ -27,7 +27,7 @@ static const char* getMedia(FFMediaResult* result)
 
     dispatch_group_enter(group);
     MRMediaRemoteGetNowPlayingApplicationIsPlaying(queue, ^(BOOL playing) {
-        ffStrbufAppendS(&result->status, playing ? "Playing" : "Paused");
+        ffStrbufSetStatic(&result->status, playing ? "Playing" : "Paused");
         dispatch_group_leave(group);
     });
 

src/detection/media/media_windows.c

@@ -0,0 +1,38 @@
+#include "common/library.h"
+#include "util/windows/unicode.h"
+#include "media.h"
+#include "media_windows.dll.h"
+
+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_SYMBOL_MESSAGE(libffwinrt, ffWinrtDetectMedia)
+    libffwinrt = NULL; // Don't close libffwinrt or it may crash
+
+    FFWinrtMediaResult result = {};
+
+    const char* error = ffffWinrtDetectMedia(&result);
+    if (error)
+    {
+        ffStrbufSetStatic(&media->error, error);
+        return NULL;
+    }
+
+    ffStrbufSetWS(&media->playerId, result.playerId);
+    ffStrbufSet(&media->player, &media->playerId);
+    if (ffStrbufEndsWithIgnCaseS(&media->player, ".exe"))
+        ffStrbufSubstrBefore(&media->player, media->player.length - 4);
+    else
+        ffStrbufSubstrAfterFirstC(&media->player, '!'); // UWP ID
+    ffStrbufSetWS(&media->song, result.song);
+    ffStrbufSetWS(&media->artist, result.artist);
+    ffStrbufSetWS(&media->album, result.album);
+    ffStrbufSetStatic(&media->status, result.status);
+    return NULL;
+}
+
+void ffDetectMediaImpl(FFMediaResult* media)
+{
+    const char* error = getMedia(media);
+    ffStrbufAppendS(&media->error, error);
+}

src/detection/media/media_windows.dll.cpp

@@ -0,0 +1,60 @@
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Media.Control.h>
+#include <wchar.h>
+
+extern "C"
+{
+#include "media_windows.dll.h"
+
+const char* ffWinrtDetectMedia(FFWinrtMediaResult* result)
+{
+    // C++/WinRT requires Windows 8.1+ and C++ runtime (std::string, exceptions and other stuff)
+    // Make it a separate dll in order not to break Windows 7 support
+    using namespace winrt::Windows::Media::Control;
+
+    try
+    {
+        auto manager = GlobalSystemMediaTransportControlsSessionManager::RequestAsync().get();
+        if (!manager)
+            return "winrt: GlobalSystemMediaTransportControlsSessionManager::RequestAsync() failed";
+
+        auto session = manager.GetCurrentSession();
+        if (!session)
+            return "winrt: GetCurrentSession() failed";
+
+        auto mediaProps = session
+            .TryGetMediaPropertiesAsync()
+            .get();
+        if (!mediaProps)
+            return "winrt: TryGetMediaPropertiesAsync() failed";
+
+        if (auto playbackInfo = session.GetPlaybackInfo())
+        {
+            switch (playbackInfo.PlaybackStatus())
+            {
+    #define FF_MEDIA_SET_STATUS(status_code) \
+    case GlobalSystemMediaTransportControlsSessionPlaybackStatus::status_code: result->status = #status_code; break
+                FF_MEDIA_SET_STATUS(Closed);
+                FF_MEDIA_SET_STATUS(Opened);
+                FF_MEDIA_SET_STATUS(Changing);
+                FF_MEDIA_SET_STATUS(Stopped);
+                FF_MEDIA_SET_STATUS(Playing);
+                FF_MEDIA_SET_STATUS(Paused);
+    #undef FF_MEDIA_SET_STATUS
+            }
+        }
+
+        ::wcsncpy(result->playerId, session.SourceAppUserModelId().data(), FF_MEDIA_WIN_RESULT_BUFLEN);
+        ::wcsncpy(result->song, mediaProps.Title().data(), FF_MEDIA_WIN_RESULT_BUFLEN);
+        ::wcsncpy(result->artist, mediaProps.Artist().data(), FF_MEDIA_WIN_RESULT_BUFLEN);
+        ::wcsncpy(result->album, mediaProps.AlbumTitle().data(), FF_MEDIA_WIN_RESULT_BUFLEN);
+
+        return NULL;
+    }
+    catch (...)
+    {
+        return "A C++ exception is thrown";
+    }
+}
+
+} // extern "C"

src/detection/media/media_windows.dll.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#define FF_MEDIA_WIN_RESULT_BUFLEN 256
+
+typedef struct FFWinrtMediaResult
+{
+    wchar_t playerId[FF_MEDIA_WIN_RESULT_BUFLEN];
+    wchar_t song[FF_MEDIA_WIN_RESULT_BUFLEN];
+    wchar_t artist[FF_MEDIA_WIN_RESULT_BUFLEN];
+    wchar_t album[FF_MEDIA_WIN_RESULT_BUFLEN];
+    const char* status;
+} FFWinrtMediaResult;
+
+__attribute__((__dllexport__))
+const char* ffWinrtDetectMedia(FFWinrtMediaResult* result);

src/detection/memory/memory_nosupport.c

@@ -0,0 +1,6 @@
+#include "memory.h"
+
+const char* ffDetectMemory(FFMemoryResult* ram)
+{
+    return "Not supported on this platform";
+}

src/detection/memory/memory_sunos.c

@@ -0,0 +1,34 @@
+#include "memory.h"
+#include <kstat.h>
+
+static inline void kstatFreeWrap(kstat_ctl_t** pkc)
+{
+    assert(pkc);
+    if (*pkc)
+        kstat_close(*pkc);
+}
+
+const char* ffDetectMemory(FFMemoryResult* ram)
+{
+    __attribute__((__cleanup__(kstatFreeWrap))) kstat_ctl_t* kc = kstat_open();
+    if (!kc)
+        return "kstat_open() failed";
+
+    kstat_t* ks = kstat_lookup(kc, "unix", -1, "system_pages");
+    if (!ks)
+        return "kstat_lookup() failed";
+
+    if (kstat_read(kc, ks, NULL) < 0)
+        return "kstat_read() failed";
+
+    {
+        kstat_named_t* kn = kstat_data_lookup(ks, "pagestotal");
+        ram->bytesTotal = kn->value.ui64 * instance.state.platform.pageSize;
+    }
+    {
+        kstat_named_t* kn = kstat_data_lookup(ks, "pagesfree");
+        ram->bytesUsed = ram->bytesTotal - kn->value.ui64 * instance.state.platform.pageSize;
+    }
+
+    return NULL;
+}

src/detection/netio/netio_nosupport.c

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

src/detection/netio/netio_sunos.c

@@ -0,0 +1,62 @@
+#include "netio.h"
+#include "common/netif/netif.h"
+#include "util/stringUtils.h"
+#include <kstat.h>
+
+static inline void kstatFreeWrap(kstat_ctl_t** pkc)
+{
+    assert(pkc);
+    if (*pkc)
+        kstat_close(*pkc);
+}
+
+const char* ffNetIOGetIoCounters(FFlist* result, FFNetIOOptions* options)
+{
+    __attribute__((__cleanup__(kstatFreeWrap))) kstat_ctl_t* kc = kstat_open();
+    if (!kc)
+        return "kstat_open() failed";
+
+    const char* defaultRoute = ffNetifGetDefaultRouteIfName();
+
+    for (kstat_t* ks = kc->kc_chain; ks; ks = ks->ks_next)
+    {
+        if (!ffStrEquals(ks->ks_class, "net") || !ffStrEquals(ks->ks_module, "link")) continue;
+
+        if (options->namePrefix.length && strncmp(ks->ks_name, options->namePrefix.chars, options->namePrefix.length) != 0)
+            continue;
+
+        bool isDefaultRoute = ffStrEquals(ks->ks_name, defaultRoute);
+        if (options->defaultRouteOnly && !isDefaultRoute)
+            continue;
+
+        if (kstat_read(kc, ks, NULL) < 0)
+            continue;
+
+        FFNetIOResult* counters = (FFNetIOResult*) ffListAdd(result);
+
+        kstat_named_t* wbytes = (kstat_named_t*) kstat_data_lookup(ks, "obytes64");
+        kstat_named_t* rbytes = (kstat_named_t*) kstat_data_lookup(ks, "rbytes64");
+        kstat_named_t* wpkts = (kstat_named_t*) kstat_data_lookup(ks, "opackets64");
+        kstat_named_t* rpkts = (kstat_named_t*) kstat_data_lookup(ks, "ipackets64");
+        kstat_named_t* werrs = (kstat_named_t*) kstat_data_lookup(ks, "oerrors");
+        kstat_named_t* rerrs = (kstat_named_t*) kstat_data_lookup(ks, "ierrors");
+
+        *counters = (FFNetIOResult) {
+            .name = ffStrbufCreateS(ks->ks_name),
+            .txBytes = wbytes->value.ui64,
+            .rxBytes = rbytes->value.ui64,
+            .txPackets = wpkts->value.ui64,
+            .rxPackets = rpkts->value.ui64,
+            .txErrors = werrs->value.ui64,
+            .rxErrors = rerrs->value.ui64,
+            .txDrops = 0, // unsupported
+            .rxDrops = 0,
+            .defaultRoute = isDefaultRoute,
+        };
+
+        if (options->defaultRouteOnly)
+            break;
+    }
+
+    return NULL;
+}

src/detection/opencl/opencl.c

@@ -1,21 +1,19 @@
 #include "detection/opencl/opencl.h"
+#include "detection/gpu/gpu.h"
 
-#ifdef __APPLE__
-#include <AvailabilityMacros.h>
-#if (MAC_OS_X_VERSION_MIN_REQUIRED > 1050) && !defined(__ppc__)
-#define MACOS_HAS_OPENCL
-#endif
+#if !defined(FF_HAVE_OPENCL) && defined(__APPLE__) && defined(MAC_OS_X_VERSION_10_15)
+    #define FF_HAVE_OPENCL 1
 #endif
 
-#if defined(FF_HAVE_OPENCL) || defined(MACOS_HAS_OPENCL)
+#ifdef FF_HAVE_OPENCL
 
 #include "common/library.h"
 #include "common/parsing.h"
 #include "util/stringUtils.h"
 #include <string.h>
 
-#define CL_TARGET_OPENCL_VERSION 100
-#ifdef FF_HAVE_OPENCL
+#define CL_TARGET_OPENCL_VERSION 110
+#ifndef __APPLE__
     #include <CL/cl.h>
 #else
     #include <OpenCL/cl.h>
@@ -24,86 +22,175 @@
 typedef struct OpenCLData
 {
     FF_LIBRARY_SYMBOL(clGetPlatformIDs)
-    FF_LIBRARY_SYMBOL(clGetDeviceIDs)
+    FF_LIBRARY_SYMBOL(clGetPlatformInfo)
     FF_LIBRARY_SYMBOL(clGetDeviceInfo)
+    FF_LIBRARY_SYMBOL(clGetDeviceIDs)
 } OpenCLData;
 
 static const char* openCLHandleData(OpenCLData* data, FFOpenCLResult* result)
 {
-    cl_platform_id platformID = NULL;
+    cl_platform_id platforms[32];
     cl_uint numPlatforms = 0;
-    data->ffclGetPlatformIDs(1, &platformID, &numPlatforms);
+    if (data->ffclGetPlatformIDs(sizeof(platforms) / sizeof(platforms[0]), platforms, &numPlatforms) != CL_SUCCESS)
+        return "clGetPlatformIDs() failed";
 
-    if(numPlatforms == 0)
+    if (numPlatforms == 0)
         return "clGetPlatformIDs returned 0 platforms";
 
-    cl_device_id deviceID = NULL;
-    cl_uint numDevices = 0;
-    data->ffclGetDeviceIDs(platformID, CL_DEVICE_TYPE_GPU, 1, &deviceID, &numDevices);
+    char buffer[1024];
+    for (cl_uint iplat = 0; iplat < numPlatforms; ++iplat)
+    {
+        if (data->ffclGetPlatformInfo(platforms[iplat], CL_PLATFORM_VERSION, sizeof(buffer), buffer, NULL) != CL_SUCCESS)
+            return "clGetPlatformInfo() failed";
 
-    if(numDevices == 0)
-        data->ffclGetDeviceIDs(platformID, CL_DEVICE_TYPE_ALL, 1, &deviceID, &numDevices);
+        // Use the newest supported OpenCL version
+        if (ffStrbufCompS(&result->version, buffer) < 0)
+        {
+            const char* versionPretty = buffer;
+            if(ffStrStartsWithIgnCase(buffer, "OpenCL "))
+                versionPretty = buffer + strlen("OpenCL ");
+            ffStrbufSetS(&result->version, versionPretty);
+            ffStrbufTrim(&result->version, ' ');
 
-    if(numDevices == 0)
-        return "clGetDeviceIDs returned 0 devices";
+            if (data->ffclGetPlatformInfo(platforms[iplat], CL_PLATFORM_NAME, sizeof(buffer), buffer, NULL) == CL_SUCCESS)
+                ffStrbufSetS(&result->name, buffer);
 
-    char version[64] = "";
-    data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VERSION, sizeof(version), version, NULL);
-    if(!ffStrSet(version))
-        return "clGetDeviceInfo returned NULL or empty string";
+            if (data->ffclGetPlatformInfo(platforms[iplat], CL_PLATFORM_VENDOR, sizeof(buffer), buffer, NULL) == CL_SUCCESS)
+                ffStrbufSetS(&result->vendor, buffer);
+        }
 
-    const char* versionPretty = version;
-    if(ffStrStartsWithIgnCase(version, "OpenCL "))
-        versionPretty = version + strlen("OpenCL ");
-    ffStrbufSetS(&result->version, versionPretty);
-    ffStrbufTrim(&result->version, ' ');
+        cl_device_id deviceIDs[32];
+        cl_uint numDevices = (cl_uint) (sizeof(deviceIDs) / sizeof(deviceIDs[0]));
+        if (data->ffclGetDeviceIDs(platforms[iplat], CL_DEVICE_TYPE_GPU, numDevices, deviceIDs, &numDevices) != CL_SUCCESS)
+            continue;
 
-    ffStrbufEnsureFree(&result->device, 128);
-    data->ffclGetDeviceInfo(deviceID, CL_DEVICE_NAME, result->device.allocated, result->device.chars, NULL);
-    ffStrbufRecalculateLength(&result->device);
-    ffStrbufTrim(&result->device, ' ');
+        for (cl_uint idev = 0; idev < numDevices; ++idev)
+        {
+            cl_device_id deviceID = deviceIDs[idev];
+            if (data->ffclGetDeviceInfo(deviceID, CL_DEVICE_NAME, sizeof(buffer), buffer, NULL) != CL_SUCCESS)
+                continue;
 
-    ffStrbufEnsureFree(&result->vendor, 32);
-    data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VENDOR, result->vendor.allocated, result->vendor.chars, NULL);
-    ffStrbufRecalculateLength(&result->vendor);
-    ffStrbufTrim(&result->vendor, ' ');
+            FFGPUResult* gpu = ffListAdd(&result->gpus);
+            ffStrbufInitS(&gpu->name, buffer);
+            ffStrbufInit(&gpu->vendor);
+            ffStrbufInit(&gpu->driver);
+            ffStrbufInit(&gpu->platformApi);
+            gpu->temperature = FF_GPU_TEMP_UNSET;
+            gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
+            gpu->type = FF_GPU_TYPE_UNKNOWN;
+            gpu->dedicated.total = gpu->dedicated.used = gpu->shared.total = gpu->shared.used = FF_GPU_VMEM_SIZE_UNSET;
+            gpu->deviceId = (size_t) deviceID;
+            gpu->frequency = FF_GPU_FREQUENCY_UNSET;
+
+            if (data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VERSION, sizeof(buffer), buffer, NULL) == CL_SUCCESS)
+            {
+                ffStrbufSetS(&gpu->platformApi, buffer);
+                ffStrbufTrimRight(&gpu->platformApi, ' ');
+            }
+            else
+                ffStrbufSetStatic(&gpu->platformApi, "OpenCL");
+
+            {
+                cl_uint vendorId;
+                if (data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VENDOR_ID, sizeof(vendorId), &vendorId, NULL) == CL_SUCCESS)
+                    ffStrbufSetStatic(&gpu->vendor, ffGetGPUVendorString(vendorId));
+                if (gpu->vendor.length == 0 && data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VENDOR, sizeof(buffer), buffer, NULL) == CL_SUCCESS)
+                    ffStrbufSetS(&gpu->vendor, buffer);
+            }
+
+            if (data->ffclGetDeviceInfo(deviceID, CL_DRIVER_VERSION, sizeof(buffer), buffer, NULL) == CL_SUCCESS)
+            {
+                const char* versionPretty = strchr(buffer, ' ');
+                if (versionPretty && *versionPretty)
+                    ffStrbufSetS(&gpu->driver, versionPretty + 1);
+                else
+                    ffStrbufSetS(&gpu->driver, buffer);
+            }
+
+            {
+                cl_uint value;
+                if (data->ffclGetDeviceInfo(deviceID, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(value), &value, NULL) == CL_SUCCESS)
+                    gpu->coreCount = (int32_t) value;
+            }
+
+            {
+                cl_uint value;
+                if (data->ffclGetDeviceInfo(deviceID, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(value), &value, NULL) == CL_SUCCESS)
+                    gpu->frequency = value / 1000.;
+            }
+
+            {
+                cl_bool value;
+                if (data->ffclGetDeviceInfo(deviceID, CL_DEVICE_HOST_UNIFIED_MEMORY, sizeof(value), &value, NULL) == CL_SUCCESS)
+                {
+                    gpu->type = value ? FF_GPU_TYPE_INTEGRATED : FF_GPU_TYPE_DISCRETE;
+
+                    cl_ulong memSize;
+                    if (data->ffclGetDeviceInfo(deviceID, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(memSize), &memSize, NULL) == CL_SUCCESS)
+                    {
+                        if (gpu->type == FF_GPU_TYPE_INTEGRATED)
+                            gpu->shared.total = memSize;
+                        else
+                            gpu->dedicated.total = memSize;
+                    }
+                }
+            }
+        }
+    }
 
     return NULL;
 }
 
-#endif // defined(FF_HAVE_OPENCL) || defined(MACOS_HAS_OPENCL)
-
-const char* ffDetectOpenCL(FFOpenCLResult* result)
+static const char* detectOpenCL(FFOpenCLResult* result)
 {
-    #ifdef FF_HAVE_OPENCL
-
     OpenCLData data;
 
-    FF_LIBRARY_LOAD(opencl, &instance.config.library.libOpenCL, "dlopen libOpenCL"FF_LIBRARY_EXTENSION" failed",
+    #ifndef __APPLE__
+
+    FF_LIBRARY_LOAD(opencl, &instance.config.library.libOpenCL, "dlopen libOpenCL" FF_LIBRARY_EXTENSION" failed",
     #ifdef _WIN32
         "OpenCL"FF_LIBRARY_EXTENSION, -1,
     #endif
         "libOpenCL"FF_LIBRARY_EXTENSION, 1
     );
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(opencl, data, clGetPlatformIDs);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(opencl, data, clGetPlatformInfo);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(opencl, data, clGetDeviceIDs);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(opencl, data, clGetDeviceInfo);
 
     return openCLHandleData(&data, result);
 
-    #elif defined(MACOS_HAS_OPENCL) // FF_HAVE_OPENCL
+    #else
 
-    OpenCLData data;
     data.ffclGetPlatformIDs = clGetPlatformIDs;
+    data.ffclGetPlatformInfo = clGetPlatformInfo;
     data.ffclGetDeviceIDs = clGetDeviceIDs;
     data.ffclGetDeviceInfo = clGetDeviceInfo;
 
     return openCLHandleData(&data, result);
 
-    #else
-
-    FF_UNUSED(result);
-    return "Fastfetch was build without OpenCL support";
-
-    #endif // FF_HAVE_OPENCL
+    #endif
+}
+
+#endif // defined(FF_HAVE_OPENCL)
+
+FFOpenCLResult* ffDetectOpenCL(void)
+{
+    static FFOpenCLResult result;
+
+    if (result.gpus.elementSize == 0)
+    {
+        ffStrbufInit(&result.version);
+        ffStrbufInit(&result.name);
+        ffStrbufInit(&result.vendor);
+        ffListInit(&result.gpus, sizeof(FFGPUResult));
+
+        #ifdef FF_HAVE_OPENCL
+            result.error = detectOpenCL(&result);
+        #else
+            result.error = "fastfetch was compiled without OpenCL support";
+        #endif
+    }
+
+    return &result;
 }

src/detection/opencl/opencl.h

@@ -5,8 +5,10 @@
 typedef struct FFOpenCLResult
 {
     FFstrbuf version;
-    FFstrbuf device;
+    FFstrbuf name;
     FFstrbuf vendor;
+    FFlist gpus; //List of FFGPUResult, see detection/gpu/gpu.h
+    const char* error;
 } FFOpenCLResult;
 
-const char* ffDetectOpenCL(FFOpenCLResult* result);
+FFOpenCLResult* ffDetectOpenCL();

src/detection/opengl/opengl.h

@@ -8,6 +8,7 @@ typedef struct FFOpenGLResult
     FFstrbuf renderer;
     FFstrbuf vendor;
     FFstrbuf slv;
+    const char* library;
 } FFOpenGLResult;
 
 const char* ffDetectOpenGL(FFOpenGLOptions* options, FFOpenGLResult* result);

src/detection/opengl/opengl_apple.c

@@ -12,6 +12,7 @@ static const char* glHandleResult(FFOpenGLResult* result)
     ffStrbufAppendS(&result->renderer, (const char*) glGetString(GL_RENDERER));
     ffStrbufAppendS(&result->vendor, (const char*) glGetString(GL_VENDOR));
     ffStrbufAppendS(&result->slv, (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION));
+    result->library = "CGL";
     return NULL;
 }
 

src/detection/opengl/opengl_linux.c

@@ -18,12 +18,13 @@ typedef struct GLData
     FF_LIBRARY_SYMBOL(glGetString)
 } GLData;
 
-static const char* glHandleResult(FFOpenGLResult* result, const GLData* data)
+static const char* glHandleResult(FFOpenGLResult* result, const GLData* data, const char* library)
 {
     ffStrbufAppendS(&result->version, (const char*) data->ffglGetString(GL_VERSION));
     ffStrbufAppendS(&result->renderer, (const char*) data->ffglGetString(GL_RENDERER));
     ffStrbufAppendS(&result->vendor, (const char*) data->ffglGetString(GL_VENDOR));
     ffStrbufAppendS(&result->slv, (const char*) data->ffglGetString(GL_SHADING_LANGUAGE_VERSION));
+    result->library = library;
     return NULL;
 }
 
@@ -61,7 +62,7 @@ static const char* eglHandleContext(FFOpenGLResult* result, EGLData* data)
     if(data->ffeglMakeCurrent(data->display, data->surface, data->surface, data->context) != EGL_TRUE)
         return "eglMakeCurrent returned EGL_FALSE";
 
-    return glHandleResult(result, &data->glData);
+    return glHandleResult(result, &data->glData, "EGL");
 }
 
 static const char* eglHandleSurface(FFOpenGLResult* result, EGLData* data)
@@ -173,7 +174,7 @@ static const char* glxHandleContext(FFOpenGLResult* result, GLXData* data)
     if(data->ffglXMakeCurrent(data->display, data->glxPixmap, data->context) != True)
         return "glXMakeCurrent returned False";
 
-    return glHandleResult(result, &data->glData);
+    return glHandleResult(result, &data->glData, "GLX");
 }
 
 static const char* glxHandleGLXPixmap(FFOpenGLResult* result, GLXData* data)
@@ -259,7 +260,11 @@ static const char* glxPrint(FFOpenGLResult* result)
 #endif //FF_HAVE_GLX
 
 #ifdef FF_HAVE_OSMESA
-#include <GL/osmesa.h>
+#if __has_include(<GL/osmesa.h>)
+    #include <GL/osmesa.h>
+#else
+    #include <mesa/osmesa.h> // for sunos
+#endif
 
 typedef struct OSMesaData
 {
@@ -280,7 +285,7 @@ static const char* osMesaHandleContext(FFOpenGLResult* result, OSMesaData* data)
     if(data->ffOSMesaMakeCurrent(data->context, buffer, GL_UNSIGNED_BYTE, FF_OPENGL_BUFFER_WIDTH, FF_OPENGL_BUFFER_HEIGHT) != GL_TRUE)
         return "OSMesaMakeCurrent returned GL_FALSE";
 
-    return glHandleResult(result, &data->glData);
+    return glHandleResult(result, &data->glData, "OSMesa");
 }
 
 static const char* osMesaHandleData(FFOpenGLResult* result, OSMesaData* data)

src/detection/opengl/opengl_windows.c

@@ -25,6 +25,7 @@ static const char* glHandleResult(WGLData* wglData)
     ffStrbufAppendS(&wglData->result->renderer, (const char*) wglData->ffglGetString(GL_RENDERER));
     ffStrbufAppendS(&wglData->result->vendor, (const char*) wglData->ffglGetString(GL_VENDOR));
     ffStrbufAppendS(&wglData->result->slv, (const char*) wglData->ffglGetString(GL_SHADING_LANGUAGE_VERSION));
+    wglData->result->library = "WGL";
     return NULL;
 }
 

src/detection/os/os_apple.m

@@ -37,6 +37,7 @@ static bool detectOSCodeName(FFOSResult* os)
 
     switch (num)
     {
+        case 15: ffStrbufSetStatic(&os->codename, "Sequoia"); return true;
         case 14: ffStrbufSetStatic(&os->codename, "Sonoma"); return true;
         case 13: ffStrbufSetStatic(&os->codename, "Ventura"); return true;
         case 12: ffStrbufSetStatic(&os->codename, "Monterey"); return true;
@@ -53,18 +54,18 @@ static bool detectOSCodeName(FFOSResult* os)
                 case 14: ffStrbufSetStatic(&os->codename, "Mojave"); return true;
                 case 13: ffStrbufSetStatic(&os->codename, "High Sierra"); return true;
                 case 12: ffStrbufSetStatic(&os->codename, "Sierra"); return true;
-                case 11: ffStrbufSetStatic(&os->codename, "El Capitan"); return true;
-                case 10: ffStrbufSetStatic(&os->codename, "Yosemite"); return true;
-                case 9: ffStrbufSetStatic(&os->codename, "Mavericks"); return true;
-                case 8: ffStrbufSetStatic(&os->codename, "Mountain Lion"); return true;
-                case 7: ffStrbufSetStatic(&os->codename, "Lion"); return true;
-                case 6: ffStrbufSetStatic(&os->codename, "Snow Leopard"); return true;
-                case 5: ffStrbufSetStatic(&os->codename, "Leopard"); return true;
-                case 4: ffStrbufSetStatic(&os->codename, "Tiger"); return true;
-                case 3: ffStrbufSetStatic(&os->codename, "Panther"); return true;
-                case 2: ffStrbufSetStatic(&os->codename, "Jaguar"); return true;
-                case 1: ffStrbufSetStatic(&os->codename, "Puma"); return true;
-                case 0: ffStrbufSetStatic(&os->codename, "Cheetah"); return true;
+                case 11: ffStrbufSetStatic(&os->codename, "El Capitan"); ffStrbufSetStatic(&os->prettyName, "OS X"); return true;
+                case 10: ffStrbufSetStatic(&os->codename, "Yosemite"); ffStrbufSetStatic(&os->prettyName, "OS X"); return true;
+                case 9: ffStrbufSetStatic(&os->codename, "Mavericks"); ffStrbufSetStatic(&os->prettyName, "OS X"); return true;
+                case 8: ffStrbufSetStatic(&os->codename, "Mountain Lion"); ffStrbufSetStatic(&os->prettyName, "OS X"); return true;
+                case 7: ffStrbufSetStatic(&os->codename, "Lion"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
+                case 6: ffStrbufSetStatic(&os->codename, "Snow Leopard"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
+                case 5: ffStrbufSetStatic(&os->codename, "Leopard"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
+                case 4: ffStrbufSetStatic(&os->codename, "Tiger"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
+                case 3: ffStrbufSetStatic(&os->codename, "Panther"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
+                case 2: ffStrbufSetStatic(&os->codename, "Jaguar"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
+                case 1: ffStrbufSetStatic(&os->codename, "Puma"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
+                case 0: ffStrbufSetStatic(&os->codename, "Cheetah"); ffStrbufSetStatic(&os->prettyName, "Mac OS X"); return true;
             }
         }
     }
@@ -105,7 +106,8 @@ void ffDetectOSImpl(FFOSResult* os)
     if(os->buildID.length == 0)
         ffSysctlGetString("kern.osversion", &os->buildID);
 
-    ffStrbufAppend(&os->prettyName, &os->name);
+    if(os->prettyName.length == 0)
+        ffStrbufSetStatic(&os->prettyName, "macOS");
     ffStrbufAppend(&os->versionID, &os->version);
 
     if(!detectOSCodeName(os))

src/detection/os/os_linux.c

@@ -180,6 +180,28 @@ static bool detectDebianDerived(FFOSResult* result)
         ffStrbufSetF(&result->prettyName, "Proxmox VE %s", result->versionID.chars);
         return true;
     }
+    else
+    {
+        // Hack for MX Linux. See #847
+        FF_STRBUF_AUTO_DESTROY lsbRelease = ffStrbufCreate();
+        if (ffAppendFileBuffer("/etc/lsb-release", &lsbRelease) && ffStrbufContainS(&lsbRelease, "DISTRIB_ID=MX"))
+        {
+            ffStrbufSetS(&result->id, "mx");
+            ffStrbufSetS(&result->idLike, "debian");
+            ffStrbufSetS(&result->name, "MX");
+
+            ffStrbufClear(&result->version);
+            ffParsePropLines(lsbRelease.chars, "DISTRIB_RELEASE=", &result->version);
+            ffStrbufSet(&result->versionID, &result->version);
+
+            ffStrbufClear(&result->codename);
+            ffParsePropLines(lsbRelease.chars, "DISTRIB_CODENAME=", &result->codename);
+
+            ffStrbufClear(&result->prettyName);
+            ffParsePropLines(lsbRelease.chars, "DISTRIB_DESCRIPTION=", &result->prettyName);
+            return true;
+        }
+    }
     return false;
 }
 
@@ -208,22 +230,9 @@ static void detectOS(FFOSResult* os)
 
     // Refer: https://gist.github.com/natefoo/814c5bf936922dad97ff
 
-    // Hack for MX Linux. See #847
-    if(parseLsbRelease(FASTFETCH_TARGET_DIR_ETC "/lsb-release", os))
-    {
-        if (ffStrbufEqualS(&os->id, "MX"))
-        {
-            ffStrbufSetStatic(&os->name, "MX");
-            ffStrbufSetStatic(&os->idLike, "debian");
-            return;
-        }
-
-        // For archlinux
-        if (ffStrbufEqualS(&os->version, "rolling"))
-            ffStrbufClear(&os->version);
-    }
-
-    if(parseOsRelease(FASTFETCH_TARGET_DIR_ETC "/os-release", os) && allRelevantValuesSet(os))
+    if((parseOsRelease(FASTFETCH_TARGET_DIR_ETC "/os-release", os) ||
+        parseLsbRelease(FASTFETCH_TARGET_DIR_ETC "/lsb-release", os)) &&
+        allRelevantValuesSet(os))
         return;
 
     parseOsRelease(FASTFETCH_TARGET_DIR_USR "/lib/os-release", os);

src/detection/os/os_sunos.c

@@ -0,0 +1,17 @@
+#include "os.h"
+#include "common/io/io.h"
+
+void ffDetectOSImpl(FFOSResult* os)
+{
+    if (!ffReadFileBuffer("/etc/release", &os->prettyName))
+        return;
+
+    ffStrbufSubstrBeforeFirstC(&os->prettyName, '\n');
+    ffStrbufSubstrBeforeLastC(&os->prettyName, '(');
+    ffStrbufTrim(&os->prettyName, ' ');
+
+    // OpenIndiana Hipster 2024.04
+    uint32_t idx = ffStrbufFirstIndexC(&os->prettyName, ' ');
+    ffStrbufSetNS(&os->id, idx, os->prettyName.chars);
+    ffStrbufSetStatic(&os->idLike, "sunos");
+}

src/detection/os/os_windows.cpp

@@ -90,4 +90,5 @@ void ffDetectOSImpl(FFOSResult* os)
     }
 
     ffStrbufAppendF(&os->id, "%*s %*s", os->prettyName.length, os->prettyName.chars, os->version.length, os->version.chars);
+    ffStrbufSetStatic(&os->idLike, "Windows");
 }

src/detection/packages/packages_nosupport.c

@@ -0,0 +1,5 @@
+#include "packages.h"
+
+void ffDetectPackagesImpl(FFPackagesResult* result, FFPackagesOptions* options)
+{
+}

src/detection/packages/packages_sunos.c

@@ -0,0 +1,15 @@
+#include "packages.h"
+
+void ffDetectPackagesImpl(FFPackagesResult* result, FFPackagesOptions* options)
+{
+    if (!(options->disabled & FF_PACKAGES_FLAG_PKG_BIT))
+    {
+        yyjson_doc* doc = yyjson_read_file(FASTFETCH_TARGET_DIR_ROOT "/var/pkg/state/installed/catalog.attrs", YYJSON_READ_NOFLAG, NULL, NULL);
+        if (doc)
+        {
+            yyjson_val* packageCount = yyjson_obj_get(yyjson_doc_get_root(doc), "package-count");
+            if (packageCount)
+                result->pkg = (uint32_t) yyjson_get_uint(packageCount);
+        }
+    }
+}

src/detection/physicaldisk/physicaldisk_nosupport.c

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

src/detection/processes/processes_linux.c

@@ -14,7 +14,11 @@ const char* ffDetectProcesses(uint32_t* result)
     struct dirent* entry;
     while ((entry = readdir(dir)) != NULL)
     {
-        if (entry->d_type == DT_DIR && ffCharIsDigit(entry->d_name[0]))
+        if (
+        #ifdef _DIRENT_HAVE_D_TYPE
+                entry->d_type == DT_DIR &&
+        #endif
+                ffCharIsDigit(entry->d_name[0]))
             ++num;
     }
 

src/detection/sound/sound_linux.c

@@ -13,7 +13,10 @@ static void paSinkInfoCallback(pa_context *c, const pa_sink_info *i, int eol, vo
 
     FFSoundDevice* device = ffListAdd(userdata);
     ffStrbufInitS(&device->identifier, i->name);
+    ffStrbufTrimRightSpace(&device->identifier);
     ffStrbufInitS(&device->name, i->description);
+    ffStrbufTrimRightSpace(&device->name);
+    ffStrbufTrimLeft(&device->name, ' ');
     device->volume = i->mute ? 0 : (uint8_t) (i->volume.values[0] * 100 / PA_VOLUME_NORM);
     device->active = i->active_port && i->active_port->available != PA_PORT_AVAILABLE_NO;
     device->main = false;

src/detection/swap/swap_nosupport.c

@@ -0,0 +1,6 @@
+#include "swap.h"
+
+const char* ffDetectSwap(FFSwapResult* swap)
+{
+    return "Not supported on this platform";
+}

src/detection/swap/swap_sunos.c

@@ -0,0 +1,33 @@
+#include "swap.h"
+#include <sys/stat.h>
+#include <sys/swap.h>
+#include <limits.h>
+
+enum { FFMaxNSwap = 8 };
+
+const char* ffDetectSwap(FFSwapResult* swap)
+{
+    char strings[FFMaxNSwap][PATH_MAX];
+    uint8_t buffer[sizeof(swaptbl_t) + sizeof(swapent_t) * (FFMaxNSwap - 1)] = {};
+    swaptbl_t* table = (swaptbl_t*) buffer;
+    table->swt_n = FFMaxNSwap;
+    for (int i = 0; i < FFMaxNSwap; ++i)
+        table->swt_ent[i].ste_path = strings[i];
+
+    int size = swapctl(SC_LIST, table);
+    if (size < 0)
+        return "swapctl() failed";
+
+    swap->bytesTotal = swap->bytesUsed = 0;
+
+    for (int i = 0; i < size; ++i)
+    {
+        swap->bytesTotal += (uint64_t) table->swt_ent[i].ste_pages;
+        swap->bytesUsed += (uint64_t) table->swt_ent[i].ste_free;
+    }
+    swap->bytesUsed = swap->bytesTotal - swap->bytesUsed;
+    swap->bytesTotal *= instance.state.platform.pageSize;
+    swap->bytesUsed *= instance.state.platform.pageSize;
+
+    return NULL;
+}

src/detection/terminalfont/terminalfont.c

@@ -1,4 +1,5 @@
 #include "terminalfont.h"
+#include "common/io/io.h"
 #include "common/properties.h"
 #include "common/processing.h"
 #include "detection/terminalshell/terminalshell.h"
@@ -256,42 +257,66 @@ static void detectFromWindowsTerminal(const FFstrbuf* terminalExe, FFTerminalFon
     }
 }
 
-
-
 #endif //defined(_WIN32) || defined(__linux__)
 
+static bool queryKittyTerm(const char* query, FFstrbuf* res)
+{
+    // https://github.com/fastfetch-cli/fastfetch/discussions/1030#discussioncomment-9845233
+    char buffer[64] = "";
+    if (ffGetTerminalResponse(
+        query, // kitty-query-font_family;kitty-query-font_size
+        "\eP1+r%*[^=]=%64[^\e]\e\\", buffer) == NULL && *buffer)
+    {
+        // 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();
 
-    FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
-    if(!ffProcessAppendStdOut(&buf, (char* const[]){
-        exe->chars,
-        "+kitten",
-        "query-terminal",
-        NULL,
-    }))
-    {
-        ffParsePropLines(buf.chars, "font_family: ", &fontName);
-        ffParsePropLines(buf.chars, "font_size: ", &fontSize);
-    }
+    // 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
     else
     {
-        FFpropquery fontQuery[] = {
-            {"font_family ", &fontName},
-            {"font_size ", &fontSize},
-        };
+        FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
+        if(!ffProcessAppendStdOut(&buf, (char* const[]){
+            exe->chars,
+            "+kitten",
+            "query-terminal",
+            NULL,
+        }))
+        {
+            ffParsePropLines(buf.chars, "font_family: ", &fontName);
+            ffParsePropLines(buf.chars, "font_size: ", &fontSize);
+        }
+        else
+        {
+            FFpropquery fontQuery[] = {
+                {"font_family ", &fontName},
+                {"font_size ", &fontSize},
+            };
 
-        ffParsePropFileConfigValues("kitty/kitty.conf", 2, fontQuery);
+            ffParsePropFileConfigValues("kitty/kitty.conf", 2, fontQuery);
 
-        if(fontName.length == 0)
-            ffStrbufSetS(&fontName, "monospace");
-        if(fontSize.length == 0)
-            ffStrbufSetS(&fontSize, "11.0");
+            if(fontName.length == 0)
+                ffStrbufSetS(&fontName, "monospace");
+            if(fontSize.length == 0)
+                ffStrbufSetS(&fontSize, "11.0");
+        }
     }
 
-
     ffFontInitValues(&result->font, fontName.chars, fontSize.chars);
 
     return true;

src/detection/terminalshell/terminalshell.c

@@ -480,33 +480,21 @@ static bool getTerminalVersionZellij(FFstrbuf* exe, FFstrbuf* version)
 #ifndef _WIN32
 static bool getTerminalVersionKitty(FFstrbuf* exe, FFstrbuf* version)
 {
-    #if defined(__linux__) || defined(__FreeBSD__)
-    // kitty is written in python. `kitty --version` can be expensive
-    char buffer[1024] = {};
-    if (
-        #ifdef __linux__
-        ffReadFileData(FASTFETCH_TARGET_DIR_USR "/lib64/kitty/kitty/constants.py", sizeof(buffer) - 1, buffer) ||
-        ffReadFileData(FASTFETCH_TARGET_DIR_USR "/lib/kitty/kitty/constants.py", sizeof(buffer) - 1, buffer)
-        #else
-        ffReadFileData(_PATH_LOCALBASE "/share/kitty/kitty/constants.py", sizeof(buffer) - 1, buffer)
-        #endif
-    )
+    char versionHex[64] = "";
+    // https://github.com/fastfetch-cli/fastfetch/discussions/1030#discussioncomment-9845233
+    if (ffGetTerminalResponse(
+        "\eP+q6b697474792d71756572792d76657273696f6e\e\\", // kitty-query-version
+        "\eP1+r%*[^=]=%64[^\e]\e\\\\", versionHex) == NULL && *versionHex)
     {
-        // Starts from version 0.17.0
-        // https://github.com/kovidgoyal/kitty/blob/master/kitty/constants.py#L25
-        const char* p = memmem(buffer, sizeof(buffer) - 1, "version: Version = Version(", strlen("version: Version = Version("));
-        if (p)
+        // decode hex string
+        for (const char* p = versionHex; p[0] && p[1]; p += 2)
         {
-            p += strlen("version: Version = Version(");
-            int major, minor, patch;
-            if (sscanf(p, "%d,%d,%d", &major, &minor, &patch) == 3)
-            {
-                ffStrbufSetF(version, "%d.%d.%d", major, minor, patch);
-                return true;
-            }
+            unsigned value;
+            if (sscanf(p, "%2x", &value) == 1)
+                ffStrbufAppendC(version, (char) value);
         }
+        return true;
     }
-    #endif
 
     //kitty 0.21.2 created by Kovid Goyal
     return getExeVersionGeneral(exe, version);
@@ -553,7 +541,7 @@ bool fftsGetTerminalVersion(FFstrbuf* processName, FF_MAYBE_UNUSED FFstrbuf* exe
 
     #endif
 
-    #if defined(__linux__) || defined(__FreeBSD__)
+    #if defined(__linux__) || defined(__FreeBSD__) || defined(__sun)
 
     if(ffStrbufStartsWithIgnCaseS(processName, "gnome-terminal"))
         return getTerminalVersionGnome(version);

src/detection/terminalsize/terminalsize_linux.c

@@ -4,6 +4,10 @@
 #include <sys/ioctl.h>
 #include <unistd.h>
 
+#ifdef __sun
+    #include <sys/termios.h>
+#endif
+
 bool ffDetectTerminalSize(FFTerminalSizeResult* result)
 {
     struct winsize winsize = {};

src/detection/terminalsize/terminalsize_windows.c

@@ -5,9 +5,19 @@
 
 bool ffDetectTerminalSize(FFTerminalSizeResult* result)
 {
+    HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+    FF_AUTO_CLOSE_FD HANDLE hConout = INVALID_HANDLE_VALUE;
+    {
+        DWORD outputMode;
+        if (!GetConsoleMode(hOutput, &outputMode))
+        {
+            hConout = CreateFileW(L"CONOUT$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, NULL);
+            hOutput = hConout;
+        }
+    }
     {
         CONSOLE_SCREEN_BUFFER_INFO csbi;
-        if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
+        if (GetConsoleScreenBufferInfo(hOutput, &csbi))
         {
             result->columns = (uint16_t) (csbi.srWindow.Right - csbi.srWindow.Left + 1);
             result->rows = (uint16_t) (csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
@@ -23,7 +33,7 @@ bool ffDetectTerminalSize(FFTerminalSizeResult* result)
 
     {
         CONSOLE_FONT_INFO cfi;
-        if(GetCurrentConsoleFont(GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &cfi)) // Only works for ConHost
+        if(GetCurrentConsoleFont(hOutput, FALSE, &cfi)) // Only works for ConHost
         {
             result->width = result->columns * (uint16_t) cfi.dwFontSize.X;
             result->height = result->rows * (uint16_t) cfi.dwFontSize.Y;

src/detection/uptime/uptime_sunos.c

@@ -0,0 +1,21 @@
+#include "uptime.h"
+#include "common/time.h"
+#include <utmpx.h>
+
+const char* ffDetectUptime(FFUptimeResult* result)
+{
+    struct utmpx* ut;
+
+    setutxent();
+    while (NULL != (ut = getutxent()))
+    {
+        if (ut->ut_type == BOOT_TIME)
+        {
+            result->bootTime = (uint64_t) ut->ut_tv.tv_sec * 1000 + (uint64_t) ut->ut_tv.tv_usec / 1000000;
+            result->uptime = ffTimeGetNow() - result->bootTime;
+            break;
+        }
+    }
+    endutxent();
+    return NULL;
+}