Merge pull request #840 from fastfetch-cli/dev

Release: v2.11.1

.github/ISSUE_TEMPLATE/bug_report.md

@@ -59,6 +59,10 @@ strace /path/to/fastfetch --multithreading false -s {MODULE} --pipe
 
 If you cannot do the instructions above, please upload the core dump file:
 
+## If fastfetch is slow
+
+Use `time fastfetch --stat` to show time usage for each module.
+
 ## If my image logo didn't show / work
 
 <!-- Please make sure the terminal does support the image protocol you used. Note Gnome terminal doesn't support any image protocols -->

.github/workflows/ci.yml

@@ -14,14 +14,16 @@ jobs:
 
       - name: Install codespell
         shell: bash
-        run: sudo apt update && sudo apt install -y codespell
+        run: |
+          sudo apt-get update || true
+          sudo apt-get install -y codespell
 
       - name: Run Spellchecker
         run: codespell
 
-  Linux-old-amd64:
-    name: Linux-old-amd64
-    runs-on: ubuntu-20.04
+  no-features-test:
+    name: No-features-test
+    runs-on: ubuntu-latest
     permissions:
       security-events: write
       contents: read
@@ -32,28 +34,12 @@ jobs:
       - name: uname -a
         run: uname -a
 
-      - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libdrm-dev directx-headers-dev
-
-      - name: install linuxbrew packages
-        run: |
-          /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa ddcutil --ignore-dependencies
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-        with:
-          languages: c
-
       - name: configure project
-        run: PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr . -DENABLE_VULKAN=OFF -DENABLE_WAYLAND=OFF -DENABLE_XCB_RANDR=OFF -DENABLE_XCB=OFF -DENABLE_XRANDR=OFF -DENABLE_X11=OFF -DENABLE_DRM=OFF -DENABLE_GIO=OFF -DENABLE_DCONF=OFF -DENABLE_DBUS=OFF -DENABLE_XFCONF=OFF -DENABLE_SQLITE3=OFF -DENABLE_RPM=OFF -DENABLE_IMAGEMAGICK7=OFF -DENABLE_IMAGEMAGICK6=OFF -DENABLE_CHAFA=OFF -DENABLE_ZLIB=OFF -DENABLE_EGL=OFF -DENABLE_GLX=OFF -DENABLE_OSMESA=OFF -DENABLE_OPENCL=OFF -DENABLE_LIBNM=OFF -DENABLE_FREETYPE=OFF -DENABLE_PULSE=OFF -DENABLE_DDCUTIL=OFF -DENABLE_DIRECTX_HEADERS=OFF -DENABLE_THREADS=OFF
 
       - name: build project
         run: cmake --build . --target package --verbose -j4
 
-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v3
-
       - name: list features
         run: ./fastfetch --list-features
 
@@ -72,15 +58,9 @@ jobs:
       - name: run tests
         run: ctest
 
-      - name: upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: fastfetch-linux-old-amd64
-          path: ./fastfetch-*.*
-
   linux-amd64:
     name: Linux-amd64
-    runs-on: ubuntu-22.04 # Ubuntu 22.04 uses Glibc 2.35. Should be fine with Debian 12, which uses Glibc 2.36 (https://packages.debian.org/source/bookworm/glibc)
+    runs-on: ubuntu-20.04
     permissions:
       security-events: write
       contents: read
@@ -94,12 +74,12 @@ jobs:
         run: uname -a
 
       - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libdrm-dev libddcutil-dev libchafa-dev directx-headers-dev
+        run: sudo apt-get update && sudo apt-get install -y libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libdrm-dev directx-headers-dev
 
       - name: install linuxbrew packages
         run: |
           /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick --ignore-dependencies
+          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa ddcutil --ignore-dependencies
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v3
@@ -178,6 +158,41 @@ jobs:
           name: fastfetch-linux-aarch64
           path: ./fastfetch-*.*
 
+  linux-armv7:
+    name: Linux-armv7
+    runs-on: ubuntu-22.04
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@v2
+        id: runcmd
+        with:
+          arch: armv7
+          distro: 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-armv7
+          path: ./fastfetch-*.*
+
   musl-amd64:
     name: Musl-amd64
     runs-on: ubuntu-latest
@@ -258,7 +273,7 @@ jobs:
 
   macos-universal:
     name: macOS-universal
-    runs-on: macos-latest
+    runs-on: macos-12
     permissions:
       security-events: write
       contents: read
@@ -521,6 +536,7 @@ jobs:
     needs:
       - linux-amd64
       - linux-aarch64
+      - linux-armv7
       - musl-amd64
       - musl-aarch64
       - macos-universal
@@ -541,11 +557,6 @@ jobs:
         if: needs.linux-amd64.outputs.ffversion != steps.get_version_release.outputs.release
         uses: actions/download-artifact@v4
 
-      - name: rm old artifacts
-        if: needs.linux-amd64.outputs.ffversion != steps.get_version_release.outputs.release
-        run: |
-          rm -rf fastfetch-*-old-*
-
       - name: create release
         if: needs.linux-amd64.outputs.ffversion != steps.get_version_release.outputs.release
         uses: ncipollo/release-action@v1

CHANGELOG.md

@@ -1,3 +1,59 @@
+# 2.11.1
+
+Hotfix for Android
+
+Bugfixes:
+* Fix uninitialized variables which can cause crashes (#760 #838, Battery, Android)
+* Don't detect hyfetch as shell when used as a backend of hyfetch
+* Fix incorrect information in man page
+
+Features:
+* Support sorcery package manager detection (Packages, Linux)
+* Make `--custom-format` optional (Custom)
+* Make `/` an alias of `C:\` for `--disk-folders` (Disk, Windows)
+
+Logo:
+* Fix colors of Source Mage logo
+
+
+# 2.11.0
+
+Changes:
+* Default `hideCursor` to false. It doesn't make much difference but makes user's terminal unusable if fastfetch is not exited correctly.
+* Linux amd64 binaries are built with Ubuntu 20.04 again (#808)
+
+Bugfixes:
+* Fix swap usage detection in x86-32 build (Windows, Swap)
+* Fix minimum cmake version support (#810)
+* Fix wifi detection on platforms that don't use NetworkManager (#811, Wifi, Linux)
+* Fix NixOS wrapped process name (#814, Terminal, Linux)
+* Fix GPU type detection for AMD cards (#816, GPU, Linux)
+* Silence system deprecation warnings (#822, Camera, macOS)
+
+Features:
+* Add basic support DE detection support for UKUI (DE, Linux)
+* Support printing total number of nix / flatpak / brew packages (Packages)
+    * See `fastfetch -h packages-format` for detail
+* Better max CPU frequency detection support with `CPUID / 16H` instruction (CPU, Windows)
+    * This requires Intel Core I Gen 6 or newer, and with `Virtual Machine Platform` Windows feature disabled. X86 only.
+* Improve performance of nix packages detection (Packages, Linux)
+* Make config specified in JSONC overridable by command line flags
+    * Note this change only make global config overridable; module configs are still not
+* Suggest increasing `--processing-timeout` when child process timeouts
+* Only detect folders that specified by `--disk-folders`
+    * Previously `--disk-folders` only omits unmatched disks from output
+    * This option can be used to improve detection performance by ignoring slow network drives
+
+# 2.10.2
+
+Bugfixes:
+* Fix a regression that detect x11 as wayland (#805, WM, Linux)
+
+# 2.10.1
+
+Bugfixes:
+* Fix build with `-DENABLE_DBUS=OFF` (Linux)
+
 # 2.10.0
 
 Changes:

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.10.0
+    VERSION 2.11.1
     LANGUAGES C
     DESCRIPTION "Fast neofetch-like system information tool"
     HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -255,7 +255,7 @@ file(GLOB LOGO_FILES "src/logo/ascii/*.txt")
 set(LOGO_BUILTIN_H "#pragma once\n#pragma GCC diagnostic ignored \"-Wtrigraphs\"\n\n")
 foreach(file ${LOGO_FILES})
     fastfetch_load_text("${file}" content)
-    get_filename_component(file "${file}" NAME_WLE)
+    get_filename_component(file "${file}" NAME_WE)
     string(TOUPPER "${file}" file)
     string(REGEX REPLACE "\\$\\{c([0-9]+)\\}" "$\\1" content "${content}")
     set(LOGO_BUILTIN_H "${LOGO_BUILTIN_H}#define FASTFETCH_DATATEXT_LOGO_${file} ${content}\n")
@@ -933,10 +933,6 @@ if(ENABLE_THREADS)
     endif()
 endif()
 
-if(ENABLE_PCI_MEMORY)
-    target_compile_definitions(libfastfetch PRIVATE FF_USE_PCI_MEMORY)
-endif()
-
 if(LINUX)
     target_link_libraries(libfastfetch
         PRIVATE "m"
@@ -1147,16 +1143,20 @@ endif()
 
 if(LINUX)
     find_program(HAVE_DPKG "dpkg")
-    find_program(HAVE_RPMBUILD "rpmbuild")
-    if(HAVE_DPKG AND HAVE_RPMBUILD)
-        set(CPACK_GENERATOR "${CPACK_GENERATOR};DEB;RPM")
+    if(HAVE_DPKG)
+        set(CPACK_GENERATOR "${CPACK_GENERATOR};DEB")
+
+        set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
+        set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+        set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
     endif()
 
-    set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
-    set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
-    set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
+    find_program(HAVE_RPMBUILD "rpmbuild")
+    if(HAVE_RPMBUILD)
+        set(CPACK_GENERATOR "${CPACK_GENERATOR};RPM")
 
-    set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+        set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+    endif()
 endif()
 
 set(CPACK_SET_DESTDIR ON)

README.md

@@ -29,8 +29,8 @@ 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 above)
-* Debian / Ubuntu: Download `fastfetch-<version>-Linux.deb` from [Github release page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and `dpkg -i fastfetch-<version>-Linux.deb` (for Ubuntu 22.04 or above and Debian 12 or above).
+* Ubuntu: [`ppa:zhangsongcui3371/fastfetch`](https://launchpad.net/~zhangsongcui3371/+archive/ubuntu/fastfetch) (for Ubuntu 22.04 or newer)
+* Debian / Ubuntu: Download `fastfetch-<version>-Linux.deb` from [Github release page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and `dpkg -i fastfetch-<version>-Linux.deb` (for Ubuntu 20.04 or newer and Debian 11 or newer).
 * Arch Linux: `sudo pacman -S fastfetch`
 * Fedora: `sudo dnf install fastfetch`
 * Gentoo: `sudo emerge --ask app-misc/fastfetch`

doc/fastfetch.1.in

@@ -125,7 +125,7 @@ The specified configuration/preset files are searched in the following order:
 When both a '.jsonc' and a '.conf' file with the same name is found,
 the '.jsonc' file is preferred.
 
-Fastfetch provides some default presets. List them with \fB \-\-print\-available\-presets\fR.
+Fastfetch provides some default presets. List them with \fB\-\-list\-presets\fR.
 
 .SH "SEE ALSO"
 .BR neofetch (1)

doc/json_schema.json

@@ -679,6 +679,7 @@
                             "board",
                             "break",
                             "brightness",
+                            "camera",
                             "chassis",
                             "cpu",
                             "cpuusage",
@@ -772,6 +773,10 @@
                                                 "const": "board",
                                                 "description": "Print mather board name and other info"
                                             },
+                                            {
+                                                "const": "camera",
+                                                "description": "Print available cameras"
+                                            },
                                             {
                                                 "const": "cursor",
                                                 "description": "Print cursor style name"
@@ -1112,6 +1117,9 @@
                                                 "maxItems": 2
                                             }
                                         }
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
                                     }
                                 }
                             },
@@ -1169,10 +1177,7 @@
                                         "description": "Text to print",
                                         "type": "string"
                                     }
-                                },
-                                "required": [
-                                    "format"
-                                ]
+                                }
                             },
                             {
                                 "title": "Display",
@@ -1233,7 +1238,7 @@
                                     },
                                     "folders": {
                                         "type": "string",
-                                        "description": "A colon (semicolon on Windows) separated list of folder paths for the disk output\nDefault: auto detection using mount-points"
+                                        "description": "A colon (semicolon on Windows) separated list of folder paths for the disk output\nDefault: auto detection using mount-points\nThis option overrides other `show*` options"
                                     },
                                     "showExternal": {
                                         "type": "boolean",

presets/examples/11.jsonc

@@ -1,5 +1,5 @@
 {
-    "$schema": "file:///C:/msys64/home/zhang/fastfetch/doc/json_schema.json",
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
     "logo": {
         "type": "small"
     },

presets/examples/13.jsonc

@@ -0,0 +1,85 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small",
+        "padding": {
+            "top": 1
+        }
+    },
+    "display": {
+        "separator": "",
+        "keyWidth": 15
+    },
+    "modules": [
+        {
+            "key": "╭───────────╮",
+            "type": "custom"
+        },
+        {
+            // draw borders first to make colors of left and right border consistant
+            "key": "│           │\u001b[11D\u001b[31m user",
+            "type": "title",
+            "format": "{1}"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[32m󰇅 hname",
+            "type": "title",
+            "format": "{2}"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[33m󰅐 uptime",
+            "type": "uptime"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[34m󰟾 distro",
+            "type": "os"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[35m kernel",
+            "type": "kernel"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[36m󰇄 desktop",
+            "type": "de"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[31m term",
+            "type": "terminal"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[32m shell",
+            "type": "shell"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[33m󰍛 cpu",
+            "type": "cpu"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[34m󰉉 disk",
+            "type": "disk",
+            "folders": "/"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[35m memory",
+            "type": "memory"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[36m󰩟 network",
+            "type": "localip",
+            "format": "{1} ({4})"
+        },
+        {
+            "key": "├───────────┤",
+            "type": "custom"
+        },
+        {
+            "key": "│           │\u001b[11D\u001b[m colors",
+            "type": "colors",
+            "symbol": "circle"
+        },
+        {
+            "key": "╰───────────╯",
+            "type": "custom"
+        }
+    ]
+}

src/common/init.c

@@ -238,9 +238,6 @@ void ffListFeatures(void)
         #ifdef FF_HAVE_DDCUTIL
             "libddcutil\n"
         #endif
-        #if __has_include(<linux/videodev2.h>)
-            "videodev2\n"
-        #endif
         #ifdef FF_HAVE_DIRECTX_HEADERS
             "Directx Headers\n"
         #endif
@@ -250,8 +247,11 @@ void ffListFeatures(void)
         #ifdef FF_USE_SYSTEM_YYJSON
             "System yyjson\n"
         #endif
-        #ifdef FF_USE_PCI_MEMORY
-            "PCI memory\n"
+        #if __has_include(<linux/videodev2.h>)
+            "linux/videodev2\n"
+        #endif
+        #if __has_include(<linux/wireless.h>)
+            "linux/wireless\n"
         #endif
         ""
     , stdout);

src/common/library.c

@@ -4,7 +4,7 @@
 #include <stdarg.h>
 
 //Clang doesn't define __SANITIZE_ADDRESS__ but defines __has_feature(address_sanitizer)
-#if defined(__has_feature)
+#if !defined(__SANITIZE_ADDRESS__) && defined(__has_feature)
     #if __has_feature(address_sanitizer)
         #define __SANITIZE_ADDRESS__
     #endif

src/common/processing_linux.c

@@ -68,7 +68,7 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
             {
                 kill(childPid, SIGTERM);
                 waitpid(childPid, NULL, 0);
-                return "poll(&pollfd, 1, timeout) timeout";
+                return "poll(&pollfd, 1, timeout) timeout (try increasing --processing-timeout)";
             }
             else if (pollfd.revents & POLLERR)
             {

src/common/processing_windows.c

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

src/data/help.json

@@ -947,7 +947,8 @@
         },
         {
             "long": "disk-folders",
-            "desc": "A colon (semicolon on Windows) separated list of folder paths for the disk output",
+            "desc": "A colon (semicolon on Windows) separated list of folder paths to be detected",
+            "remark": "On Windows, a drive latter must be upper cased and end with \"\\\". \"/\" is used as an alias of the system drive. This option overrides other disk-show-* options",
             "arg": {
                 "type": "path",
                 "default": "Auto detection using mount-points"

src/detection/battery/battery_android.c

@@ -40,6 +40,7 @@ static const char* parseTermuxApi(FFBatteryOptions* options, FFlist* results)
     ffStrbufInit(&battery->modelName);
     ffStrbufInit(&battery->status);
     ffStrbufInit(&battery->technology);
+    ffStrbufInit(&battery->serial);
     ffStrbufInit(&battery->manufactureDate);
 
     battery->capacity = yyjson_get_num(yyjson_obj_get(root, "percentage"));
@@ -77,6 +78,8 @@ static const char* parseDumpsys(FFBatteryOptions* options, FFlist* results)
     ffStrbufInit(&battery->modelName);
     ffStrbufInit(&battery->status);
     ffStrbufInit(&battery->technology);
+    ffStrbufInit(&battery->serial);
+    ffStrbufInit(&battery->manufactureDate);
 
     if (ffParsePropLines(start, "AC powered: ", &temp) && ffStrbufEqualS(&temp, "true"))
         ffStrbufAppendS(&battery->status, "AC powered");

src/detection/camera/camera_apple.m

@@ -1,10 +1,14 @@
 #include "camera.h"
+#include "common/io/io.h"
 
 #import <AVFoundation/AVCaptureDevice.h>
 
 const char* ffDetectCamera(FFlist* result)
 {
-    AVCaptureDeviceDiscoverySession* session = [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:@[AVCaptureDeviceTypeBuiltInWideAngleCamera] mediaType:AVMediaTypeVideo position:AVCaptureDevicePositionUnspecified];
+    FF_SUPPRESS_IO(); // #822
+    AVCaptureDeviceDiscoverySession* session = [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:@[AVCaptureDeviceTypeBuiltInWideAngleCamera, AVCaptureDeviceTypeExternalUnknown]
+                                                                                mediaType:AVMediaTypeVideo
+                                                                                position:AVCaptureDevicePositionUnspecified];
     if (!session)
         return "Failed to create AVCaptureDeviceDiscoverySession";
 

src/detection/cpu/cpu_windows.c

@@ -50,6 +50,31 @@ typedef struct FFSmbiosProcessorInfo
     uint16_t ThreadEnabled; // varies
 } FFSmbiosProcessorInfo;
 
+#if defined(__x86_64__) || defined(__i386__)
+
+#include <cpuid.h>
+
+inline static const char* detectSpeedByCpuid(FFCPUResult* cpu)
+{
+    uint32_t base = 0, max = 0, bus = 0, unused = 0;
+    if (!__get_cpuid(0x16, &base, &max, &bus, &unused))
+        return "Unsupported instruction";
+
+    // cpuid returns 0 MHz when hyper-v is enabled
+    if (base) cpu->frequencyBase = base / 1000.0;
+    if (max) cpu->frequencyMax = max / 1000.0;
+    return NULL;
+}
+
+#else
+
+inline static const char* detectSpeedByCpuid(FF_MAYBE_UNUSED FFCPUResult* cpu)
+{
+    return "Unsupported platform";
+}
+
+#endif
+
 static const char* detectMaxSpeedBySmbios(FFCPUResult* cpu)
 {
     const FFSmbiosProcessorInfo* data = (const FFSmbiosProcessorInfo*) (*ffGetSmbiosHeaderTable())[FF_SMBIOS_TYPE_PROCESSOR_INFO];
@@ -114,6 +139,7 @@ static const char* detectByRegistry(FFCPUResult* cpu)
     if(!ffRegOpenKeyForRead(HKEY_LOCAL_MACHINE, L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", &hKey, NULL))
         return "ffRegOpenKeyForRead(HKEY_LOCAL_MACHINE, L\"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0\", &hKey, NULL) failed";
 
+    if (detectSpeedByCpuid(cpu) != NULL || cpu->frequencyBase != cpu->frequencyBase)
     {
         uint32_t mhz;
         if(ffRegReadUint(hKey, L"~MHz", &mhz, NULL))
@@ -141,7 +167,8 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
     if (error)
         return error;
 
-    detectMaxSpeedBySmbios(cpu);
+    if (cpu->frequencyMax != cpu->frequencyMax)
+        detectMaxSpeedBySmbios(cpu);
 
     if(options->temp)
         ffDetectSmbiosTemp(&cpu->temperature, NULL);

src/detection/de/de_linux.c

@@ -43,19 +43,23 @@ static void getKDE(FFstrbuf* result, FFDEOptions* options)
     }
 }
 
-static const char* getGnomeBySo(FFstrbuf* result)
+static const char* getGnomeByDbus(FF_MAYBE_UNUSED FFstrbuf* result)
 {
+#ifdef FF_HAVE_DBUS
     FFDBusData dbus;
     if (ffDBusLoadData(DBUS_BUS_SESSION, &dbus) != NULL)
         return "ffDBusLoadData() failed";
 
     ffDBusGetPropertyString(&dbus, "org.gnome.Shell", "/org/gnome/Shell", "org.gnome.Shell", "ShellVersion", result);
     return NULL;
+#else // FF_HAVE_DBUS
+    return "ffDBusLoadData() failed: dbus support not compiled in";
+#endif // FF_HAVE_DBUS
 }
 
 static void getGnome(FFstrbuf* result, FF_MAYBE_UNUSED FFDEOptions* options)
 {
-    getGnomeBySo(result);
+    getGnomeByDbus(result);
 
     if (result->length == 0 && options->slowVersionDetection)
     {

src/detection/disk/disk.c

@@ -1,6 +1,29 @@
 #include "disk.h"
 
-const char* ffDetectDisksImpl(FFlist* disks);
+bool ffDiskMatchMountpoint(FFDiskOptions* options, const char* mountpoint)
+{
+    #ifdef _WIN32
+    const char separator = ';';
+    #else
+    const char separator = ':';
+    #endif
+
+    uint32_t mountpointLength = (uint32_t) strlen(mountpoint);
+
+    uint32_t startIndex = 0;
+    while(startIndex < options->folders.length)
+    {
+        uint32_t colonIndex = ffStrbufNextIndexC(&options->folders, startIndex, separator);
+
+        uint32_t folderLength = colonIndex - startIndex;
+        if (folderLength == mountpointLength && memcmp(options->folders.chars + startIndex, mountpoint, mountpointLength) == 0)
+            return true;
+
+        startIndex = colonIndex + 1;
+    }
+
+    return false;
+}
 
 static int compareDisks(const FFDisk* disk1, const FFDisk* disk2)
 {
@@ -9,7 +32,7 @@ static int compareDisks(const FFDisk* disk1, const FFDisk* disk2)
 
 const char* ffDetectDisks(FFDiskOptions* options, FFlist* disks)
 {
-    const char* error = ffDetectDisksImpl(disks);
+    const char* error = ffDetectDisksImpl(options, disks);
 
     if (error) return error;
     if (disks->length == 0) return "No disks found";

src/detection/disk/disk.h

@@ -26,3 +26,6 @@ typedef struct FFDisk
  * If error is not set, disks contains at least one disk.
  */
 const char* ffDetectDisks(FFDiskOptions* options, FFlist* disks /* list of FFDisk */);
+
+const char* ffDetectDisksImpl(FFDiskOptions* options, FFlist* disks);
+bool ffDiskMatchMountpoint(FFDiskOptions* options, const char* mountpoint);

src/detection/disk/disk_bsd.c

@@ -90,7 +90,7 @@ void detectFsInfo(struct statfs* fs, FFDisk* disk)
 }
 #endif
 
-const char* ffDetectDisksImpl(FFlist* disks)
+const char* ffDetectDisksImpl(FFDiskOptions* options, FFlist* disks)
 {
     int size = getfsstat(NULL, 0, MNT_WAIT);
 
@@ -103,7 +103,12 @@ const char* ffDetectDisksImpl(FFlist* disks)
 
     for(struct statfs* fs = buf; fs < buf + size; ++fs)
     {
-        if(!ffStrStartsWith(fs->f_mntfromname, "/dev/") && !ffStrEquals(fs->f_fstypename, "zfs"))
+        if(__builtin_expect(options->folders.length, 0))
+        {
+            if(!ffDiskMatchMountpoint(options, fs->f_mntonname))
+                continue;
+        }
+        else if(!ffStrStartsWith(fs->f_mntfromname, "/dev/") && !ffStrEquals(fs->f_fstypename, "zfs"))
             continue;
 
         #ifdef __FreeBSD__

src/detection/disk/disk_linux.c

@@ -250,7 +250,7 @@ static void detectStats(FFDisk* disk)
     #endif
 }
 
-const char* ffDetectDisksImpl(FFlist* disks)
+const char* ffDetectDisksImpl(FFDiskOptions* options, FFlist* disks)
 {
     FILE* mountsFile = setmntent("/proc/mounts", "r");
     if(mountsFile == NULL)
@@ -260,7 +260,12 @@ const char* ffDetectDisksImpl(FFlist* disks)
 
     while((device = getmntent(mountsFile)))
     {
-        if(!isPhysicalDevice(device))
+        if (__builtin_expect(options->folders.length, 0))
+        {
+            if (!ffDiskMatchMountpoint(options, device->mnt_dir))
+                continue;
+        }
+        else if(!isPhysicalDevice(device))
             continue;
 
         //We have a valid device, add it to the list

src/detection/disk/disk_windows.c

@@ -4,25 +4,40 @@
 
 #include <windows.h>
 #include <winioctl.h>
-#include <assert.h>
 
-const char* ffDetectDisksImpl(FFlist* disks)
+const char* ffDetectDisksImpl(FFDiskOptions* options, FFlist* disks)
 {
     wchar_t buf[MAX_PATH + 1];
     uint32_t length = GetLogicalDriveStringsW(sizeof(buf) / sizeof(*buf), buf);
     if (length == 0 || length >= sizeof(buf) / sizeof(*buf))
         return "GetLogicalDriveStringsW(sizeof(buf) / sizeof(*buf), buf) failed";
 
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+
+    // For cross-platform portability; used by `presets/examples/13.jsonc`
+    if (__builtin_expect(options->folders.length == 1 && options->folders.chars[0] == '/', 0))
+    {
+        wchar_t path[MAX_PATH + 1];
+        GetSystemWindowsDirectoryW(path, sizeof(path) / sizeof(*path));
+        ffStrbufSetF(&options->folders, "%c:\\", (char) path[0]);
+    }
+
     for(uint32_t i = 0; i < length; i++)
     {
         wchar_t* mountpoint = buf + i;
 
+        ffStrbufSetWS(&buffer, mountpoint);
+        i += buffer.length;
+
         UINT driveType = GetDriveTypeW(mountpoint);
-        if(driveType == DRIVE_NO_ROOT_DIR)
+
+        if (__builtin_expect((long) options->folders.length, 0))
         {
-            i += (uint32_t)wcslen(mountpoint);
-            continue;
+            if (!ffDiskMatchMountpoint(options, buffer.chars))
+                continue;
         }
+        else if(driveType == DRIVE_NO_ROOT_DIR)
+            continue;
 
         FFDisk* disk = ffListAdd(disks);
 
@@ -77,7 +92,7 @@ const char* ffDetectDisksImpl(FFlist* disks)
         else
             disk->createTime = 0;
 
-        ffStrbufInitWS(&disk->mountpoint, mountpoint);
+        ffStrbufInitMove(&disk->mountpoint, &buffer);
         if (mountpoint[2] == L'\\' && mountpoint[3] == L'\0')
         {
             wchar_t volumeName[MAX_PATH + 1];
@@ -91,8 +106,6 @@ const char* ffDetectDisksImpl(FFlist* disks)
         //Unsupported
         disk->filesUsed = 0;
         disk->filesTotal = 0;
-
-        i += disk->mountpoint.length;
     }
 
     return NULL;

src/detection/displayserver/displayserver.h

@@ -13,6 +13,7 @@
 #define FF_DE_PRETTY_BUDGIE "Budgie"
 #define FF_DE_PRETTY_CDE "CDE"
 #define FF_DE_PRETTY_UNITY "Unity"
+#define FF_DE_PRETTY_UKUI "UKUI"
 
 #define FF_WM_PRETTY_KWIN "KWin"
 #define FF_WM_PRETTY_MUTTER "Mutter"

src/detection/displayserver/linux/wayland/global-output.c

@@ -118,7 +118,7 @@ void ffWaylandHandleGlobalOutput(WaylandData* wldata, struct wl_registry* regist
         rotation,
         display.edidName.length
             ? &display.edidName
-            : display.description.length
+            : display.description.length && !ffStrbufEndsWithS(&display.description, "-unknown")
                 ? &display.description
                 : &display.name,
         display.type,

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

@@ -135,7 +135,7 @@ void ffdsConnectWayland(FFDisplayServerResult* result)
     const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
 
     //If XDG_SESSION_TYPE is set, and doesn't contain "wayland", we are probably not running in a wayland session.
-    if(xdgSessionType != NULL && ffStrEqualsIgnCase(xdgSessionType, "wayland"))
+    if(xdgSessionType != NULL && !ffStrEqualsIgnCase(xdgSessionType, "wayland"))
         return;
 
     //If XDG_SESSION_TYPE is not set, check if WAYLAND_DISPLAY or WAYLAND_SOCKET is set.

src/detection/displayserver/linux/wayland/zwlr-output.c

@@ -6,7 +6,7 @@
 static void waylandZwlrTransformListener(void* data, FF_MAYBE_UNUSED struct zwlr_output_head_v1 *zwlr_output_head_v1, int32_t transform)
 {
     WaylandDisplay* wldata = (WaylandDisplay*) data;
-    wldata->transform = transform;
+    wldata->transform = (enum wl_output_transform) transform;
 }
 
 static void waylandZwlrScaleListener(void* data, FF_MAYBE_UNUSED struct zwlr_output_head_v1 *zwlr_output_head_v1, wl_fixed_t scale)

src/detection/displayserver/linux/wmde.c

@@ -75,7 +75,9 @@ static void applyPrettyNameIfWM(FFDisplayServerResult* result, const char* name)
         ffStrEqualsIgnCase(name, "kwin_wayland_wrapper") ||
         ffStrEqualsIgnCase(name, "kwin_x11") ||
         ffStrEqualsIgnCase(name, "kwin_x11_wrapper") ||
-        ffStrEqualsIgnCase(name, "kwin")
+        ffStrEqualsIgnCase(name, "kwin") ||
+        ffStrEndsWithIgnCase(name, "-kwin_wayland") ||
+        ffStrEndsWithIgnCase(name, "-kwin_x11")
     ) ffStrbufSetS(&result->wmPrettyName, FF_WM_PRETTY_KWIN);
     else if(
         ffStrEqualsIgnCase(name, "gnome-shell") ||
@@ -231,6 +233,13 @@ static void applyPrettyNameIfDE(FFDisplayServerResult* result, const char* name)
         ffStrbufSetS(&result->deProcessName, "dtsession");
         ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_CDE);
     }
+
+    else if(
+        ffStrEqualsIgnCase(name, "ukui-session")
+    ) {
+        ffStrbufSetS(&result->deProcessName, "ukui-session");
+        ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_UKUI);
+    }
 }
 
 static void getWMProtocolNameFromEnv(FFDisplayServerResult* result)

src/detection/gpu/gpu_linux.c

@@ -15,23 +15,6 @@
 
 #include <inttypes.h>
 
-FF_MAYBE_UNUSED static void pciDetectTemp(FFGPUResult* gpu, uint32_t deviceClass)
-{
-    const FFlist* tempsResult = ffDetectTemps();
-
-    FF_LIST_FOR_EACH(FFTempValue, tempValue, *tempsResult)
-    {
-        // https://www.kernel.org/doc/html/v5.10/gpu/amdgpu.html#hwmon-interfaces
-        // FIXME: this code doesn't take multiGPUs into count
-        // The kernel exposes the device class multiplied by 256 for some reason
-        if(tempValue->deviceClass == deviceClass * 256)
-        {
-            gpu->temperature = tempValue->value;
-            return;
-        }
-    }
-}
-
 static void pciDetectDriver(FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer)
 {
     ffStrbufAppendS(pciDir, "/driver");
@@ -56,33 +39,64 @@ static void pciDetectDriver(FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer
     }
 }
 
-static void pciDetectVmem(FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer)
+static void pciDetectAmdSpecific(const FFGPUOptions* options, FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer)
 {
-    // Works for AMD GPUs
     // https://www.kernel.org/doc/html/v5.10/gpu/amdgpu.html#mem-info-vis-vram-total
-    ffStrbufAppendS(pciDir, "/mem_info_vis_vram_total");
-    uint64_t size = 0;
-    if (ffReadFileBuffer(pciDir->chars, buffer) && (size = ffStrbufToUInt(buffer, 0)))
-    {
-        gpu->type = size > 1024UL * 1024 * 1024 ? FF_GPU_TYPE_DISCRETE : FF_GPU_TYPE_INTEGRATED;
-        if (gpu->type == FF_GPU_TYPE_DISCRETE)
-            gpu->dedicated.total = size;
-        else
-            gpu->shared.total = size;
+    const uint32_t pciDirLen = pciDir->length;
 
-        ffStrbufSubstrBefore(pciDir, pciDir->length - (uint32_t) strlen("/mem_info_vis_vram_total"));
-        ffStrbufAppendS(pciDir, "/mem_info_vram_used");
-        if (ffReadFileBuffer(pciDir->chars, buffer) && (size = ffStrbufToUInt(buffer, 0)))
+    ffStrbufAppendS(pciDir, "/hwmon/");
+    FF_AUTO_CLOSE_DIR DIR* dirp = opendir(pciDir->chars);
+    struct dirent* entry;
+    while ((entry = readdir(dirp)) != NULL)
+    {
+        if (entry->d_name[0] == '.') continue;
+        break;
+    }
+    if (!entry) return;
+    ffStrbufAppendS(pciDir, entry->d_name);
+    ffStrbufAppendC(pciDir, '/');
+
+    const uint32_t hwmonLen = pciDir->length;
+    ffStrbufAppendS(pciDir, "in1_input"); // Northbridge voltage in millivolts (APUs only)
+    if (ffPathExists(pciDir->chars, FF_PATHTYPE_FILE))
+        gpu->type = FF_GPU_TYPE_INTEGRATED;
+    else
+        gpu->type = FF_GPU_TYPE_DISCRETE;
+
+    uint64_t value = 0;
+    if (options->temp)
+    {
+        ffStrbufSubstrBefore(pciDir, hwmonLen);
+        ffStrbufAppendS(pciDir, "temp1_input"); // The on die GPU temperature in millidegrees Celsius
+        if (ffReadFileBuffer(pciDir->chars, buffer) && (value = ffStrbufToUInt(buffer, 0)))
+            gpu->temperature = (double) value / 1000;
+    }
+
+    ffStrbufSubstrBefore(pciDir, hwmonLen);
+    ffStrbufAppendS(pciDir, "freq1_input"); // The gfx/compute clock in hertz
+    if (ffReadFileBuffer(pciDir->chars, buffer) && (value = ffStrbufToUInt(buffer, 0)))
+        gpu->frequency = (double) value / (1000 * 1000 * 1000);
+
+    if (options->driverSpecific)
+    {
+        ffStrbufSubstrBefore(pciDir, pciDirLen);
+        ffStrbufAppendS(pciDir, "/mem_info_vis_vram_total");
+        if (ffReadFileBuffer(pciDir->chars, buffer) && (value = ffStrbufToUInt(buffer, 0)))
         {
-            if (gpu->type == FF_GPU_TYPE_DISCRETE)
-                gpu->dedicated.used = size;
-            else
-                gpu->shared.used = size;
+            ffStrbufSubstrBefore(pciDir, pciDir->length - (uint32_t) strlen("/mem_info_vis_vram_total"));
+            ffStrbufAppendS(pciDir, "/mem_info_vis_vram_used");
+            if (ffReadFileBuffer(pciDir->chars, buffer) && (value = ffStrbufToUInt(buffer, 0)))
+            {
+                if (gpu->type == FF_GPU_TYPE_DISCRETE)
+                    gpu->dedicated.used = value;
+                else
+                    gpu->shared.used = value;
+            }
         }
     }
 }
 
-static void pciDetectVfreq(FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer)
+static void pciDetectIntelSpecific(FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer)
 {
     if (!ffStrbufEndsWithS(pciDir, "/device")) // Must be in `/sys/class/drm/cardN/device`
         return;
@@ -98,6 +112,10 @@ static void pciDetectVfreq(FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer)
         str[len] = '\0';
         gpu->frequency = (double) strtoul(str, NULL, 10) / 1000.0;
     }
+
+    if (ffStrbufStartsWithS(&gpu->name, "Intel "))
+        ffStrbufSubstrAfter(&gpu->name, (uint32_t) strlen("Intel "));
+    gpu->type = ffStrbufStartsWithIgnCaseS(&gpu->name, "Arc ") ? FF_GPU_TYPE_DISCRETE : FF_GPU_TYPE_INTEGRATED;
 }
 
 static bool loadPciIds(FFstrbuf* pciids)
@@ -186,43 +204,50 @@ static const char* detectPci(const FFGPUOptions* options, FFlist* gpus, FFstrbuf
             ffGPUParsePciIds(&pciids, subclassId, (uint16_t) vendorId, (uint16_t) deviceId, gpu);
     }
 
-    pciDetectVmem(gpu, drmDir, buffer);
-    ffStrbufSubstrBefore(drmDir, drmDirPathLength);
-
-    pciDetectVfreq(gpu, drmDir, buffer);
-    ffStrbufSubstrBefore(drmDir, drmDirPathLength);
-
     pciDetectDriver(gpu, drmDir, buffer);
     ffStrbufSubstrBefore(drmDir, drmDirPathLength);
 
-    #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
-    if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_NVIDIA && (options->temp || options->driverSpecific))
+    if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_AMD)
     {
-        ffDetectNvidiaGpuInfo(&(FFGpuDriverCondition) {
-            .type = FF_GPU_DRIVER_CONDITION_TYPE_BUS_ID,
-            .pciBusId = {
-                .domain = pciDomain,
-                .bus = pciBus,
-                .device = pciDevice,
-                .func = pciFunc,
-            },
-        }, (FFGpuDriverResult) {
-            .temp = options->temp ? &gpu->temperature : NULL,
-            .memory = options->driverSpecific ? &gpu->dedicated : NULL,
-            .coreCount = options->driverSpecific ? (uint32_t*) &gpu->coreCount : NULL,
-            .type = &gpu->type,
-            .frequency = &gpu->frequency,
-        }, "libnvidia-ml.so");
-
-        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;
+        pciDetectAmdSpecific(options, gpu, drmDir, buffer);
+        ffStrbufSubstrBefore(drmDir, drmDirPathLength);
     }
-    #endif // FF_USE_PROPRIETARY_GPU_DRIVER_API
+    else if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_INTEL)
+    {
+        pciDetectIntelSpecific(gpu, drmDir, buffer);
+        ffStrbufSubstrBefore(drmDir, drmDirPathLength);
+    }
+    else if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_NVIDIA)
+    {
+        #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
+        if (options->temp || options->driverSpecific)
+        {
+            ffDetectNvidiaGpuInfo(&(FFGpuDriverCondition) {
+                .type = FF_GPU_DRIVER_CONDITION_TYPE_BUS_ID,
+                .pciBusId = {
+                    .domain = pciDomain,
+                    .bus = pciBus,
+                    .device = pciDevice,
+                    .func = pciFunc,
+                },
+            }, (FFGpuDriverResult) {
+                .temp = options->temp ? &gpu->temperature : NULL,
+                .memory = options->driverSpecific ? &gpu->dedicated : NULL,
+                .coreCount = options->driverSpecific ? (uint32_t*) &gpu->coreCount : NULL,
+                .type = &gpu->type,
+                .frequency = &gpu->frequency,
+            }, "libnvidia-ml.so");
+        }
+        #endif // FF_USE_PROPRIETARY_GPU_DRIVER_API
 
-    #ifdef __linux__
-    if(options->temp && gpu->temperature != gpu->temperature)
-        pciDetectTemp(gpu, ((uint32_t) classId << 8) + subclassId);
-    #endif
+        if (gpu->type == FF_GPU_TYPE_UNKNOWN)
+        {
+            if (ffStrbufStartsWithIgnCaseS(&gpu->name, "GeForce") ||
+                ffStrbufStartsWithIgnCaseS(&gpu->name, "Quadro") ||
+                ffStrbufStartsWithIgnCaseS(&gpu->name, "Tesla"))
+                gpu->type = FF_GPU_TYPE_DISCRETE;
+        }
+    }
 
     return NULL;
 }

src/detection/os/os_linux.c

@@ -150,8 +150,11 @@ static void detectOS(FFOSResult* os)
 
         if(os->prettyName.length == 0)
             ffStrbufAppendS(&os->prettyName, "Bedrock Linux");
+        
+        parseFile("/bedrock"FASTFETCH_TARGET_DIR_ETC"/os-release", os);
 
-        return;
+        if(allRelevantValuesSet(os))
+            return;
     }
 
     parseFile(FASTFETCH_TARGET_DIR_ETC"/os-release", os);

src/detection/packages/packages.h

@@ -26,6 +26,7 @@ typedef struct FFPackagesResult
     uint32_t rpm;
     uint32_t scoop;
     uint32_t snap;
+    uint32_t sorcery;
     uint32_t winget;
     uint32_t xbps;
 

src/detection/packages/packages_linux.c

@@ -118,28 +118,146 @@ static uint32_t countFilesRecursive(FFstrbuf* baseDir, const char* dirname, cons
     return sum;
 }
 
+static bool isValidNixPkg(FFstrbuf* pkg)
+{
+    if (!ffPathExists(pkg->chars, FF_PATHTYPE_DIRECTORY))
+        return false;
+
+    ffStrbufSubstrAfterLastC(pkg, '/');
+    if (
+        ffStrbufStartsWithS(pkg, "nixos-system-nixos-") ||
+        ffStrbufEndsWithS(pkg, "-doc") ||
+        ffStrbufEndsWithS(pkg, "-man") ||
+        ffStrbufEndsWithS(pkg, "-info") ||
+        ffStrbufEndsWithS(pkg, "-dev") ||
+        ffStrbufEndsWithS(pkg, "-bin")
+    ) return false;
+
+    enum { START, DIGIT, DOT, MATCH } state = START;
+
+    for (uint32_t i = 0; i < pkg->length; i++)
+    {
+        char c = pkg->chars[i];
+        switch (state)
+        {
+            case START:
+                if (c >= '0' && c <= '9')
+                    state = DIGIT;
+                break;
+            case DIGIT:
+                if (c >= '0' && c <= '9')
+                    continue;
+                if (c == '.')
+                    state = DOT;
+                else
+                    state = START;
+                break;
+            case DOT:
+                if (c >= '0' && c <= '9')
+                    state = MATCH;
+                else
+                    state = START;
+                break;
+            case MATCH:
+                break;
+        }
+    }
+
+    return state == MATCH;
+}
+
+static bool checkNixCache(FFstrbuf* cacheDir, FFstrbuf* hash, uint32_t* count)
+{
+    if (!ffPathExists(cacheDir->chars, FF_PATHTYPE_FILE))
+        return false;
+
+    FF_STRBUF_AUTO_DESTROY cacheContent = ffStrbufCreate();
+    if (!ffReadFileBuffer(cacheDir->chars, &cacheContent))
+        return false;
+
+    // Format: <hash>\n<count>
+    uint32_t split = ffStrbufFirstIndexC(&cacheContent, '\n');
+    if (split == cacheContent.length)
+        return false;
+
+    ffStrbufSetNS(hash, split, cacheContent.chars);
+    *count = (uint32_t)atoi(cacheContent.chars + split + 1);
+
+    return true;
+}
+
+static bool writeNixCache(FFstrbuf* cacheDir, FFstrbuf* hash, uint32_t count)
+{
+    FF_STRBUF_AUTO_DESTROY cacheContent = ffStrbufCreateCopy(hash);
+    ffStrbufAppendF(&cacheContent, "\n%u", count);
+    return ffWriteFileBuffer(cacheDir->chars, &cacheContent);
+}
+
 static uint32_t getNixPackagesImpl(char* path)
 {
     //Nix detection is kinda slow, so we only do it if the dir exists
     if(!ffPathExists(path, FF_PATHTYPE_DIRECTORY))
         return 0;
 
-    FF_STRBUF_AUTO_DESTROY output = ffStrbufCreateA(128);
+    FF_STRBUF_AUTO_DESTROY cacheDir = ffStrbufCreateCopy(&instance.state.platform.cacheDir);
+    ffStrbufEnsureEndsWithC(&cacheDir, '/');
+    ffStrbufAppendS(&cacheDir, "fastfetch/packages/nix");
+    ffStrbufAppendS(&cacheDir, path);
 
-    //https://github.com/fastfetch-cli/fastfetch/issues/195#issuecomment-1191748222
-    FF_STRBUF_AUTO_DESTROY command = ffStrbufCreateA(255);
-    ffStrbufAppendS(&command, "for x in $(nix-store --query --requisites ");
-    ffStrbufAppendS(&command, path);
-    ffStrbufAppendS(&command, "); do if [ -d $x ]; then echo $x ; fi ; done | cut -d- -f2- | egrep '([0-9]{1,}\\.)+[0-9]{1,}' | egrep -v '\\-doc$|\\-man$|\\-info$|\\-dev$|\\-bin$|^nixos-system-nixos-' | uniq | wc -l");
+    //Check the hash first to determine if we need to recompute the count
+    FF_STRBUF_AUTO_DESTROY hash = ffStrbufCreateA(64);
+    FF_STRBUF_AUTO_DESTROY cacheHash = ffStrbufCreateA(64);
+    uint32_t count = 0;
 
-    ffProcessAppendStdOut(&output, (char* const[]) {
-        "sh",
-        "-c",
-        command.chars,
+    ffProcessAppendStdOut(&hash, (char* const[]) {
+        "nix-store",
+        "--query",
+        "--hash",
+        path,
         NULL
     });
 
-    return (uint32_t) strtol(output.chars, NULL, 10);
+    if (checkNixCache(&cacheDir, &cacheHash, &count) && ffStrbufEqual(&hash, &cacheHash))
+        return count;
+
+    //Cache is invalid, recompute the count
+    count = 0;
+
+    //Implementation based on bash script from here:
+    //https://github.com/fastfetch-cli/fastfetch/issues/195#issuecomment-1191748222
+
+    FF_STRBUF_AUTO_DESTROY output = ffStrbufCreateA(1024);
+
+    ffProcessAppendStdOut(&output, (char* const[]) {
+        "nix-store",
+        "--query",
+        "--requisites",
+        path,
+        NULL
+    });
+
+    uint32_t lineLength = 0;
+    for (uint32_t i = 0; i < output.length; i++)
+    {
+        if (output.chars[i] != '\n')
+        {
+            lineLength++;
+            continue;
+        }
+
+        output.chars[i] = '\0';
+        FFstrbuf line = {
+            .allocated = 0,
+            .length = lineLength,
+            .chars = output.chars + i - lineLength
+        };
+        if (isValidNixPkg(&line))
+            count++;
+        lineLength = 0;
+    }
+
+    writeNixCache(&cacheDir, &hash, count);
+    return count;
 }
 
 static uint32_t getNixPackages(FFstrbuf* baseDir, const char* dirname)
@@ -315,6 +433,7 @@ static void getPackageCounts(FFstrbuf* baseDir, FFPackagesResult* packageCounts,
     if (!(options->disabled & FF_PACKAGES_FLAG_PALUDIS_BIT)) packageCounts->paludis += countFilesRecursive(baseDir, "/var/db/paludis/repositories", "environment.bz2");
     if (!(options->disabled & FF_PACKAGES_FLAG_OPKG_BIT)) packageCounts->opkg += getNumStrings(baseDir, "/usr/lib/opkg/status", "Package:"); // openwrt
     if (!(options->disabled & FF_PACKAGES_FLAG_AM_BIT)) packageCounts->am = getAM(baseDir);
+    if (!(options->disabled & FF_PACKAGES_FLAG_SORCERY_BIT)) packageCounts->sorcery += getNumStrings(baseDir, "/var/state/sorcery/packages", ":installed:");
 }
 
 static void getPackageCountsRegular(FFstrbuf* baseDir, FFPackagesResult* packageCounts, FFPackagesOptions* options)

src/detection/swap/swap_windows.c

@@ -7,20 +7,11 @@
 
 const char* ffDetectSwap(FFSwapResult* swap)
 {
-    ULONG size = sizeof(SYSTEM_PAGEFILE_INFORMATION);
-    SYSTEM_PAGEFILE_INFORMATION* FF_AUTO_FREE pstart = (SYSTEM_PAGEFILE_INFORMATION*)malloc(size);
-    while(true)
-    {
-        NTSTATUS status = NtQuerySystemInformation(SystemPagefileInformation, pstart, size, &size);
-        if(status == STATUS_INFO_LENGTH_MISMATCH)
-        {
-            if(!(pstart = (SYSTEM_PAGEFILE_INFORMATION*)realloc(pstart, size)))
-                return "realloc(pstart, size) failed";
-        }
-        else if(!NT_SUCCESS(status))
-            return "NtQuerySystemInformation(SystemPagefileInformation, size) failed";
-        break;
-    }
+    uint8_t buffer[1024];
+    ULONG size = sizeof(buffer);
+    SYSTEM_PAGEFILE_INFORMATION* pstart = (SYSTEM_PAGEFILE_INFORMATION*) buffer;
+    if(!NT_SUCCESS(NtQuerySystemInformation(SystemPagefileInformation, pstart, size, &size)))
+        return "NtQuerySystemInformation(SystemPagefileInformation, size) failed";
 
     uint32_t pageSize = instance.state.platform.pageSize;
     swap->bytesUsed = (uint64_t)pstart->TotalUsed * pageSize;

src/detection/terminalshell/terminalshell_linux.c

@@ -243,6 +243,7 @@ static pid_t getShellInfo(FFShellResult* result, pid_t pid)
                 ffStrEquals(name, "perf")                ||
                 ffStrEquals(name, "guake-wrapped")       ||
                 ffStrEquals(name, "time")                ||
+                ffStrEquals(name, "hyfetch")             || //when hyfetch uses fastfetch as backend
                 ffStrContainsIgnCase(name, "debug")      ||
                 ffStrContainsIgnCase(name, "not-found")  ||
                 ffStrEndsWith(name, ".sh")
@@ -482,14 +483,12 @@ static void setShellInfoDetails(FFShellResult* result)
 
 static void setTerminalInfoDetails(FFTerminalResult* result)
 {
-    if(result->exeName[0] == '.' && ffStrEndsWith(result->exeName, "-wrapped"))
+    if(ffStrbufStartsWithC(&result->processName, '.') && ffStrbufEndsWithS(&result->processName, "-wrapped"))
     {
         // For NixOS. Ref: #510 and https://github.com/NixOS/nixpkgs/pull/249428
         // We use processName when detecting version and font, overriding it for simplification
-        ffStrbufSetNS(
-            &result->processName,
-            (uint32_t) (strlen(result->exeName) - strlen(".-wrapped")),
-            result->exeName + 1);
+        ffStrbufSubstrBefore(&result->processName, result->processName.length - (uint32_t) strlen("-wrapped"));
+        ffStrbufSubstrAfter(&result->processName, 0);
     }
 
     if(ffStrbufEqualS(&result->processName, "wezterm-gui"))

src/detection/terminalshell/terminalshell_windows.c

@@ -104,6 +104,7 @@ static uint32_t getShellInfo(FFShellResult* result, uint32_t pid)
             ffStrbufIgnCaseEqualS(&result->prettyName, "python")        || // python on windows generates shim executables
             ffStrbufIgnCaseEqualS(&result->prettyName, "fastfetch")     || // scoop warps the real binaries with a "shim" exe
             ffStrbufIgnCaseEqualS(&result->prettyName, "flashfetch")    ||
+            ffStrbufIgnCaseEqualS(&result->prettyName, "hyfetch")       || // uses fastfetch as backend
             ffStrbufContainIgnCaseS(&result->prettyName, "debug")       ||
             ffStrbufContainIgnCaseS(&result->prettyName, "time")        ||
             ffStrbufStartsWithIgnCaseS(&result->prettyName, "ConEmu") // https://github.com/fastfetch-cli/fastfetch/issues/488#issuecomment-1619982014

src/detection/wifi/wifi_linux.c

@@ -337,7 +337,8 @@ static const char* detectWifiWithIoctls(FFlist* result)
 const char* ffDetectWifi(FFlist* result)
 {
     #ifdef FF_HAVE_LIBNM
-    if(!detectWifiWithLibnm(result))
+    detectWifiWithLibnm(result);
+    if(result->length) // NetworkManager not enabled? #811
         return NULL;
     #endif
 

src/fastfetch.c

@@ -321,21 +321,42 @@ static void parseOption(FFdata* data, const char* key, const char* value);
 
 static bool parseJsoncFile(const char* path)
 {
-    yyjson_read_err error;
-    yyjson_doc* doc = yyjson_read_file(path, YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS | YYJSON_READ_ALLOW_INF_AND_NAN, NULL, &error);
-    if (!doc)
+    assert(!instance.state.configDoc);
+
     {
-        if (error.code != YYJSON_READ_ERROR_FILE_OPEN)
+        yyjson_read_err error;
+        instance.state.configDoc = yyjson_read_file(path, YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS | YYJSON_READ_ALLOW_INF_AND_NAN, NULL, &error);
+        if (!instance.state.configDoc)
         {
-            fprintf(stderr, "Error: failed to parse JSON config file `%s` at pos %zu: %s\n", path, error.pos, error.msg);
+            if (error.code != YYJSON_READ_ERROR_FILE_OPEN)
+            {
+                fprintf(stderr, "Error: failed to parse JSON config file `%s` at pos %zu: %s\n", path, error.pos, error.msg);
+                exit(477);
+            }
+            return false;
+        }
+    }
+
+    {
+        const char* error = NULL;
+
+        yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
+        if (!yyjson_is_obj(root))
+            error = "Invalid JSON config format. Root value must be an object";
+
+        if (
+            error ||
+            (error = ffOptionsParseLogoJsonConfig(&instance.config.logo, root)) ||
+            (error = ffOptionsParseGeneralJsonConfig(&instance.config.general, root)) ||
+            (error = ffOptionsParseDisplayJsonConfig(&instance.config.display, root)) ||
+            (error = ffOptionsParseLibraryJsonConfig(&instance.config.library, root)) ||
+            false
+        ) {
+            fprintf(stderr, "JsonConfig Error: %s\n", error);
             exit(477);
         }
-        return false;
     }
-    if (instance.state.configDoc)
-        yyjson_doc_free(instance.state.configDoc); // for `--load-config`
 
-    instance.state.configDoc = doc;
     return true;
 }
 
@@ -779,27 +800,6 @@ static void parseArguments(FFdata* data, int argc, char** argv, void (*parser)(F
 
 static void run(FFdata* data)
 {
-    if (instance.state.configDoc)
-    {
-        const char* error = NULL;
-
-        yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
-        if (!yyjson_is_obj(root))
-            error = "Invalid JSON config format. Root value must be an object";
-
-        if (
-            error ||
-            (error = ffOptionsParseLogoJsonConfig(&instance.config.logo, root)) ||
-            (error = ffOptionsParseGeneralJsonConfig(&instance.config.general, root)) ||
-            (error = ffOptionsParseDisplayJsonConfig(&instance.config.display, root)) ||
-            (error = ffOptionsParseLibraryJsonConfig(&instance.config.library, root)) ||
-            false
-        ) {
-            fprintf(stderr, "JsonConfig Error: %s\n", error);
-            exit(477);
-        }
-    }
-
     const bool useJsonConfig = data->structure.length == 0 && instance.state.configDoc;
 
     if (useJsonConfig)

src/logo/builtin.c

@@ -3791,14 +3791,14 @@ static const FFlogo S[] = {
             FF_COLOR_FG_WHITE,
         },
     },
-    // SourceMage
+    // Source Mage
     {
-        .names = {"Source Mage", "source_mage"},
+        .names = {"Source Mage", "Source Mage GNU/Linux", "source_mage", "sourcemage"},
         .lines = FASTFETCH_DATATEXT_LOGO_SOURCE_MAGE,
         .colors = {
             FF_COLOR_FG_WHITE,
         },
-        .colorKeys = FF_COLOR_FG_BLUE,
+        .colorKeys = FF_COLOR_FG_RED,
         .colorTitle = FF_COLOR_FG_WHITE,
     },
     // Solaris

src/modules/custom/custom.c

@@ -6,12 +6,6 @@
 
 void ffPrintCustom(FFCustomOptions* options)
 {
-    if (options->moduleArgs.outputFormat.length == 0)
-    {
-        ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "output format must be set for custom module");
-        return;
-    }
-
     ffPrintLogoAndKey(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
     ffStrbufWriteTo(&options->moduleArgs.outputFormat, stdout);
     puts(FASTFETCH_TEXT_MODIFIER_RESET);

src/modules/disk/disk.c

@@ -131,54 +131,6 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk)
     }
 }
 
-static void printMountpoint(FFDiskOptions* options, const FFlist* disks, const char* mountpoint)
-{
-    FF_LIST_FOR_EACH(FFDisk, disk, *disks)
-    {
-        if(ffStrbufEqualS(&disk->mountpoint, mountpoint))
-        {
-            printDisk(options, disk);
-            return;
-        }
-    }
-
-    ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No disk found for mountpoint: %s", mountpoint);
-}
-
-static void printMountpoints(FFDiskOptions* options, const FFlist* disks)
-{
-    #ifdef _WIN32
-    const char separator = ';';
-    #else
-    const char separator = ':';
-    #endif
-
-    FF_STRBUF_AUTO_DESTROY mountpoints = ffStrbufCreateCopy(&options->folders);
-    ffStrbufTrim(&mountpoints, separator);
-
-    uint32_t startIndex = 0;
-    while(startIndex < mountpoints.length)
-    {
-        uint32_t colonIndex = ffStrbufNextIndexC(&mountpoints, startIndex, separator);
-        mountpoints.chars[colonIndex] = '\0';
-
-        printMountpoint(options, disks, mountpoints.chars + startIndex);
-
-        startIndex = colonIndex + 1;
-    }
-}
-
-static void printAutodetected(FFDiskOptions* options, const FFlist* disks)
-{
-    FF_LIST_FOR_EACH(FFDisk, disk, *disks)
-    {
-        if(disk->type & ~options->showTypes)
-            continue;
-
-        printDisk(options, disk);
-    }
-}
-
 void ffPrintDisk(FFDiskOptions* options)
 {
     FF_LIST_AUTO_DESTROY disks = ffListCreate(sizeof (FFDisk));
@@ -190,10 +142,13 @@ void ffPrintDisk(FFDiskOptions* options)
     }
     else
     {
-        if(options->folders.length == 0)
-            printAutodetected(options, &disks);
-        else
-            printMountpoints(options, &disks);
+        FF_LIST_FOR_EACH(FFDisk, disk, disks)
+        {
+            if(__builtin_expect(options->folders.length == 0, 1) && (disk->type & ~options->showTypes))
+                continue;
+
+            printDisk(options, disk);
+        }
     }
 
     FF_LIST_FOR_EACH(FFDisk, disk, disks)

src/modules/packages/option.h

@@ -27,6 +27,7 @@ typedef enum FFPackagesFlags
     FF_PACKAGES_FLAG_WINGET_BIT = 1 << 17,
     FF_PACKAGES_FLAG_XBPS_BIT = 1 << 18,
     FF_PACKAGES_FLAG_AM_BIT = 1 << 19,
+    FF_PACKAGES_FLAG_SORCERY_BIT = 1 << 20,
 } FFPackagesFlags;
 
 typedef struct FFPackagesOptions

src/modules/packages/packages.c

@@ -4,7 +4,7 @@
 #include "modules/packages/packages.h"
 #include "util/stringUtils.h"
 
-#define FF_PACKAGES_NUM_FORMAT_ARGS 26
+#define FF_PACKAGES_NUM_FORMAT_ARGS 30
 
 void ffPrintPackages(FFPackagesOptions* options)
 {
@@ -65,11 +65,15 @@ void ffPrintPackages(FFPackagesOptions* options)
         FF_PRINT_PACKAGE(winget)
         FF_PRINT_PACKAGE(opkg)
         FF_PRINT_PACKAGE(am)
+        FF_PRINT_PACKAGE(sorcery)
 
         putchar('\n');
     }
     else
     {
+        uint32_t nixAll = counts.nixDefault + counts.nixSystem + counts.nixUser;
+        uint32_t flatpakAll = counts.flatpakSystem + counts.flatpakUser;
+        uint32_t brewAll = counts.brew + counts.brewCask;
         FF_PRINT_FORMAT_CHECKED(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_PACKAGES_NUM_FORMAT_ARGS, ((FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_UINT, &counts.all},
             {FF_FORMAT_ARG_TYPE_UINT, &counts.pacman},
@@ -97,6 +101,10 @@ void ffPrintPackages(FFPackagesOptions* options)
             {FF_FORMAT_ARG_TYPE_UINT, &counts.winget},
             {FF_FORMAT_ARG_TYPE_UINT, &counts.opkg},
             {FF_FORMAT_ARG_TYPE_UINT, &counts.am},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.sorcery},
+            {FF_FORMAT_ARG_TYPE_UINT, &nixAll},
+            {FF_FORMAT_ARG_TYPE_UINT, &flatpakAll},
+            {FF_FORMAT_ARG_TYPE_UINT, &brewAll},
         }));
     }
 
@@ -166,6 +174,7 @@ bool ffParsePackagesCommandOptions(FFPackagesOptions* options, const char* key,
                 case 'S': if (false);
                     FF_TEST_PACKAGE_NAME(SCOOP)
                     FF_TEST_PACKAGE_NAME(SNAP)
+                    FF_TEST_PACKAGE_NAME(SORCERY)
                     break;
                 case 'W': if (false);
                     FF_TEST_PACKAGE_NAME(WINGET)
@@ -266,6 +275,7 @@ void ffParsePackagesJsonObject(FFPackagesOptions* options, yyjson_val* module)
                         case 'S': if (false);
                             FF_TEST_PACKAGE_NAME(SCOOP)
                             FF_TEST_PACKAGE_NAME(SNAP)
+                            FF_TEST_PACKAGE_NAME(SORCERY)
                             break;
                         case 'W': if (false);
                             FF_TEST_PACKAGE_NAME(WINGET)
@@ -316,6 +326,7 @@ void ffGeneratePackagesJsonConfig(FFPackagesOptions* options, yyjson_mut_doc* do
         FF_TEST_PACKAGE_NAME(WINGET)
         FF_TEST_PACKAGE_NAME(XBPS)
         FF_TEST_PACKAGE_NAME(AM)
+        FF_TEST_PACKAGE_NAME(SORCERY)
         #undef FF_TEST_PACKAGE_NAME
     }
 }
@@ -362,12 +373,13 @@ void ffGeneratePackagesJsonResult(FF_MAYBE_UNUSED FFPackagesOptions* options, yy
     FF_APPEND_PACKAGE_COUNT(xbps)
     FF_APPEND_PACKAGE_COUNT(opkg)
     FF_APPEND_PACKAGE_COUNT(am)
+    FF_APPEND_PACKAGE_COUNT(sorcery)
     yyjson_mut_obj_add_strbuf(doc, obj, "pacmanBranch", &counts.pacmanBranch);
 }
 
 void ffPrintPackagesHelpFormat(void)
 {
-    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_PACKAGES_MODULE_NAME, "{2} (pacman){?3}[{3}]{?}, {4} (dpkg), {5} (rpm), {6} (emerge), {7} (eopkg), {8} (xbps), {9} (nix-system), {10} (nix-user), {11} (nix-default), {12} (apk), {13} (pkg), {14} (flatpak-system), {15} (flatpack-user), {16} (snap), {17} (brew), {18} (brew-cask), {19} (MacPorts), {20} (scoop), {21} (choco), {22} (pkgtool), {23} (paludis), {24} (winget), {25} (opkg)", FF_PACKAGES_NUM_FORMAT_ARGS, ((const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_PACKAGES_MODULE_NAME, "{2} (pacman){?3}[{3}]{?}, {4} (dpkg), {5} (rpm), {6} (emerge), {7} (eopkg), {8} (xbps), {9} (nix-system), {10} (nix-user), {11} (nix-default), {12} (apk), {13} (pkg), {14} (flatpak-system), {15} (flatpack-user), {16} (snap), {17} (brew), {18} (brew-cask), {19} (MacPorts), {20} (scoop), {21} (choco), {22} (pkgtool), {23} (paludis), {24} (winget), {25} (opkg), {26} (am), {27} (sorcery)", FF_PACKAGES_NUM_FORMAT_ARGS, ((const char* []) {
         "Number of all packages",
         "Number of pacman packages",
         "Pacman branch on manjaro",
@@ -394,6 +406,10 @@ void ffPrintPackagesHelpFormat(void)
         "Number of winget packages",
         "Number of opkg packages",
         "Number of am packages",
+        "Number of sorcery packages",
+        "Total number of all nix packages",
+        "Total number of all flatpak packages",
+        "Total number of all brew packages",
     }));
 }
 

src/modules/separator/separator.c

@@ -12,9 +12,20 @@ static inline uint32_t max(uint32_t a, uint32_t b)
 
 static inline uint32_t getWcsWidth(const FFstrbuf* mbstr, wchar_t* wstr, mbstate_t* state)
 {
+    int result = 1;
+    for (uint32_t i = 0; i < mbstr->length; i++)
+    {
+        if (!isascii(mbstr->chars[i]))
+        {
+            result = 0;
+            break;
+        }
+    }
+    if (__builtin_expect(result, 1)) return mbstr->length;
+
     const char* str = mbstr->chars;
     uint32_t wstrLength = (uint32_t) mbsrtowcs(wstr, &str, mbstr->length, state);
-    int result = mk_wcswidth(wstr, wstrLength);
+    result = mk_wcswidth(wstr, wstrLength);
     return result > 0 ? (uint32_t) result : mbstr->length;
 }
 
@@ -32,9 +43,9 @@ void ffPrintSeparator(FFSeparatorOptions* options)
         + (fqdn ? platform->hostName.length : ffStrbufFirstIndexC(&platform->hostName, '.')); // host name
     ffLogoPrintLine();
 
-    if(options->string.length == 0)
+    if(__builtin_expect(options->string.length == 1, 1))
     {
-        ffPrintCharTimes('-', titleLength);
+        ffPrintCharTimes(options->string.chars[0], titleLength);
     }
     else
     {
@@ -131,7 +142,7 @@ void ffInitSeparatorOptions(FFSeparatorOptions* options)
         NULL,
         ffGenerateSeparatorJsonConfig
     );
-    ffStrbufInit(&options->string);
+    ffStrbufInitStatic(&options->string, "-");
 }
 
 void ffDestroySeparatorOptions(FFSeparatorOptions* options)

src/options/display.c

@@ -354,12 +354,11 @@ void ffOptionsInitDisplay(FFOptionsDisplay* options)
 
     #ifdef NDEBUG
     options->disableLinewrap = !options->pipe;
-    options->hideCursor = !options->pipe;
     #else
     options->disableLinewrap = false;
-    options->hideCursor = false;
     #endif
 
+    options->hideCursor = false;
     options->binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
     options->sizeNdigits = 2;
     options->sizeMaxPrefix = UINT8_MAX;