Merge pull request #794 from fastfetch-cli/dev

Release: v2.9.2
2026-09-12 10:22:12 +02:00 · 2024-04-16 10:45:39 +08:00 · 2024-04-16 10:16:31 +08:00 · 2024-04-16 10:16:31 +08:00 · 2024-04-16 09:55:21 +08:00 · 2024-04-16 09:50:24 +08:00
141 changed files with 1771 additions and 972 deletions
@@ -13,6 +13,7 @@ assignees: ''

 * What happened:
 * What should happen:
+* Fastfetch version used: <!-- please use the latest version, if possible -->
 * Did it work in an older version: <!-- if yes, which version -->
 * Where did you get the binary: <!-- Github Release / Github Actions / Installed with a package manager (What package manager) / Built from source yourself -->
 * Does this issue still occurs in [the latest dev build](https://github.com/fastfetch-cli/fastfetch/actions/)?
@@ -41,18 +42,19 @@ Output of `fastfetch --list-features`:
 //paste here
 ```

-## If fastfatch crashed
+## If fastfatch crashed or freezed

 Paste the stacktrace here. You may get it with:

-```
-$ gdb -q -ex 'set confirm off' -ex run -ex 'bt full' -ex quit --args /path/to/fastfetch
+```shell
+# You may need Ctrl+C to stop the process if it freezes
+gdb -q -ex 'set confirm off' -ex run -ex 'bt full' -ex quit --args /path/to/fastfetch
 ```

 If you are able to identify which module crashed, the strace can be helpful too

-```
-$ strace /path/to/fastfetch --multithreading false --structure {MODULE} --pipe
+```shell
+strace /path/to/fastfetch --multithreading false -s {MODULE} --pipe
 ```

 If you cannot do the instructions above, please upload the core dump file:
@@ -7,10 +7,28 @@ assignees: ''

 ---

-<!-- Before requesting a new feature, please try `fastfetch -c all.jsonc` to see if it has been supported -->
+## Before requesting a new feature

-# Current state:
+* A lot of features are not enabled by default. Please try `fastfetch --list-modules` and `fastfetch -c all.jsonc` to see if it has been supported
+* Fastfetch supports `Command` module, which can be used to grab output from a custom shell script. Please check if it fits your needs

-# Wanted state:
+```jsonc
+// ~/.config/fastfetch/fastfetch.jsonc
+{
+    "modules": [
+        {
+            "type": "command",
+            "text": "/path/to/your/script",
+            "key": "Feature Title"
+        }
+    ]
+}
+```

-# Why the change is sensible:
+## Wanted features:
+
+<!-- Your features here -->
+
+## Motivation:
+
+<!-- Your motivation here -->
@@ -7,6 +7,8 @@ assignees: ''

 ---

+Tip: A logo can be displayed by fastfetch without getting into fastfetch's official repo. For highly customized logo for personal use, it's recommended to keep it locally. Please refer to https://github.com/fastfetch-cli/fastfetch/wiki/Migrate-Neofetch-Logo-To-Fastfetch
+
 # OS
 ```
 Paste content of /etc/os-release here. If this file doesn't exist, describe a way to identify the distro.
@@ -245,8 +245,7 @@ jobs:

      - name: install required packages
        run: |
-          brew update
-          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install vulkan-loader vulkan-headers molten-vk imagemagick chafa
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install --overwrite vulkan-loader vulkan-headers molten-vk imagemagick chafa

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v3
@@ -378,7 +377,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-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

      - name: print msys version
        run: uname -a
@@ -440,7 +439,7 @@ jobs:
        with:
          msystem: CLANG32
          update: true
-          install: git mingw-w64-clang-i686-7zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-opencl-icd
+          install: git mingw-w64-clang-i686-7zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-vulkan-headers mingw-w64-clang-i686-opencl-icd

      - name: print msys version
        run: uname -a
@@ -1,9 +1,9 @@
-**/build/
-**/.vscode/
-**/.cache/
-**/.kdev4/
-**/.DS_Store
-/.vs
+build/
+.vs/
+.vscode/
+.cache/
+.kdev4/
+.DS_Store
 cscope.*
 tags
 fastfetch.kdev4
@@ -1,3 +1,92 @@
+# 2.9.2
+
+Changes:
+* To make use of the newly introduced `yyjson` flag `YYJSON_WRITE_NEWLINE_AT_END`, fastfetch now requires `yyjson` 0.9.0 or later
+
+Features:
+* Always add a final new-line when generating JSON output
+* Detect partition create time, which can be used as OS installation time (Disk)
+* Print time string when generating JSON result instead of UNIX epoch time number, which is more human-readable
+
+Bugfixes:
+* Fix a memory leak
+* Better portable mode detection of Windows Terminal (TerminalFont, Windows)
+* Fix parsing of option `--packages-disabled` (Packages)
+* Don't use command `time` as a shell (Shell)
+
+Logos:
+* Add openSUSE MicroOS
+* Fix color of AOSC OS
+
+# 2.9.1
+
+Features:
+* Support weston-terminal (missed commit in v2.9.0) (TerminalFont, Linux)
+* Support hyprcursor detection (#776, Cursor, Linux)
+
+Bugfixes:
+* Fix `fastfetch --gen-config` raises SIGSEGV when `~/.config/fastfetch` doesn't exist. Regression of `2.9.0` (#778)
+
+# 2.9.0
+
+Features:
+* Support Lxterminal version detection (Terminal, Linux)
+* Support weston-terminal version detection (Terminal, Linux)
+* Support `am` package manager detection (#771, Packages, Linux)
+* Support network prefix length detection for IPv6 (LocalIP)
+* Display all IPs when multiple IPs are assigned to the same interface (LocalIP)
+* Add option `--localip-show-prefix-len` to show network prefix length for both IPv4 and IPv6. Defaults to `true` (LocalIP)
+
+Bugfixes:
+* Fix network prefix length detection when the value is greater than 24 (#773, LocalIP, Linux)
+* For xfce4-terminal, use system mono font if no config file is found (TerminalFont, Linux)
+
+# 2.8.10
+
+Bugfixes:
+* Don't display 0.00 GHz (CPU, FreeBSD)
+* Don't detect manufactor of Qualcomm as ARM (CPU, Android)
+* Ignore `chezmoi` (Terminal, Linux)
+* Trim trailing possible whitespaces (PublicIP)
+* Fix detection compatibility for KDE 6 (Font, Linux)
+* Always use Metal API to detect vmem size (GPU, macOS)
+
+Features:
+* Improve stability; print more useful error message; avoid misuse (PublicIP / Weather)
+* Use MS-DOS device name as mountFrom result, instead of useless GUID volume name (Windows, Disk)
+* Some adjustments to Terminal detection (Terminal, Windows)
+    * Don't pretty print CMD
+    * Print conhost as Windows Console
+    * Don't detect `wininit` as Terminal
+
+Logo:
+* Fix color of Arco Linux
+
+# 2.8.9
+
+Bugfixes:
+* Don't detect `SessionLeader` as terminal, actually (Terminal, Linux)
+* Fix blurry chafa result when specifying both width and height (#757, Logo)
+
+Features:
+* Support new MacBook Air (Host, macOS)
+* Distinguish min frequency and base frequency (CPU)
+
+Logo:
+* Fix proxmox
+
+# 2.8.8
+
+Bugfixes:
+* Fix old fish version compatibility (#744)
+* Fix truncated texts in `--help format` (#745)
+* Fix old vulkan-header and libdrm library compatibility (#748, Linux)
+* Fix possible segfaults in `--help *-format` (#749)
+* Fix invalid resolution detection when using libdrm (Linux, Display)
+* Fix segfault when `/sys/devices/system/cpu/cpufreq/` doesn't exist (#750, CPU, Linux)
+* Don't detect `SessionLeader` as terminal (Terminal, Linux)
+* Fix detection of client IP (Users, Linux)
+
 # 2.8.7

 Bugfixes:
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url

 project(fastfetch
-    VERSION 2.8.7
+    VERSION 2.9.2
    LANGUAGES C
    DESCRIPTION "Fast neofetch-like system information tool"
    HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -699,6 +699,9 @@ check_function_exists(wcwidth HAVE_WCWIDTH)
 if(NOT HAVE_WCWIDTH)
    list(APPEND LIBFASTFETCH_SRC src/3rdparty/mk_wcwidch/wcwidth.c)
 endif()
+if(LINUX)
+    check_function_exists(statx HAVE_STATX)
+endif()

 if(ENABLE_SYSTEM_YYJSON)
    find_package(yyjson)
@@ -762,6 +765,10 @@ elseif(APPLE)
    target_compile_definitions(libfastfetch PUBLIC _DARWIN_C_SOURCE)
 endif()

+if(HAVE_STATX)
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_STATX)
+endif()
+
 if(HAVE_WCWIDTH)
    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WCWIDTH)
 endif()
@@ -0,0 +1,133 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
@@ -27,8 +27,10 @@ There are [screenshots on different platforms](https://github.com/fastfetch-cli/

 ### Linux

-* Ubuntu: `ppa:zhangsongcui3371/fastfetch`
-* 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`
+Some distros packaged a 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).
 * Arch Linux: `sudo pacman -S fastfetch`. You can also find fastfetch [on the AUR](https://aur.archlinux.org/packages/fastfetch-git).
 * Fedora: `sudo dnf install fastfetch`
 * Gentoo: `sudo emerge --ask app-misc/fastfetch`
@@ -1,3 +1,21 @@
+fastfetch (2.8.10) jammy; urgency=medium
+
+  * Update to 2.8.10
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 25 Mar 2024 15:01:53 +0800
+
+fastfetch (2.8.9) jammy; urgency=medium
+
+  * Update to 2.8.9
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 15 Mar 2024 10:49:42 +0800
+
+fastfetch (2.8.8) jammy; urgency=medium
+
+  * Update to 2.8.8
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 08 Mar 2024 09:59:41 +0800
+
 fastfetch (2.8.6) jammy; urgency=medium

  * Update to 2.8.6
@@ -1 +1 @@
-fastfetch_2.8.6_source.buildinfo universe/utils optional
+fastfetch_2.8.10_source.buildinfo universe/utils optional
@@ -730,7 +730,6 @@
                    },
                    {
                        "type": "object",
-                        "additionalProperties": false,
                        "description": "Run module with custom configurations",
                        "required": [
                            "type"
@@ -1438,6 +1437,11 @@
                                        "type": "boolean",
                                        "default": false
                                    },
+                                    "showPrefixLen": {
+                                        "description": "Show network prefix length (/N)",
+                                        "type": "boolean",
+                                        "default": true
+                                    },
                                    "compact": {
                                        "description": "Show all IPs in one line",
                                        "type": "boolean",
@@ -1572,9 +1576,35 @@
                                        "description": "List installed package managers and count of installed packages"
                                    },
                                    "disabled": {
-                                        "description": "A colon separated list of package managers to be disabled when detecting",
-                                        "type": "string",
-                                        "default": "winget"
+                                        "description": "List of package managers to be disabled when detecting",
+                                        "type": "array",
+                                        "items": {
+                                            "type": "string",
+                                            "enum": [
+                                                "am",
+                                                "apk",
+                                                "brew",
+                                                "choco",
+                                                "dpkg",
+                                                "emerge",
+                                                "eopkg",
+                                                "flatpak",
+                                                "macports",
+                                                "nix",
+                                                "opkg",
+                                                "pacman",
+                                                "paludis",
+                                                "pkg",
+                                                "pkgtool",
+                                                "rpm",
+                                                "scoop",
+                                                "snap",
+                                                "winget",
+                                                "xbps"
+                                            ],
+                                            "uniqueItems": true
+                                        },
+                                        "default": ["winget"]
                                    },
                                    "key": {
                                        "$ref": "#/$defs/key"
@@ -84,17 +84,17 @@
        },
        {
            "type": "host",
-            "key": " PC",
+            "key": "󰌢 PC",
            "keyColor": "green"
        },
        {
            "type": "cpu",
-            "key": "│ ├",
+            "key": "│ ├󰻠",
            "keyColor": "green"
        },
        {
            "type": "gpu",
-            "key": "│ ├﬙",
+            "key": "│ ├󰍛",
            "keyColor": "green"
        },
        {
@@ -0,0 +1,104 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "none"
+    },
+    "display": {
+        "separator": "->   "
+    },
+    "modules": [
+        {
+            "type": "title",
+            "format": "                                {6}{7}{8}"
+        },
+        "break",
+        {
+            "type": "custom",
+            "format": "┌───────────────────────────── \u001b[1mSystem Information\u001b[0m ─────────────────────────────┐" // `\u001b` is `\033`, or `\e`
+        },
+        "break",
+        {
+            "key": "     OS           ",
+            "keyColor": "red",
+            "type": "os"
+        },
+        {
+            "key": "    󰌢 Machine      ",
+            "keyColor": "green",
+            "type": "host"
+        },
+        {
+            "key": "     Kernel       ",
+            "keyColor": "magenta",
+            "type": "kernel"
+        },
+        {
+            "key": "    󰅐 Uptime       ",
+            "keyColor": "red",
+            "type": "uptime"
+        },
+        {
+            "key": "    󰍹 Resolution   ",
+            "keyColor": "yellow",
+            "type": "display",
+            "compactType": "original-with-refresh-rate"
+        },
+        {
+            "key": "     WM           ",
+            "keyColor": "blue",
+            "type": "wm"
+        },
+        {
+            "key": "     DE           ",
+            "keyColor": "green",
+            "type": "de"
+        },
+        {
+            "key": "     Shell        ",
+            "keyColor": "cyan",
+            "type": "shell"
+        },
+        {
+            "key": "     Terminal     ",
+            "keyColor": "red",
+            "type": "terminal"
+        },
+        {
+            "key": "    󰻠 CPU          ",
+            "keyColor": "yellow",
+            "type": "cpu"
+        },
+        {
+            "key": "    󰍛 GPU          ",
+            "keyColor": "blue",
+            "type": "gpu"
+        },
+        {
+            "key": "    󰑭 Memory       ",
+            "keyColor": "magenta",
+            "type": "memory"
+        },
+        {
+            "key": "    󰩟 Local IP     ",
+            "keyColor": "red",
+            "type": "localip",
+            "compact": true
+        },
+        {
+            "key": "    󰩠 Public IP    ",
+            "keyColor": "cyan",
+            "type": "publicip"
+        },
+        "break",
+        {
+            "type": "custom",
+            "format": "└──────────────────────────────────────────────────────────────────────────────┘" // `\u001b` is `\033`, or `\e`
+        },
+        "break",
+        {
+            "type": "colors",
+            "paddingLeft": 34,
+            "symbol": "circle"
+        }
+    ]
+}
@@ -19,15 +19,15 @@
        },
        {
            "type": "host",
-            "key": "  "
+            "key": "  󰌢"
        },
        {
            "type": "cpu",
-            "key": "  "
+            "key": "  󰻠"
        },
        {
            "type": "gpu",
-            "key": "  ﬙"
+            "key": "  󰍛"
        },
        {
            "type": "disk",
@@ -14,8 +14,7 @@
        },
        {
            "type": "icons",
-            "key": "I",
-            "format": "{5}"
+            "key": "I"
        },
        {
            "type": "font",
@@ -15,17 +15,17 @@
    "modules": [
        {
            "type": "host",
-            "key": "╭─",
+            "key": "╭─󰌢",
            "keyColor": "green"
        },
        {
            "type": "cpu",
-            "key": "├─",
+            "key": "├─󰻠",
            "keyColor": "green"
        },
        {
            "type": "gpu",
-            "key": "├─﬙",
+            "key": "├─󰍛",
            "keyColor": "green"
        },
        {
@@ -77,17 +77,17 @@
        "break",
        {
            "type": "host",
-            "key": " PC",
+            "key": "󰌢 PC",
            "keyColor": "green"
        },
        {
            "type": "cpu",
-            "key": "├",
+            "key": "├󰻠",
            "keyColor": "green"
        },
        {
            "type": "gpu",
-            "key": "├﬙",
+            "key": "├󰍛",
            "keyColor": "green"
        },
        {
@@ -33,7 +33,7 @@
        },
        {
            "type": "memory",
-            "key": ""
+            "key": "󰻠"
        },
        {
            "type": "packages",
@@ -12,7 +12,7 @@
        "uptime",
        {
            "type": "battery",
-            "format": "{/4}{-}{/}{4}%{?5} [{5}]{?}"
+            "format": "{/4}{-}{/}{4}{?5} [{5}]{?}"
        },
        "break",
        "packages",
@@ -1,6 +1,6 @@
 {
    "home": "https://github.com/ibireme/yyjson",
    "license": "MIT ( embed in source )",
-    "version": "0.8.0",
+    "version": "0.9.0",
    "author": "ibireme"
 }
@@ -1407,6 +1407,7 @@ bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc *doc, size_t count) {
 void yyjson_mut_doc_free(yyjson_mut_doc *doc) {
    if (doc) {
        yyjson_alc alc = doc->alc;
+        memset(&doc->alc, 0, sizeof(alc));
        unsafe_yyjson_str_pool_release(&doc->str_pool, &alc);
        unsafe_yyjson_val_pool_release(&doc->val_pool, &alc);
        alc.free(alc.ctx, doc);
@@ -8309,13 +8310,15 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
    bool cpy = (enc_table == enc_table_cpy);
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
+    const usize end_len = 2; /* '\n' and '\0' */
    
    switch (unsafe_yyjson_get_type(val)) {
        case YYJSON_TYPE_RAW:
            str_len = unsafe_yyjson_get_len(val);
            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
            check_str_len(str_len);
-            incr_len(str_len + 1);
+            incr_len(str_len + end_len);
            cur = write_raw(cur, str_ptr, str_len);
            break;
            
@@ -8323,7 +8326,7 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            str_len = unsafe_yyjson_get_len(val);
            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
            check_str_len(str_len);
-            incr_len(str_len * 6 + 4);
+            incr_len(str_len * 6 + 2 + end_len);
            if (likely(cpy) && unsafe_yyjson_get_subtype(val)) {
                cur = write_string_noesc(cur, str_ptr, str_len);
            } else {
@@ -8333,7 +8336,7 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            break;
            
        case YYJSON_TYPE_NUM:
-            incr_len(32);
+            incr_len(32 + end_len);
            cur = write_number(cur, val, flg);
            if (unlikely(!cur)) goto fail_num;
            break;
@@ -8349,13 +8352,13 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            break;
            
        case YYJSON_TYPE_ARR:
-            incr_len(4);
+            incr_len(2 + end_len);
            byte_copy_2(cur, "[]");
            cur += 2;
            break;
            
        case YYJSON_TYPE_OBJ:
-            incr_len(4);
+            incr_len(2 + end_len);
            byte_copy_2(cur, "{}");
            cur += 2;
            break;
@@ -8364,6 +8367,7 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            goto fail_type;
    }
    
+    if (newline) *cur++ = '\n';
    *cur = '\0';
    *dat_len = (usize)(cur - hdr);
    memset(err, 0, sizeof(yyjson_write_err));
@@ -8436,6 +8440,7 @@ static_inline u8 *yyjson_write_minify(const yyjson_val *root,
    bool cpy = (enc_table == enc_table_cpy);
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = root->uni.ofs / sizeof(yyjson_val);
    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
@@ -8542,6 +8547,11 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *(cur - 1) = '\n';
+        cur++;
+    }
    *--cur = '\0';
    *dat_len = (usize)(cur - hdr);
    memset(err, 0, sizeof(yyjson_write_err));
@@ -8615,6 +8625,7 @@ static_inline u8 *yyjson_write_pretty(const yyjson_val *root,
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
    usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = root->uni.ofs / sizeof(yyjson_val);
    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
@@ -8745,6 +8756,10 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *cur++ = '\n';
+    }
    *cur = '\0';
    *dat_len = (usize)(cur - hdr);
    memset(err, 0, sizeof(yyjson_write_err));
@@ -8977,6 +8992,7 @@ static_inline u8 *yyjson_mut_write_minify(const yyjson_mut_val *root,
    bool cpy = (enc_table == enc_table_cpy);
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
@@ -9087,6 +9103,11 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *(cur - 1) = '\n';
+        cur++;
+    }
    *--cur = '\0';
    *dat_len = (usize)(cur - hdr);
    err->code = YYJSON_WRITE_SUCCESS;
@@ -9162,6 +9183,7 @@ static_inline u8 *yyjson_mut_write_pretty(const yyjson_mut_val *root,
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
    usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
@@ -9296,6 +9318,10 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *cur++ = '\n';
+    }
    *cur = '\0';
    *dat_len = (usize)(cur - hdr);
    err->code = YYJSON_WRITE_SUCCESS;
@@ -527,16 +527,16 @@ extern "C" {
 #define YYJSON_VERSION_MAJOR  0

 /** The minor version of yyjson. */
-#define YYJSON_VERSION_MINOR  8
+#define YYJSON_VERSION_MINOR  9

 /** The patch version of yyjson. */
 #define YYJSON_VERSION_PATCH  0

 /** The version of yyjson in hex: `(major << 16) | (minor << 8) | (patch)`. */
-#define YYJSON_VERSION_HEX    0x000800
+#define YYJSON_VERSION_HEX    0x000900

 /** The version string of yyjson. */
-#define YYJSON_VERSION_STRING "0.8.0"
+#define YYJSON_VERSION_STRING "0.9.0"

 /** The version of yyjson in hex, same as `YYJSON_VERSION_HEX`. */
 yyjson_api uint32_t yyjson_version(void);
@@ -738,7 +738,7 @@ typedef uint32_t yyjson_read_flag;
    - Report error if double number is infinity.
    - Report error if string contains invalid UTF-8 character or BOM.
    - Report error on trailing commas, comments, inf and nan literals. */
-static const yyjson_read_flag YYJSON_READ_NOFLAG                = 0 << 0;
+static const yyjson_read_flag YYJSON_READ_NOFLAG                = 0;

 /** Read the input data in-situ.
    This option allows the reader to modify and use input data to store string
@@ -1067,7 +1067,7 @@ typedef uint32_t yyjson_write_flag;
    - Report error on inf or nan number.
    - Report error on invalid UTF-8 string.
    - Do not escape unicode or slash. */
-static const yyjson_write_flag YYJSON_WRITE_NOFLAG                  = 0 << 0;
+static const yyjson_write_flag YYJSON_WRITE_NOFLAG                  = 0;

 /** Write JSON pretty with 4 space indent. */
 static const yyjson_write_flag YYJSON_WRITE_PRETTY                  = 1 << 0;
@@ -1096,6 +1096,10 @@ static const yyjson_write_flag YYJSON_WRITE_ALLOW_INVALID_UNICODE   = 1 << 5;
    This flag will override `YYJSON_WRITE_PRETTY` flag. */
 static const yyjson_write_flag YYJSON_WRITE_PRETTY_TWO_SPACES       = 1 << 6;

+/** Adds a newline character `\n` at the end of the JSON.
+    This can be helpful for text editors or NDJSON. */
+static const yyjson_write_flag YYJSON_WRITE_NEWLINE_AT_END          = 1 << 7;
+


 /** Result code for JSON writer */
@@ -3695,7 +3699,7 @@ yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
    The `len` should be the length of the `val`, in bytes.
    This function allows duplicated key in one object.
    
-    @warning The key/value strings are not copied, you should keep these strings
+    @warning The key strings are not copied, you should keep these strings
        unmodified for the lifetime of this JSON document. */
 yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
                                                  yyjson_mut_val *obj,
@@ -4829,6 +4833,7 @@ yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc) {
 yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc) {
    if (doc) {
        yyjson_alc alc = doc->alc;
+        memset(&doc->alc, 0, sizeof(alc));
        if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
        alc.free(alc.ctx, doc);
    }
@@ -5668,6 +5673,7 @@ yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
    if (yyjson_likely(doc)) {
        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
        if (yyjson_likely(val)) {
+            _val = !!_val;
            val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
            return val;
        }
@@ -5920,7 +5926,8 @@ yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc) {
 yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
    yyjson_mut_doc *doc, const bool *vals, size_t count) {
    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)vals[i] << 3);
+        bool _val = !!vals[i];
+        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
    });
 }

@@ -6872,6 +6879,7 @@ yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
                                               const char *_key,
                                               bool _val) {
    yyjson_mut_obj_add_func({
+        _val = !!_val;
        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3);
    });
 }
@@ -7730,33 +7738,39 @@ yyjson_api_inline bool yyjson_ptr_get_bool(
 }

 /**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type uint.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is an integer
+ that fits in `uint64_t`. Returns true if successful, otherwise false.
 */
 yyjson_api_inline bool yyjson_ptr_get_uint(
    yyjson_val *root, const char *ptr, uint64_t *value) {
    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_uint(val)) {
-        *value = unsafe_yyjson_get_uint(val);
-        return true;
-    } else {
-        return false;
+    if (value && val) {
+        uint64_t ret = val->uni.u64;
+        if (unsafe_yyjson_is_uint(val) ||
+            (unsafe_yyjson_is_sint(val) && !(ret >> 63))) {
+            *value = ret;
+            return true;
+        }
    }
+    return false;
 }

 /**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type sint.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is an integer
+ that fits in `int64_t`. Returns true if successful, otherwise false.
 */
 yyjson_api_inline bool yyjson_ptr_get_sint(
    yyjson_val *root, const char *ptr, int64_t *value) {
    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_sint(val)) {
-        *value = unsafe_yyjson_get_sint(val);
-        return true;
-    } else {
-        return false;
+    if (value && val) {
+        int64_t ret = val->uni.i64;
+        if (unsafe_yyjson_is_sint(val) ||
+            (unsafe_yyjson_is_uint(val) && ret >= 0)) {
+            *value = ret;
+            return true;
+        }
    }
+    return false;
 }

 /**
@@ -118,7 +118,7 @@ static void parseStructureCommand(
        }
    }

-    ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
+    ffPrintError(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
 }

 void ffPrintCommandOption(FFdata* data, yyjson_mut_doc* jsonDoc)
@@ -2,6 +2,7 @@
 #include "common/font.h"

 #include <string.h>
+#include <ctype.h>

 void ffFontInit(FFfont* font)
 {
@@ -66,59 +67,33 @@ void ffFontInitQt(FFfont* font, const char* data)
    //See https://doc.qt.io/qt-5/qfont.html#toString

    //Family
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->name, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
+    data = ffStrbufAppendSUntilC(&font->name, data, ',');
    ffStrbufTrim(&font->name, ' ');
+    if (!data) goto exit;
+    data++;

    //Size
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->size, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
+    data = ffStrbufAppendSUntilC(&font->size, data, ',');
    ffStrbufTrim(&font->size, ' ');
+    if (!data) goto exit;
+    data++;

-    #define FF_FONT_QT_SKIP_VALUE \
-        while(*data != ',' && *data != '\0') \
-            ++data; \
-        if(*data != '\0') \
-             ++data;
-
-    FF_FONT_QT_SKIP_VALUE //Pixel size
-    FF_FONT_QT_SKIP_VALUE //Style hint
-    FF_FONT_QT_SKIP_VALUE //Font weight
-    FF_FONT_QT_SKIP_VALUE //Font style
-    FF_FONT_QT_SKIP_VALUE //Underline
-    FF_FONT_QT_SKIP_VALUE //Strike out
-    FF_FONT_QT_SKIP_VALUE //Fixed pitch
-    FF_FONT_QT_SKIP_VALUE //Always 0
-
-    #undef FF_FONT_QT_SKIP_VALUE
-
-    while(*data != '\0')
+    //Style
+    data = strrchr(data, ',');
+    if (!data) goto exit;
+    data++;
+    if (isalpha(*data))
    {
-        while(*data == ' ')
-            ++data;
-
-        if(*data == '\0')
-            break;
-
-        FFstrbuf* style = ffListAdd(&font->styles);
-        ffStrbufInit(style);
-        while(*data != ' ' && *data != '\0')
+        do
        {
-            ffStrbufAppendC(style, *data);
-            ++data;
-        }
+            FFstrbuf* style = ffListAdd(&font->styles);
+            ffStrbufInit(style);
+            data = ffStrbufAppendSUntilC(style, data, ' ');
+            if (data) data++;
+        } while (data);
    }

+exit:
    fontInitPretty(font);
 }

@@ -24,3 +24,7 @@ typedef struct FFformatarg

 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
 void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments);
+#define FF_PARSE_FORMAT_STRING_CHECKED(buffer, formatstr, numArgs, arguments) do {\
+    static_assert(sizeof(arguments) / sizeof(*(arguments)) == (numArgs), "Invalid number of format arguments");\
+    ffParseFormatString((buffer), (formatstr), (numArgs), (arguments));\
+} while (0)
@@ -235,6 +235,6 @@ void ffPrintJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
            yyjson_mut_doc_set_root(jsonDoc, obj);
        }
        else
-            ffPrintErrorString("JsonConfig", 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "%s", error);
+            ffPrintError("JsonConfig", 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "%s", error);
    }
 }
@@ -20,15 +20,9 @@ typedef struct FFNetworkingState {
            FFThreadType thread;
        #endif
    #endif
+
+    uint32_t timeout;
 } FFNetworkingState;

-bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers);
-bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout);
-
-static inline bool ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, const char* headers, FFstrbuf* buffer)
-{
-    FFNetworkingState state;
-    if(ffNetworkingSendHttpRequest(&state, host, path, headers))
-        return ffNetworkingRecvHttpResponse(&state, buffer, timeout);
-    return false;
-}
+const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers);
+const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer);
@@ -5,30 +5,50 @@
 #include <sys/time.h>
 #include <sys/socket.h>
 #include <netdb.h>
+#include <netinet/in.h> // For FreeBSD
+#include <netinet/tcp.h>

-static void connectAndSend(FFNetworkingState* state)
+static const char* connectAndSend(FFNetworkingState* state)
 {
-    struct addrinfo hints = {
-        .ai_family = AF_INET,
-        .ai_socktype = SOCK_STREAM,
-    };
-
+    const char* ret = NULL;
    struct addrinfo* addr;

-    if(getaddrinfo(state->host.chars, "80", &hints, &addr) != 0)
+    if(getaddrinfo(state->host.chars, "80", &(struct addrinfo) {
+        .ai_family = AF_INET,
+        .ai_socktype = SOCK_STREAM,
+    }, &addr) != 0)
+    {
+        ret = "getaddrinfo() failed";
        goto error;
+    }

    state->sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
    if(state->sockfd == -1)
    {
        freeaddrinfo(addr);
+        ret = "socket() failed";
        goto error;
    }

+    if (state->timeout > 0)
+    {
+        FF_MAYBE_UNUSED uint32_t sec = state->timeout / 1000;
+        if (sec == 0) sec = 1;
+
+        #ifdef TCP_CONNECTIONTIMEOUT
+        setsockopt(state->sockfd, IPPROTO_TCP, TCP_CONNECTIONTIMEOUT, &sec, sizeof(sec));
+        #elif defined(TCP_KEEPINIT)
+        setsockopt(state->sockfd, IPPROTO_TCP, TCP_KEEPINIT, &sec, sizeof(sec));
+        #elif defined(TCP_USER_TIMEOUT)
+        setsockopt(state->sockfd, IPPROTO_TCP, TCP_USER_TIMEOUT, &state->timeout, sizeof(state->timeout));
+        #endif
+    }
+
    if(connect(state->sockfd, addr->ai_addr, addr->ai_addrlen) == -1)
    {
        close(state->sockfd);
        freeaddrinfo(addr);
+        ret = "connect() failed";
        goto error;
    }

@@ -37,6 +57,7 @@ static void connectAndSend(FFNetworkingState* state)
    if(send(state->sockfd, state->command.chars, state->command.length, 0) < 0)
    {
        close(state->sockfd);
+        ret = "send() failed";
        goto error;
    }

@@ -48,11 +69,13 @@ error:
 exit:
    ffStrbufDestroy(&state->host);
    ffStrbufDestroy(&state->command);
+
+    return ret;
 }

 FF_THREAD_ENTRY_DECL_WRAPPER(connectAndSend, FFNetworkingState*);

-bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
+const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
 {
    ffStrbufInitS(&state->host, host);

@@ -66,22 +89,30 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
    ffStrbufAppendS(&state->command, "\r\n");

    #ifdef FF_HAVE_THREADS
+    if (instance.config.general.multithreading)
+    {
        state->thread = ffThreadCreate(connectAndSendThreadMain, state);
-        return !!state->thread;
-    #else
-        connectAndSend(state);
-        return state->sockfd != -1;
+        return state->thread ? NULL : "ffThreadCreate(connectAndSend) failed";
+    }
    #endif
+
+    return connectAndSend(state);
 }

-bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout)
+const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer)
 {
+    uint32_t timeout = state->timeout;
+
    #ifdef FF_HAVE_THREADS
+    if (instance.config.general.multithreading)
+    {
        if (!ffThreadJoin(state->thread, timeout))
-            return false;
+            return "ffThreadJoin() failed or timeout";
+    }
    #endif
+
    if(state->sockfd == -1)
-        return false;
+        return "ffNetworkingSendHttpRequest() failed";

    if(timeout > 0)
    {
@@ -91,14 +122,15 @@ bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, ui
        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
    }

-    ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);
-
-    if(received > 0)
-    {
+    uint32_t recvStart;
+    do {
+        recvStart = buffer->length;
+        ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);
+        if (received <= 0) break;
        buffer->length += (uint32_t) received;
        buffer->chars[buffer->length] = '\0';
-    }
+    } while (ffStrbufGetFree(buffer) > 0 && strstr(buffer->chars + recvStart, "\r\n\r\n") == NULL);

    close(state->sockfd);
-    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n");
+    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n") ? NULL : "Invalid response";
 }
@@ -33,21 +33,20 @@ static const char* initWsaData(WSADATA* wsaData)
    return NULL;
 }

-bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
+const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
 {
    static WSADATA wsaData;
    if (wsaData.wVersion == 0)
    {
-        if (initWsaData(&wsaData) != NULL)
+        const char* error = initWsaData(&wsaData);
+        if (error != NULL)
        {
            wsaData.wVersion = (WORD) -1;
-            return false;
+            return error;
        }
    }
    else if (wsaData.wVersion == (WORD) -1)
-        return false;
-
-    memset(state, 0, sizeof(*state));
+        return "initWsaData() failed before";

    struct addrinfo* addr;

@@ -55,26 +54,27 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
        .ai_family = AF_INET,
        .ai_socktype = SOCK_STREAM,
    }, &addr) != 0)
-        return false;
+        return "getaddrinfo() failed";

    state->sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
    if(state->sockfd == INVALID_SOCKET)
    {
        freeaddrinfo(addr);
-        return false;
+        return "socket() failed";
    }

    {
        //ConnectEx requires the socket to be initially bound
-        struct sockaddr_in addr = {
+        if(bind(state->sockfd, (SOCKADDR *) &(struct sockaddr_in) {
            .sin_family = AF_INET,
            .sin_addr.s_addr = INADDR_ANY,
            .sin_port = 0,
-        };
-        if(bind(state->sockfd, (SOCKADDR *)&addr, sizeof(addr)) != 0)
+        }, sizeof(struct sockaddr_in)) != 0)
        {
-            printf("bind %d\n", WSAGetLastError());
-            return false;
+            closesocket(state->sockfd);
+            freeaddrinfo(addr);
+            state->sockfd = INVALID_SOCKET;
+            return "bind() failed";
        }
    }

@@ -93,35 +93,52 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
    if(!result && WSAGetLastError() != WSA_IO_PENDING)
    {
        closesocket(state->sockfd);
-        return false;
+        freeaddrinfo(addr);
+        state->sockfd = INVALID_SOCKET;
+        return "ConnectEx() failed";
    }

-    return true;
+    return NULL;
 }

-bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout)
+const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer)
 {
+    if (state->sockfd == INVALID_SOCKET)
+        return "ffNetworkingSendHttpRequest() failed";
+
+    uint32_t timeout = state->timeout;
+    if (timeout > 0)
+    {
+        if (WaitForSingleObject((HANDLE) state->sockfd, timeout) != WAIT_OBJECT_0)
+        {
+            CancelIo((HANDLE) state->sockfd);
+            closesocket(state->sockfd);
+            return "WaitForSingleObject(state->sockfd) failed or timeout";
+        }
+    }
+
    DWORD transfer, flags;
    if (!WSAGetOverlappedResult(state->sockfd, &state->overlapped, &transfer, TRUE, &flags))
    {
        closesocket(state->sockfd);
-        return false;
+        return "WSAGetOverlappedResult() failed";
    }

    if(timeout > 0)
    {
        //https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-setsockopt
-        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
+        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*) &timeout, sizeof(timeout));
    }

-    ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, (int)ffStrbufGetFree(buffer), 0);
-
-    if(received > 0)
-    {
-        buffer->length += (uint32_t) received;
+    uint32_t recvStart;
+    do {
+        recvStart = buffer->length;
+        ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, (int) ffStrbufGetFree(buffer), 0);
+        if (received <= 0) break;
+        buffer->length = recvStart + (uint32_t) received;
        buffer->chars[buffer->length] = '\0';
-    }
+    } while (ffStrbufGetFree(buffer) > 0 && strstr(buffer->chars + recvStart, "\r\n\r\n") == NULL);

    closesocket(state->sockfd);
-    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n");
+    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n") ? NULL : "Invalid response";
 }
@@ -100,19 +100,19 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
 {
    if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)
    {
-        if((ffStrbufIgnCaseComp(gtk2, gtk3) == 0) && (ffStrbufIgnCaseComp(gtk2, gtk4) == 0))
+        if((ffStrbufIgnCaseEqual(gtk2, gtk3)) && (ffStrbufIgnCaseEqual(gtk2, gtk4)))
        {
            ffStrbufAppend(buffer, gtk4);
            ffStrbufAppendS(buffer, " [GTK2/3/4]");
        }
-        else if(ffStrbufIgnCaseComp(gtk2, gtk3) == 0)
+        else if(ffStrbufIgnCaseEqual(gtk2, gtk3))
        {
            ffStrbufAppend(buffer, gtk3);
            ffStrbufAppendS(buffer, " [GTK2/3], ");
            ffStrbufAppend(buffer, gtk4);
            ffStrbufAppendS(buffer, " [GTK4]");
        }
-        else if(ffStrbufIgnCaseComp(gtk3, gtk4) == 0)
+        else if(ffStrbufIgnCaseEqual(gtk3, gtk4))
        {
            ffStrbufAppend(buffer, gtk2);
            ffStrbufAppendS(buffer, " [GTK2], ");
@@ -131,7 +131,7 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
    }
    else if(gtk2->length > 0 && gtk3->length > 0)
    {
-        if(ffStrbufIgnCaseComp(gtk2, gtk3) == 0)
+        if(ffStrbufIgnCaseEqual(gtk2, gtk3))
        {
            ffStrbufAppend(buffer, gtk3);
            ffStrbufAppendS(buffer, " [GTK2/3]");
@@ -146,7 +146,7 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
    }
    else if(gtk3->length > 0 && gtk4->length > 0)
    {
-        if(ffStrbufIgnCaseComp(gtk3, gtk4) == 0)
+        if(ffStrbufIgnCaseEqual(gtk3, gtk4))
        {
            ffStrbufAppend(buffer, gtk4);
            ffStrbufAppendS(buffer, " [GTK3/4]");
@@ -37,9 +37,9 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModu
    else
    {
        FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate();
-        ffParseFormatString(&key, &moduleArgs->key, 1, (FFformatarg[]){
+        FF_PARSE_FORMAT_STRING_CHECKED(&key, &moduleArgs->key, 1, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
-        });
+        }));
        ffStrbufWriteTo(&key, stdout);
    }

@@ -60,7 +60,7 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModu
    }
 }

-void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments)
 {
    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
    if (moduleArgs)
@@ -93,7 +93,7 @@ static void printError(const char* moduleName, uint8_t moduleIndex, const FFModu
    putchar('\n');
 }

-void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...)
+void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...)
 {
    va_list arguments;
    va_start(arguments, message);
@@ -101,14 +101,6 @@ void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFMod
    va_end(arguments);
 }

-void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
-{
-    va_list arguments;
-    va_start(arguments, message);
-    printError(moduleName, moduleIndex, moduleArgs, FF_PRINT_TYPE_DEFAULT, message, arguments);
-    va_end(arguments);
-}
-
 void ffPrintColor(const FFstrbuf* colorValue)
 {
    //If the color is not set, this would reset in \033[m, which resets everything.
@@ -12,14 +12,17 @@ typedef enum FFPrintType {
 } FFPrintType;

 void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType);
-void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments);
-static inline void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
-{
-    ffPrintFormatString(moduleName, moduleIndex, moduleArgs, FF_PRINT_TYPE_DEFAULT, numArgs, arguments);
-}
-FF_C_PRINTF(5, 6) void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...);
-FF_C_PRINTF(4, 5) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments);
+#define FF_PRINT_FORMAT_CHECKED(moduleName, moduleIndex, moduleArgs, printType, numArgs, arguments) do {\
+    static_assert(sizeof(arguments) / sizeof(*(arguments)) == (numArgs), "Invalid number of format arguments");\
+    ffPrintFormat((moduleName), (moduleIndex), (moduleArgs), (printType), (numArgs), (arguments));\
+} while (0)
+FF_C_PRINTF(5, 6) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...);
 void ffPrintColor(const FFstrbuf* colorValue);
 void ffPrintCharTimes(char c, uint32_t times);

 void ffPrintModuleFormatHelp(const char* name, const char* def, uint32_t numArgs, const char* args[]);
+#define FF_PRINT_MODULE_FORMAT_HELP_CHECKED(moduleName, def, numArgs, args) do {\
+    static_assert(sizeof(args) / sizeof(*(args)) == (numArgs), "Invalid number of format arguments");\
+    ffPrintModuleFormatHelp((moduleName), (def), (numArgs), (args));\
+} while (0)
@@ -1,12 +1,12 @@
 #pragma once

 #include <stdint.h>
+#include <time.h>
+#include <stdio.h>
 #ifdef _WIN32
    #include <synchapi.h>
    #include <profileapi.h>
    #include <sysinfoapi.h>
-#else
-    #include <time.h>
 #endif

 static inline uint64_t ffTimeGetTick() //In msec
@@ -45,3 +45,37 @@ static inline void ffTimeSleep(uint32_t msec)
        nanosleep(&(struct timespec){ msec / 1000, (long) (msec % 1000) * 1000000 }, NULL);
    #endif
 }
+
+#ifdef _WIN32
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wformat"
+#endif
+
+// Not thread-safe
+static inline const char* ffTimeToFullStr(uint64_t msec)
+{
+    if (msec == 0) return "";
+    time_t tsec = (time_t) (msec / 1000);
+    const struct tm* tm = localtime(&tsec);
+
+    static char buf[32];
+    strftime(buf, __builtin_strlen("0000-00-00T00:00:00") + 1, "%FT%T", tm);
+    snprintf(buf + __builtin_strlen("0000-00-00T00:00:00"), __builtin_strlen(".000") + 1, ".%03u", (unsigned) (msec % 1000));
+    strftime(buf + __builtin_strlen("0000-00-00T00:00:00.000"), __builtin_strlen("+0000") + 1, "%z", tm);
+    return buf;
+}
+
+// Not thread-safe
+static inline const char* ffTimeToShortStr(uint64_t msec)
+{
+    if (msec == 0) return "";
+    time_t tsec = (time_t) (msec / 1000);
+
+    static char buf[32];
+    strftime(buf, sizeof(buf), "%F %T", localtime(&tsec));
+    return buf;
+}
+
+#ifdef _WIN32
+    #pragma GCC diagnostic pop
+#endif
@@ -1261,6 +1261,15 @@
                "default": false
            }
        },
+        {
+            "long": "localip-show-prefix-len",
+            "desc": "Show network prefix length (/N) in local ip module",
+            "arg": {
+                "type": "bool",
+                "optional": true,
+                "default": true
+            }
+        },
        {
            "long": "localip-name-prefix",
            "desc": "Show interfaces with given interface name prefix only",
@@ -13,10 +13,12 @@ typedef struct FFCPUResult
    uint16_t coresLogical;
    uint16_t coresOnline;

-    double frequencyMin; // GHz
+    double frequencyBase; // GHz
    double frequencyMax; // GHz
+    double frequencyMin; // GHz

    double temperature;
 } FFCPUResult;

+const char* ffCPUDetectByCpuid(FFCPUResult* cpu);
 const char* ffDetectCPU(const FFCPUOptions* options, FFCPUResult* cpu);
@@ -60,14 +60,13 @@ static const char* detectFrequency(FFCPUResult* cpu)
        ffCfDictGetData(properties, CFSTR("voltage-states5-sram"), pCoreLength - 8, 4, (uint8_t*) &aMax, NULL);
        cpu->frequencyMax = aMax / (1000.0 * 1000 * 1000);
    }
-    else
-        cpu->frequencyMax = 0.0;

    return NULL;
 }
 #else
 static const char* detectFrequency(FFCPUResult* cpu)
 {
+    cpu->frequencyBase = ffSysctlGetInt64("hw.cpufrequency", 0) / 1000.0 / 1000.0 / 1000.0;
    cpu->frequencyMin = ffSysctlGetInt64("hw.cpufrequency_min", 0) / 1000.0 / 1000.0 / 1000.0;
    cpu->frequencyMax = ffSysctlGetInt64("hw.cpufrequency_max", 0);
    if(cpu->frequencyMax > 0.0)
@@ -11,8 +11,8 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    cpu->coresLogical = cpu->coresPhysical;
    cpu->coresOnline = cpu->coresPhysical;

-    cpu->frequencyMin = ffSysctlGetInt("hw.clockrate", 0) / 1000.0;
-    cpu->frequencyMax = cpu->frequencyMin;
+    int clockRate = ffSysctlGetInt("hw.clockrate", 0);
+    cpu->frequencyBase = clockRate <= 0 ? 0.0/0.0 : clockRate / 1000.0;
    cpu->temperature = FF_CPU_TEMP_UNSET;

    if (options->temp)
@@ -17,7 +17,10 @@
 static void detectAndroid(FFCPUResult* cpu)
 {
    if (cpu->name.length == 0)
+    {
        ffSettingsGetAndroidProperty("ro.soc.model", &cpu->name);
+        ffStrbufClear(&cpu->vendor); // We usually detect the vendor of CPU core as ARM, but instead we want the vendor of SOC
+    }
    if (cpu->vendor.length == 0)
    {
        if (!ffSettingsGetAndroidProperty("ro.soc.manufacturer", &cpu->vendor))
@@ -94,11 +97,14 @@ static double getFrequency(FFstrbuf* basePath, const char* cpuinfoFileName, cons
    if (ok)
        return ffStrbufToDouble(buffer) / 1e6;

-    ffStrbufAppendS(basePath, scalingFileName);
-    ok = ffReadFileBuffer(basePath->chars, buffer);
-    ffStrbufSubstrBefore(basePath, baseLen);
-    if (ok)
-        return ffStrbufToDouble(buffer) / 1e6;
+    if (scalingFileName)
+    {
+        ffStrbufAppendS(basePath, scalingFileName);
+        ok = ffReadFileBuffer(basePath->chars, buffer);
+        ffStrbufSubstrBefore(basePath, baseLen);
+        if (ok)
+            return ffStrbufToDouble(buffer) / 1e6;
+    }

    return 0.0/0.0;
 }
@@ -107,9 +113,10 @@ static bool detectFrequency(FFCPUResult* cpu)
 {
    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateS("/sys/devices/system/cpu/cpufreq/");
    FF_AUTO_CLOSE_DIR DIR* dir = opendir(path.chars);
+    if (!dir) return false;
+
    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
    uint32_t baseLen = path.length;
-    bool flag = false;

    struct dirent* entry;
    while((entry = readdir(dir)) != NULL)
@@ -117,26 +124,34 @@ static bool detectFrequency(FFCPUResult* cpu)
        if (ffStrStartsWith(entry->d_name, "policy") && isdigit(entry->d_name[strlen("policy")]))
        {
            ffStrbufAppendS(&path, entry->d_name);
-            double fmin = getFrequency(&path, "/cpuinfo_min_freq", "/scaling_min_freq", &buffer);
-            if (fmin != fmin) continue;
-            double fmax = getFrequency(&path, "/cpuinfo_max_freq", "/scaling_max_freq", &buffer);
-            if (fmax != fmax) continue;
-
-            if (flag)
+            double fbase = getFrequency(&path, "/base_frequency", NULL, &buffer);
+            if (fbase == fbase)
            {
-                cpu->frequencyMin = cpu->frequencyMin < fmin ? cpu->frequencyMin : fmin;
-                cpu->frequencyMax = cpu->frequencyMax > fmax ? cpu->frequencyMax : fmax;
+                if (cpu->frequencyBase == cpu->frequencyBase)
+                    cpu->frequencyBase = cpu->frequencyBase > fbase ? cpu->frequencyBase : fbase;
+                else
+                    cpu->frequencyBase = fbase;
            }
-            else
+            double fmax = getFrequency(&path, "/cpuinfo_max_freq", "/scaling_max_freq", &buffer);
+            if (fmax == fmax)
            {
-                cpu->frequencyMin = fmin;
-                cpu->frequencyMax = fmax;
-                flag = true;
+                if (cpu->frequencyMax == cpu->frequencyMax)
+                    cpu->frequencyMax = cpu->frequencyMax > fmax ? cpu->frequencyMax : fmax;
+                else
+                    cpu->frequencyMax = fmax;
+            }
+            double fmin = getFrequency(&path, "/cpuinfo_min_freq", "/scaling_min_freq", &buffer);
+            if (fmin == fmin)
+            {
+                if (cpu->frequencyMin == cpu->frequencyMin)
+                    cpu->frequencyMin = cpu->frequencyMin < fmin ? cpu->frequencyMin : fmin;
+                else
+                    cpu->frequencyMin = fmin;
            }
            ffStrbufSubstrBefore(&path, baseLen);
        }
    }
-    return flag;
+    return true;
 }

 static double detectCPUTemp(void)
@@ -232,8 +247,8 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    cpu->coresOnline = (uint16_t) get_nprocs();
    cpu->coresPhysical = (uint16_t) ffStrbufToUInt(&physicalCoresBuffer, cpu->coresLogical);

-    if (!detectFrequency(cpu))
-        cpu->frequencyMin = cpu->frequencyMax = ffStrbufToDouble(&cpuMHz) / 1000;
+    if (!detectFrequency(cpu) || cpu->frequencyBase != cpu->frequencyBase)
+        cpu->frequencyBase = ffStrbufToDouble(&cpuMHz) / 1000;

    if(cpuUarch.length > 0)
    {
@@ -64,50 +64,53 @@ static const char* detectMaxSpeedBySmbios(FFCPUResult* cpu)
            return "No active CPU is found in SMBIOS data";
    }

-    double speed;
    if (data->MaxSpeed > 0 && data->MaxSpeed < 30000) // VMware reports weird values
-        speed = data->MaxSpeed / 1000.0;
-    else
-        speed = data->CurrentSpeed / 1000.0;
+    {
+        double speed = data->MaxSpeed / 1000.0;
+        if (cpu->frequencyBase < speed)
+            cpu->frequencyMax = speed;
+    }

-    if (cpu->frequencyMax < speed)
-        cpu->frequencyMax = speed;

    return NULL;
 }

-static const char* detectByOS(FFCPUResult* cpu)
+static const char* detectNCores(FFCPUResult* cpu)
 {
+    DWORD length = 0;
+    GetLogicalProcessorInformationEx(RelationAll, NULL, &length);
+    if (length == 0)
+        return "GetLogicalProcessorInformationEx(RelationAll, NULL, &length) failed";
+
+    SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* FF_AUTO_FREE
+        pProcessorInfo = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)malloc(length);
+
+    if (!pProcessorInfo || !GetLogicalProcessorInformationEx(RelationAll, pProcessorInfo, &length))
+        return "GetLogicalProcessorInformationEx(RelationAll, pProcessorInfo, &length) failed";
+
+    for(
+        SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* ptr = pProcessorInfo;
+        (uint8_t*)ptr < ((uint8_t*)pProcessorInfo) + length;
+        ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((uint8_t*)ptr) + ptr->Size)
+    )
    {
-        DWORD length = 0;
-        GetLogicalProcessorInformationEx(RelationAll, NULL, &length);
-        if (length == 0)
-            return "GetLogicalProcessorInformationEx(RelationAll, NULL, &length) failed";
-
-        SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* FF_AUTO_FREE
-            pProcessorInfo = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)malloc(length);
-
-        if (pProcessorInfo && GetLogicalProcessorInformationEx(RelationAll, pProcessorInfo, &length))
+        if(ptr->Relationship == RelationProcessorCore)
+            ++cpu->coresPhysical;
+        else if(ptr->Relationship == RelationGroup)
        {
-            for(
-                SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX* ptr = pProcessorInfo;
-                (uint8_t*)ptr < ((uint8_t*)pProcessorInfo) + length;
-                ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((uint8_t*)ptr) + ptr->Size)
-            )
+            for (uint32_t index = 0; index < ptr->Group.ActiveGroupCount; ++index)
            {
-                if(ptr->Relationship == RelationProcessorCore)
-                    ++cpu->coresPhysical;
-                else if(ptr->Relationship == RelationGroup)
-                {
-                    cpu->coresOnline += ptr->Group.GroupInfo->ActiveProcessorCount;
-                    cpu->coresLogical += ptr->Group.GroupInfo->MaximumProcessorCount;
-                }
+                cpu->coresOnline += ptr->Group.GroupInfo[index].ActiveProcessorCount;
+                cpu->coresLogical += ptr->Group.GroupInfo[index].MaximumProcessorCount;
            }
        }
-        else
-            return "GetLogicalProcessorInformationEx(RelationAll, pProcessorInfo, &length) failed";
    }

+    return NULL;
+}
+
+static const char* detectByRegistry(FFCPUResult* cpu)
+{
    FF_HKEY_AUTO_DESTROY hKey = NULL;
    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";
@@ -115,24 +118,34 @@ static const char* detectByOS(FFCPUResult* cpu)
    {
        uint32_t mhz;
        if(ffRegReadUint(hKey, L"~MHz", &mhz, NULL))
-            cpu->frequencyMin = cpu->frequencyMax = mhz / 1000.0;
+            cpu->frequencyBase = mhz / 1000.0;
    }

    ffRegReadStrbuf(hKey, L"ProcessorNameString", &cpu->name, NULL);
    ffRegReadStrbuf(hKey, L"VendorIdentifier", &cpu->vendor, NULL);

+    if (cpu->coresLogical == 0)
+    {
+        DWORD cores;
+        if (RegQueryInfoKeyW(HKEY_LOCAL_MACHINE, L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor", NULL, NULL, &cores, NULL, NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
+            cpu->coresOnline = cpu->coresPhysical = cpu->coresLogical = (uint16_t) cores;
+    }
+
    return NULL;
 }

 const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
-    const char* error = detectByOS(cpu);
+    detectNCores(cpu);
+
+    const char* error = detectByRegistry(cpu);
    if (error)
        return error;

+    detectMaxSpeedBySmbios(cpu);
+
    if(options->temp)
        ffDetectSmbiosTemp(&cpu->temperature, NULL);

-    detectMaxSpeedBySmbios(cpu);
    return NULL;
 }
@@ -68,18 +68,33 @@ static bool detectCursorFromEnv(FFCursorResult* result)
    return true;
 }

+static bool detectCursorHyprcursor(FFCursorResult* result)
+{
+    const char* hyprcursor_theme = getenv("HYPRCURSOR_THEME");
+
+    if(!ffStrSet(hyprcursor_theme))
+        return false;
+
+    ffStrbufAppendS(&result->theme, hyprcursor_theme);
+    ffStrbufAppendS(&result->size, getenv("HYPRCURSOR_SIZE"));
+
+    return true;
+}
+
 void ffDetectCursor(FFCursorResult* result)
 {
    const FFDisplayServerResult* wmde = ffConnectDisplayServer();

-    if(ffStrbufCompS(&wmde->wmPrettyName, FF_WM_PRETTY_WSLG) == 0)
+    if(ffStrbufEqualS(&wmde->wmPrettyName, FF_WM_PRETTY_WSLG))
        ffStrbufAppendS(&result->error, "WSLg uses native windows cursor");
-    else if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
+    else if(ffStrbufIgnCaseEqualS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY))
        ffStrbufAppendS(&result->error, "Cursor isn't supported in TTY");
-    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_PLASMA) == 0)
+    else if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, FF_DE_PRETTY_PLASMA))
        detectCursorFromConfigFile("kcminputrc", "cursorTheme =", "Breeze", "cursorSize =", "24", result);
-    else if(ffStrbufStartsWithIgnCaseS(&wmde->dePrettyName, FF_DE_PRETTY_LXQT))
+    else if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, FF_DE_PRETTY_LXQT))
        detectCursorFromConfigFile("lxqt/session.conf", "cursor_theme =", "Adwaita", "cursor_size =", "24", result);
+    else if(ffStrbufIgnCaseEqualS(&wmde->wmPrettyName, FF_WM_PRETTY_HYPRLAND) && detectCursorHyprcursor(result))
+        return;
    else if(
        !detectCursorGTK(result) &&
        !detectCursorFromEnv(result) &&
@@ -17,6 +17,8 @@ typedef struct FFDisk

    uint32_t filesUsed;
    uint32_t filesTotal;
+
+    uint64_t createTime;
 } FFDisk;

 /**
@@ -3,6 +3,7 @@
 #include "util/stringUtils.h"

 #include <sys/mount.h>
+#include <sys/stat.h>

 #ifdef __FreeBSD__
 #include <libgeom.h>
@@ -130,6 +131,10 @@ const char* ffDetectDisksImpl(FFlist* disks)

        if(fs->f_flags & MNT_RDONLY)
            disk->type |= FF_DISK_VOLUME_TYPE_READONLY_BIT;
+
+        struct stat st;
+        if(stat(fs->f_mntonname, &st) == 0)
+            disk->createTime = (uint64_t)((st.st_birthtimespec.tv_sec * 1000) + (st.st_birthtimespec.tv_nsec / 1000000));
    }

    return NULL;
@@ -6,9 +6,9 @@
 #include <limits.h>
 #include <ctype.h>
 #include <dirent.h>
+#include <mntent.h>
 #include <sys/stat.h>
 #include <sys/statvfs.h>
-#include <mntent.h>
 #include <sys/mount.h>

 #ifdef __USE_LARGEFILE64
@@ -241,6 +241,13 @@ static void detectStats(FFDisk* disk)

    if(fs.f_flag & ST_RDONLY)
        disk->type |= FF_DISK_VOLUME_TYPE_READONLY_BIT;
+
+    disk->createTime = 0;
+    #ifdef FF_HAVE_STATX
+    struct statx stx;
+    if (statx(0, disk->mountpoint.chars, 0, STATX_BTIME, &stx) == 0 && (stx.stx_mask & STATX_BTIME))
+        disk->createTime = (uint64_t)((stx.stx_btime.tv_sec * 1000) + (stx.stx_btime.tv_nsec / 1000000));
+    #endif
 }

 const char* ffDetectDisksImpl(FFlist* disks)
@@ -15,7 +15,7 @@ const char* ffDetectDisksImpl(FFlist* disks)

    for(uint32_t i = 0; i < length; i++)
    {
-        const wchar_t* mountpoint = buf + i;
+        wchar_t* mountpoint = buf + i;

        UINT driveType = GetDriveTypeW(mountpoint);
        if(driveType == DRIVE_NO_ROOT_DIR)
@@ -25,13 +25,6 @@ const char* ffDetectDisksImpl(FFlist* disks)
        }

        FFDisk* disk = ffListAdd(disks);
-        ffStrbufInitWS(&disk->mountpoint, mountpoint);
-
-        wchar_t volumeName[64];
-        if(GetVolumeNameForVolumeMountPointW(mountpoint, volumeName, sizeof(volumeName) / sizeof(*volumeName)))
-            ffStrbufInitWS(&disk->mountFrom, volumeName);
-        else
-            ffStrbufInit(&disk->mountFrom);

        if(!GetDiskFreeSpaceExW(
            mountpoint,
@@ -78,6 +71,23 @@ const char* ffDetectDisksImpl(FFlist* disks)
                disk->type |= FF_DISK_VOLUME_TYPE_READONLY_BIT;
        }

+        WIN32_FILE_ATTRIBUTE_DATA data;
+        if(GetFileAttributesExW(mountpoint, GetFileExInfoStandard, &data) && data.ftCreationTime.dwHighDateTime > 0)
+            disk->createTime = (*(uint64_t*) &data.ftCreationTime - 116444736000000000ull) / 10000ull;
+        else
+            disk->createTime = 0;
+
+        ffStrbufInitWS(&disk->mountpoint, mountpoint);
+        if (mountpoint[2] == L'\\' && mountpoint[3] == L'\0')
+        {
+            wchar_t volumeName[MAX_PATH + 1];
+            mountpoint[2] = L'\0';
+            if(QueryDosDeviceW(mountpoint, volumeName, sizeof(volumeName) / sizeof(*volumeName)))
+                ffStrbufInitWS(&disk->mountFrom, volumeName);
+            else
+                ffStrbufInit(&disk->mountFrom);
+        }
+
        //Unsupported
        disk->filesUsed = 0;
        disk->filesTotal = 0;
@@ -21,6 +21,7 @@
 #define FF_WM_PRETTY_XFWM4 "Xfwm4"
 #define FF_WM_PRETTY_OPENBOX "Openbox"
 #define FF_WM_PRETTY_I3 "i3"
+#define FF_WM_PRETTY_HYPRLAND "Hyprland"
 #define FF_WM_PRETTY_WAYFIRE "Wayfire"
 #define FF_WM_PRETTY_SWAY "Sway"
 #define FF_WM_PRETTY_BSPWM "bspwm"
@@ -143,7 +143,7 @@ static inline const char* drmType2Name(uint32_t connector_type)
        return "DPI";
    case DRM_MODE_CONNECTOR_WRITEBACK:
        return "Writeback";
-    case DRM_MODE_CONNECTOR_SPI:
+    case 19 /*DRM_MODE_CONNECTOR_SPI*/:
        return "SPI";
    case 20 /*DRM_MODE_CONNECTOR_USB*/:
        return "USB";
@@ -250,8 +250,8 @@ static const char* drmConnectLibdrm(FFDisplayServerResult* result)
                    drmModeCrtc* crtc = ffdrmModeGetCrtc(fd, encoder->crtc_id);
                    if (crtc)
                    {
-                        width = crtc->mode.vdisplay;
-                        height = crtc->mode.hdisplay;
+                        width = crtc->mode.hdisplay;
+                        height = crtc->mode.vdisplay;
                        refreshRate = crtc->mode.vrefresh;
                        if (refreshRate == 0)
                        {
@@ -52,6 +52,9 @@ static const char* parseEnv(void)
    if(getenv("TDE_FULL_SESSION") != NULL)
        return "Trinity";

+    if(getenv("HYPRLAND_CMD") != NULL)
+        return "Hyprland";
+
    #ifdef __linux__
    if(
        getenv("WAYLAND_DISPLAY") != NULL &&
@@ -116,6 +119,8 @@ static void applyPrettyNameIfWM(FFDisplayServerResult* result, const char* name)
        ffStrbufSetS(&result->wmPrettyName, FF_WM_PRETTY_ICEWM);
    else if(ffStrEqualsIgnCase(name, "dtwm"))
        ffStrbufSetS(&result->wmPrettyName, FF_WM_PRETTY_DTWM);
+    else if(ffStrEqualsIgnCase(name, "hyprland"))
+        ffStrbufSetS(&result->wmPrettyName, FF_WM_PRETTY_HYPRLAND);
 }

 static void applyNameIfWM(FFDisplayServerResult* result, const char* processName)
@@ -63,10 +63,6 @@ const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
        ffStrbufInit(&gpu->driver); // Ok for both Apple and Intel
        ffCfDictGetString(properties, CFSTR("CFBundleIdentifier"), &gpu->driver);

-        int vram; // Supported on Intel
-        if(!ffCfDictGetInt(properties, CFSTR("VRAM,totalMB"), &vram))
-            gpu->dedicated.total = (uint64_t) vram * 1024 * 1024;
-
        if(ffCfDictGetInt(properties, CFSTR("gpu-core-count"), &gpu->coreCount)) // For Apple
            gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;

@@ -151,9 +151,9 @@ const FFQtResult* ffDetectQt(void)

    const FFDisplayServerResult* wmde = ffConnectDisplayServer();

-    if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_PLASMA) == 0)
+    if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, FF_DE_PRETTY_PLASMA))
        detectPlasma(&result);
-    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_LXQT) == 0)
+    else if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, FF_DE_PRETTY_LXQT))
        detectLXQt(&result);

    return &result;
@@ -111,6 +111,8 @@ static const char* getProductNameWithHwModel(const FFstrbuf* hwModel)
    else if(ffStrbufStartsWithS(hwModel, "Mac"))
    {
        const char* version = hwModel->chars + strlen("Mac");
+        if(ffStrEquals(version, "15,13"))       return "MacBook Air (15-inch, M3, 2024)";
+        if(ffStrEquals(version, "15,2"))        return "MacBook Air (13-inch, M3, 2024)";
        if(ffStrEquals(version, "15,3"))        return "MacBook Pro (14-inch, Nov 2023, Two Thunderbolt / USB 4 ports)";
        if(ffStrEquals(version, "15,4"))        return "iMac (24-inch, 2023, Two Thunderbolt / USB 4 ports)";
        if(ffStrEquals(version, "15,5"))        return "iMac (24-inch, 2023, Two Thunderbolt / USB 4 ports, Two USB 3 ports)";
@@ -7,8 +7,6 @@ typedef struct FFLocalIpResult
    FFstrbuf name;
    FFstrbuf ipv4;
    FFstrbuf ipv6;
-    FFstrbuf gateway4;
-    FFstrbuf gateway6;
    FFstrbuf mac;
    bool defaultRoute;
 } FFLocalIpResult;
@@ -40,10 +40,12 @@ static void addNewIp(FFlist* list, const char* name, const char* addr, int type,
    switch (type)
    {
        case AF_INET:
-            ffStrbufSetS(&ip->ipv4, addr);
+            if (ip->ipv4.length) ffStrbufAppendC(&ip->ipv4, ',');
+            ffStrbufAppendS(&ip->ipv4, addr);
            break;
        case AF_INET6:
-            ffStrbufSetS(&ip->ipv6, addr);
+            if (ip->ipv6.length) ffStrbufAppendC(&ip->ipv6, ',');
+            ffStrbufAppendS(&ip->ipv6, addr);
            break;
        case -1:
            ffStrbufSetS(&ip->mac, addr);
@@ -83,12 +85,15 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
            char addressBuffer[INET_ADDRSTRLEN + 4];
            inet_ntop(AF_INET, &ipv4->sin_addr, addressBuffer, INET_ADDRSTRLEN);

-            struct sockaddr_in* netmask = (struct sockaddr_in*) ifa->ifa_netmask;
-            int cidr = __builtin_popcount(inet_netof(netmask->sin_addr));
-            if (cidr != 0)
+            if (options->showType & FF_LOCALIP_TYPE_PREFIX_LEN_BIT)
            {
-                size_t len = strlen(addressBuffer);
-                snprintf(addressBuffer + len, 4, "/%d", cidr);
+                struct sockaddr_in* netmask = (struct sockaddr_in*) ifa->ifa_netmask;
+                int cidr = __builtin_popcount(netmask->sin_addr.s_addr);
+                if (cidr != 0)
+                {
+                    size_t len = strlen(addressBuffer);
+                    snprintf(addressBuffer + len, 4, "/%d", cidr);
+                }
            }

            addNewIp(results, ifa->ifa_name, addressBuffer, AF_INET, isDefaultRoute);
@@ -99,8 +104,23 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
                continue;

            struct sockaddr_in6* ipv6 = (struct sockaddr_in6 *)ifa->ifa_addr;
-            char addressBuffer[INET6_ADDRSTRLEN];
+            char addressBuffer[INET6_ADDRSTRLEN + 4];
            inet_ntop(AF_INET6, &ipv6->sin6_addr, addressBuffer, INET6_ADDRSTRLEN);
+
+            if (options->showType & FF_LOCALIP_TYPE_PREFIX_LEN_BIT)
+            {
+                struct sockaddr_in6* netmask = (struct sockaddr_in6*) ifa->ifa_netmask;
+                int cidr = 0;
+                static_assert(sizeof(netmask->sin6_addr) % sizeof(uint64_t) == 0, "");
+                for (uint32_t i = 0; i < sizeof(netmask->sin6_addr) / sizeof(uint64_t); ++i)
+                    cidr += __builtin_popcountll(((uint64_t*) &netmask->sin6_addr)[i]);
+                if (cidr != 0)
+                {
+                    size_t len = strlen(addressBuffer);
+                    snprintf(addressBuffer + len, 4, "/%d", cidr);
+                }
+            }
+
            addNewIp(results, ifa->ifa_name, addressBuffer, AF_INET6, isDefaultRoute);
        }
        #if defined(__FreeBSD__) || defined(__APPLE__)
@@ -6,7 +6,7 @@
 #include "util/windows/unicode.h"
 #include "localip.h"

-static void addNewIp(FFlist* list, const char* name, const char* value, int type, bool newIp, bool gateway, bool defaultRoute)
+static void addNewIp(FFlist* list, const char* name, const char* addr, int type, bool newIp, bool defaultRoute)
 {
    FFLocalIpResult* ip = NULL;

@@ -17,8 +17,6 @@ static void addNewIp(FFlist* list, const char* name, const char* value, int type
        ffStrbufInit(&ip->ipv4);
        ffStrbufInit(&ip->ipv6);
        ffStrbufInit(&ip->mac);
-        ffStrbufInit(&ip->gateway4);
-        ffStrbufInit(&ip->gateway6);
        ip->defaultRoute = defaultRoute;
    }
    else
@@ -29,13 +27,15 @@ static void addNewIp(FFlist* list, const char* name, const char* value, int type
    switch (type)
    {
        case AF_INET:
-            ffStrbufSetS(gateway ? &ip->gateway4 : &ip->ipv4, value);
+            if (ip->ipv4.length) ffStrbufAppendC(&ip->ipv4, ',');
+            ffStrbufAppendS(&ip->ipv4, addr);
            break;
        case AF_INET6:
-            ffStrbufSetS(gateway ? &ip->gateway6 : &ip->ipv6, value);
+            if (ip->ipv6.length) ffStrbufAppendC(&ip->ipv6, ',');
+            ffStrbufAppendS(&ip->ipv6, addr);
            break;
        case -1:
-            ffStrbufSetS(&ip->mac, value);
+            ffStrbufSetS(&ip->mac, addr);
            break;
    }
 }
@@ -59,7 +59,7 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
            options->showType & FF_LOCALIP_TYPE_IPV4_BIT
                ? options->showType & FF_LOCALIP_TYPE_IPV6_BIT ? AF_UNSPEC : AF_INET
                : AF_INET6,
-            GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | (options->showType & FF_LOCALIP_TYPE_GATEWAY_BIT ? GAA_FLAG_INCLUDE_GATEWAYS : 0),
+            GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER,
            NULL,
            adapter_addresses,
            &adapter_addresses_buffer_size);
@@ -98,30 +98,10 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
            uint8_t* ptr = adapter->PhysicalAddress;
            snprintf(addressBuffer, sizeof(addressBuffer), "%02x:%02x:%02x:%02x:%02x:%02x",
                        ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
-            addNewIp(results, name, addressBuffer, -1, newIp, false, isDefaultRoute);
+            addNewIp(results, name, addressBuffer, -1, newIp, isDefaultRoute);
            newIp = false;
        }

-        for (IP_ADAPTER_GATEWAY_ADDRESS_LH* ifa = adapter->FirstGatewayAddress; ifa; ifa = ifa->Next)
-        {
-            if (ifa->Address.lpSockaddr->sa_family == AF_INET)
-            {
-                SOCKADDR_IN* ipv4 = (SOCKADDR_IN*) ifa->Address.lpSockaddr;
-                char addressBuffer[INET_ADDRSTRLEN + 4];
-                inet_ntop(AF_INET, &ipv4->sin_addr, addressBuffer, INET_ADDRSTRLEN);
-                addNewIp(results, name, addressBuffer, AF_INET, newIp, true, isDefaultRoute);
-                newIp = false;
-            }
-            else if (ifa->Address.lpSockaddr->sa_family == AF_INET6)
-            {
-                SOCKADDR_IN6* ipv6 = (SOCKADDR_IN6*) ifa->Address.lpSockaddr;
-                char addressBuffer[INET6_ADDRSTRLEN];
-                inet_ntop(AF_INET6, &ipv6->sin6_addr, addressBuffer, INET6_ADDRSTRLEN);
-                addNewIp(results, name, addressBuffer, AF_INET6, newIp, true, isDefaultRoute);
-                newIp = false;
-            }
-        }
-
        for (IP_ADAPTER_UNICAST_ADDRESS* ifa = adapter->FirstUnicastAddress; ifa; ifa = ifa->Next)
        {
            if (ifa->Address.lpSockaddr->sa_family == AF_INET)
@@ -130,21 +110,28 @@ const char* ffDetectLocalIps(const FFLocalIpOptions* options, FFlist* results)
                char addressBuffer[INET_ADDRSTRLEN + 4];
                inet_ntop(AF_INET, &ipv4->sin_addr, addressBuffer, INET_ADDRSTRLEN);

-                if (ifa->OnLinkPrefixLength)
+                if ((options->showType & FF_LOCALIP_TYPE_PREFIX_LEN_BIT) && ifa->OnLinkPrefixLength)
                {
                    size_t len = strlen(addressBuffer);
                    snprintf(addressBuffer + len, 4, "/%u", (unsigned) ifa->OnLinkPrefixLength);
                }

-                addNewIp(results, name, addressBuffer, AF_INET, newIp, false, isDefaultRoute);
+                addNewIp(results, name, addressBuffer, AF_INET, newIp, isDefaultRoute);
                newIp = false;
            }
            else if (ifa->Address.lpSockaddr->sa_family == AF_INET6)
            {
                SOCKADDR_IN6* ipv6 = (SOCKADDR_IN6*) ifa->Address.lpSockaddr;
-                char addressBuffer[INET6_ADDRSTRLEN];
+                char addressBuffer[INET6_ADDRSTRLEN + 4];
                inet_ntop(AF_INET6, &ipv6->sin6_addr, addressBuffer, INET6_ADDRSTRLEN);
-                addNewIp(results, name, addressBuffer, AF_INET6, newIp, false, isDefaultRoute);
+
+                if ((options->showType & FF_LOCALIP_TYPE_PREFIX_LEN_BIT) && ifa->OnLinkPrefixLength)
+                {
+                    size_t len = strlen(addressBuffer);
+                    snprintf(addressBuffer + len, 4, "/%u", (unsigned) ifa->OnLinkPrefixLength);
+                }
+
+                addNewIp(results, name, addressBuffer, AF_INET6, newIp, isDefaultRoute);
                newIp = false;
            }
        }
@@ -4,6 +4,7 @@

 typedef struct FFPackagesResult
 {
+    uint32_t am;
    uint32_t apk;
    uint32_t brew;
    uint32_t brewCask;
@@ -253,6 +253,43 @@ static uint32_t getRpmFromLibrpm(void)

 #endif //FF_HAVE_RPM

+static uint32_t getAM(FFstrbuf* baseDir)
+{
+    // #771
+    uint32_t baseDirLength = baseDir->length;
+
+    ffStrbufAppendS(baseDir, "/opt");
+    uint32_t optDirLength = baseDir->length;
+
+    uint32_t result = 0;
+
+    ffStrbufAppendS(baseDir, "/am/APP-MANAGER");
+    if (ffPathExists(baseDir->chars, FF_PATHTYPE_FILE))
+    {
+        ++result; // `am` itself is counted as a package too
+        ffStrbufSubstrBefore(baseDir, optDirLength);
+        FF_AUTO_CLOSE_DIR DIR* dirp = opendir(baseDir->chars);
+        if(dirp)
+        {
+            struct dirent *entry;
+            while ((entry = readdir(dirp)) != NULL)
+            {
+                if (entry->d_name[0] == '.') continue;
+                if (entry->d_type == DT_DIR)
+                {
+                    ffStrbufAppendF(baseDir, "/%s/AM-updater", entry->d_name);
+                    if (ffPathExists(baseDir->chars, FF_PATHTYPE_FILE))
+                        ++result;
+                    ffStrbufSubstrBefore(baseDir, optDirLength);
+                }
+            }
+        }
+    }
+
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+    return result;
+}
+
 static void getPackageCounts(FFstrbuf* baseDir, FFPackagesResult* packageCounts, FFPackagesOptions* options)
 {
    if (!(options->disabled & FF_PACKAGES_FLAG_APK_BIT)) packageCounts->apk += getNumStrings(baseDir, "/lib/apk/db/installed", "C:Q");
@@ -277,6 +314,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);
 }

 static void getPackageCountsRegular(FFstrbuf* baseDir, FFPackagesResult* packageCounts, FFPackagesOptions* options)
@@ -1,23 +1,35 @@
 #include "publicip.h"
 #include "common/networking.h"

+#define FF_UNITIALIZED ((const char*)(uintptr_t) -1)
 static FFNetworkingState state;
-static int status = -1;
+static const char* status = FF_UNITIALIZED;

 void ffPreparePublicIp(FFPublicIpOptions* options)
 {
-    if (status != -1)
+    if (status != FF_UNITIALIZED)
    {
        fputs("Error: this module can only be used once due to internal limitations\n", stderr);
        exit(1);
    }

+    state.timeout = options->timeout;
+
    if (options->url.length == 0)
        status = ffNetworkingSendHttpRequest(&state, "ipinfo.io", "/json", NULL);
    else
    {
        FF_STRBUF_AUTO_DESTROY host = ffStrbufCreateCopy(&options->url);
-        ffStrbufSubstrAfterFirstS(&host, "://");
+        uint32_t hostStartIndex = ffStrbufFirstIndexS(&host, "://");
+        if (hostStartIndex < host.length)
+        {
+            if (hostStartIndex != 4 || !ffStrbufStartsWithIgnCaseS(&host, "http"))
+            {
+                fputs("Error: only http: protocol is supported. Use `Command` module with `curl` if needed\n", stderr);
+                exit(1);
+            }
+            ffStrbufSubstrAfter(&host, hostStartIndex + (strlen("://") - 1));
+        }
        uint32_t pathStartIndex = ffStrbufFirstIndexC(&host, '/');

        FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
@@ -41,18 +53,21 @@ static inline void wrapYyjsonFree(yyjson_doc** doc)

 const char* ffDetectPublicIp(FFPublicIpOptions* options, FFPublicIpResult* result)
 {
-    if (status == -1)
+    if (status == FF_UNITIALIZED)
        ffPreparePublicIp(options);

-    if (status == 0)
-        return "Failed to connect to an IP detection server";
+    if (status != NULL)
+        return status;

    FF_STRBUF_AUTO_DESTROY response = ffStrbufCreateA(4096);
-    bool success = ffNetworkingRecvHttpResponse(&state, &response, options->timeout);
-    if (success) ffStrbufSubstrAfterFirstS(&response, "\r\n\r\n");
+    const char* error = ffNetworkingRecvHttpResponse(&state, &response);
+    if (error == NULL)
+        ffStrbufSubstrAfterFirstS(&response, "\r\n\r\n");
+    else
+        return error;

-    if (!success || response.length == 0)
-        return "Failed to receive the server response";
+    if (response.length == 0)
+        return "Empty server response received";

    if (options->url.length == 0)
    {
@@ -69,5 +84,6 @@ const char* ffDetectPublicIp(FFPublicIpOptions* options, FFPublicIpResult* resul

    ffStrbufDestroy(&result->ip);
    ffStrbufInitMove(&result->ip, &response);
+    ffStrbufTrimRightSpace(&result->ip);
    return NULL;
 }
@@ -160,7 +160,7 @@ static const char* detectFromWTImpl(FFstrbuf* content, FFstrbuf* name, double* s
    #include <shlobj.h>
 #endif

-static void detectFromWindowsTeriminal(const FFstrbuf* terminalExe, FFTerminalFontResult* terminalFont)
+static void detectFromWindowsTerminal(const FFstrbuf* terminalExe, FFTerminalFontResult* terminalFont)
 {
    //https://learn.microsoft.com/en-us/windows/terminal/install#settings-json-file
    FF_STRBUF_AUTO_DESTROY json = ffStrbufCreate();
@@ -174,7 +174,7 @@ static void detectFromWindowsTeriminal(const FFstrbuf* terminalExe, FFTerminalFo
        char* pathEnd = jsonPath + strlen(jsonPath);
        strncpy(pathEnd, ".portable", sizeof(jsonPath) - (size_t) (pathEnd - jsonPath) - 1);

-        if(ffPathExists(jsonPath, FF_PATHTYPE_FILE))
+        if(ffPathExists(jsonPath, FF_PATHTYPE_ANY))
        {
            strncpy(pathEnd, "settings\\settings.json", sizeof(jsonPath) - (size_t) (pathEnd - jsonPath) - 1);
            if(!ffAppendFileBuffer(jsonPath, &json))
@@ -432,7 +432,7 @@ static bool detectTerminalFontCommon(const FFTerminalResult* terminal, FFTermina
    //Used by both Linux (WSL) and Windows
    else if(ffStrbufIgnCaseEqualS(&terminal->processName, "Windows Terminal") ||
        ffStrbufIgnCaseEqualS(&terminal->processName, "WindowsTerminal.exe"))
-        detectFromWindowsTeriminal(&terminal->exe, terminalFont);
+        detectFromWindowsTerminal(&terminal->exe, terminalFont);
    #endif

    else
@@ -145,13 +145,7 @@ static void detectXFCETerminal(FFTerminalFontResult* terminalFont)
        });
    }

-    if (!configFound)
-    {
-        ffStrbufSetStatic(&terminalFont->error, "Couldn't find xfce4/xfconf/xfce-perchannel-xml/xfce4-terminal.xml or xfce4/terminal/terminalrc");
-        return;
-    }
-
-    if(useSysFont.length == 0 || ffStrbufIgnCaseCompS(&useSysFont, "false") == 0)
+    if(configFound && (useSysFont.length == 0 || ffStrbufIgnCaseCompS(&useSysFont, "false") == 0))
    {
        if(fontName.length == 0)
            ffStrbufAppendF(&terminalFont->error, "Couldn't find FontName in %s", path);
@@ -331,6 +325,19 @@ static void detectWarp(FFTerminalFontResult* terminalFont)
    }
 }

+static void detectWestonTerminal(FFTerminalFontResult* terminalFont)
+{
+    FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
+    FF_STRBUF_AUTO_DESTROY size = ffStrbufCreate();
+    ffParsePropFileConfigValues("weston.ini", 2, (FFpropquery[]) {
+        {"font=", &font},
+        {"font-size=", &size},
+    });
+    if (!font.length) ffStrbufSetStatic(&font, "DejaVu Sans Mono");
+    if (!size.length) ffStrbufSetStatic(&size, "14");
+    ffFontInitValues(&terminalFont->font, font.chars, size.chars);
+}
+
 void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
 {
    if(ffStrbufIgnCaseEqualS(&terminal->processName, "konsole"))
@@ -361,4 +368,6 @@ void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFo
        detectSt(terminalFont, terminal->pid);
    else if(ffStrbufIgnCaseEqualS(&terminal->processName, "warp"))
        detectWarp(terminalFont);
+    else if(ffStrbufIgnCaseEqualS(&terminal->processName, "weston-terminal"))
+        detectWestonTerminal(terminalFont);
 }
@@ -400,6 +400,29 @@ FF_MAYBE_UNUSED static bool getTerminalVersionSt(FF_MAYBE_UNUSED FFstrbuf* exe,
    return version->length > 0;
 }

+FF_MAYBE_UNUSED static bool getTerminalVersionLxterminal(FFstrbuf* exe, FFstrbuf* version)
+{
+    if(!getExeVersionRaw(exe, version)) return false;
+    // lxterminal 0.3.2
+    ffStrbufSubstrAfterFirstC(version, ' ');
+    return version->length > 0;
+}
+
+FF_MAYBE_UNUSED static bool getTerminalVersionWeston(FF_MAYBE_UNUSED FFstrbuf* exe, FFstrbuf* version)
+{
+    // weston-terminal doesn't report a version, use weston version instead
+    if(ffProcessAppendStdOut(version, (char* const[]){
+        "weston",
+        "--version",
+        NULL
+    })) return false;
+
+    //weston 8.0.0
+    ffStrbufSubstrAfterFirstC(version, ' ');
+
+    return version->length > 0;
+}
+
 static bool getTerminalVersionContour(FFstrbuf* exe, FFstrbuf* version)
 {
    const char* env = getenv("TERMINAL_VERSION_STRING");
@@ -410,7 +433,7 @@ static bool getTerminalVersionContour(FFstrbuf* exe, FFstrbuf* version)
    }
    if(!getExeVersionRaw(exe, version)) return false;
    // Contour Terminal Emulator 0.3.12.262
-    ffStrbufSubstrAfterFirstC(version, ' ');
+    ffStrbufSubstrAfterLastC(version, ' ');
    return version->length > 0;
 }

@@ -525,6 +548,12 @@ bool fftsGetTerminalVersion(FFstrbuf* processName, FF_MAYBE_UNUSED FFstrbuf* exe
    if(ffStrbufIgnCaseEqualS(processName, "st"))
        return getTerminalVersionSt(exe, version);

+    if(ffStrbufIgnCaseEqualS(processName, "lxterminal"))
+        return getTerminalVersionLxterminal(exe, version);
+
+    if(ffStrbufIgnCaseEqualS(processName, "weston-terminal"))
+        return getTerminalVersionWeston(exe, version);
+
    if(ffStrbufIgnCaseEqualS(processName, "urxvt") ||
        ffStrbufIgnCaseEqualS(processName, "urxvtd") ||
        ffStrbufIgnCaseEqualS(processName, "rxvt") ||
@@ -231,6 +231,7 @@ static pid_t getShellInfo(FFShellResult* result, pid_t pid)
            ffStrEquals(name, "ltrace")              ||
            ffStrEquals(name, "perf")                ||
            ffStrEquals(name, "guake-wrapped")       ||
+            ffStrEquals(name, "time")                ||
            ffStrContainsIgnCase(name, "debug")      ||
            ffStrContainsIgnCase(name, "not-found")  ||
            ffStrEndsWith(name, ".sh")
@@ -280,6 +281,7 @@ static pid_t getTerminalInfo(FFTerminalResult* result, pid_t pid)
            ffStrEquals(name, "xonsh")      || // works in Linux but not in macOS because kernel returns `Python` in this case
            ffStrEquals(name, "login")      ||
            ffStrEquals(name, "sshd")       ||
+            ffStrEquals(name, "chezmoi")    || // #762
            #ifdef __linux__
            ffStrStartsWith(name, "flatpak-") || // #707
            #endif
@@ -341,6 +343,7 @@ static void getTerminalFromEnv(FFTerminalResult* result)
        !ffStrbufEqualS(&result->processName, "systemd") &&
        !ffStrbufEqualS(&result->processName, "init") &&
        !ffStrbufEqualS(&result->processName, "(init)") &&
+        !ffStrbufEqualS(&result->processName, "SessionLeader") && // #750
        #endif

        !ffStrbufEqualS(&result->processName, "0")
@@ -98,16 +98,14 @@ static uint32_t getShellInfo(FFShellResult* result, uint32_t pid)
        if(
            ffStrbufIgnCaseEqualS(&result->prettyName, "sudo")          ||
            ffStrbufIgnCaseEqualS(&result->prettyName, "su")            ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "doas")          ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "strace")        ||
            ffStrbufIgnCaseEqualS(&result->prettyName, "sshd")          ||
            ffStrbufIgnCaseEqualS(&result->prettyName, "gdb")           ||
            ffStrbufIgnCaseEqualS(&result->prettyName, "lldb")          ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "guake-wrapped") ||
            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")    ||
            ffStrbufContainIgnCaseS(&result->prettyName, "debug")       ||
+            ffStrbufContainIgnCaseS(&result->prettyName, "time")        ||
            ffStrbufStartsWithIgnCaseS(&result->prettyName, "ConEmu") // https://github.com/fastfetch-cli/fastfetch/issues/488#issuecomment-1619982014
        ) {
            ffStrbufClear(&result->processName);
@@ -143,7 +141,7 @@ static void setShellInfoDetails(FFShellResult* result)
        ffStrbufSetS(&result->prettyName, "Windows PowerShell ISE");
    else if(ffStrbufIgnCaseEqualS(&result->prettyName, "cmd"))
    {
-        ffStrbufClear(&result->prettyName);
+        ffStrbufSetS(&result->prettyName, "CMD");

        FF_AUTO_CLOSE_FD HANDLE snapshot = NULL;
        while(!(snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, result->pid)) && GetLastError() == ERROR_BAD_LENGTH) {}
@@ -156,15 +154,13 @@ static void setShellInfoDetails(FFShellResult* result)
            {
                if(wcsncmp(module.szModule, L"clink_dll_", strlen("clink_dll_")) == 0)
                {
-                    ffStrbufAppendS(&result->prettyName, "CMD (with Clink ");
+                    ffStrbufAppendS(&result->prettyName, " (with Clink ");
                    getProductVersion(module.szExePath, &result->prettyName);
                    ffStrbufAppendC(&result->prettyName, ')');
                    break;
                }
            }
        }
-        if(result->prettyName.length == 0)
-            ffStrbufAppendS(&result->prettyName, "Command Prompt");
    }
    else if(ffStrbufIgnCaseEqualS(&result->prettyName, "nu"))
        ffStrbufSetS(&result->prettyName, "nushell");
@@ -262,6 +258,7 @@ static bool detectDefaultTerminal(FFTerminalResult* result)
                    if(ffPathExists(result->exe.chars, FF_PATHTYPE_FILE))
                    {
                        result->exeName = result->exe.chars + ffStrbufLastIndexC(&result->exe, '\\') + 1;
+                        ffStrbufSet(&result->exePath, &result->exe);
                    }
                    else
                    {
@@ -296,7 +293,7 @@ static uint32_t getTerminalInfo(FFTerminalResult* result, uint32_t pid)

    while (pid != 0 && getProcessInfo(pid, &ppid, &result->processName, &result->exe, &result->exeName, &result->exePath, &hasGui))
    {
-        if(!hasGui)
+        if(!hasGui || ffStrbufIgnCaseEqualS(&result->processName, "far.exe")) // Far includes GUI objects...
        {
            //We are in nested shell
            ffStrbufClear(&result->processName);
@@ -313,7 +310,8 @@ static uint32_t getTerminalInfo(FFTerminalResult* result, uint32_t pid)
            ffStrbufSubstrBefore(&result->prettyName, result->prettyName.length - 4);

        if(ffStrbufIgnCaseEqualS(&result->prettyName, "sihost")           ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "explorer")
+            ffStrbufIgnCaseEqualS(&result->prettyName, "explorer")        ||
+            ffStrbufIgnCaseEqualS(&result->prettyName, "wininit")
        ) {
            // A CUI program created by Windows Explorer will spawn a conhost as its child.
            // However the conhost process is just a placeholder;
@@ -344,7 +342,7 @@ static void setTerminalInfoDetails(FFTerminalResult* result)
            : "Windows Terminal"
        );
    else if(ffStrbufIgnCaseEqualS(&result->prettyName, "conhost"))
-        ffStrbufSetStatic(&result->prettyName, "Console Window Host");
+        ffStrbufSetStatic(&result->prettyName, "Windows Console");
    else if(ffStrbufIgnCaseEqualS(&result->prettyName, "Code"))
        ffStrbufSetStatic(&result->prettyName, "Visual Studio Code");
    else if(ffStrbufIgnCaseEqualS(&result->prettyName, "explorer"))
@@ -10,6 +10,10 @@
    #define setutxent setutent
    #define getutxent getutent
 #endif
+#ifdef __linux__
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+#endif

 const char* ffDetectUsers(FFlist* users)
 {
@@ -33,11 +37,11 @@ next:
        ffStrbufInitS(&user->hostName, n->ut_host);
        ffStrbufInitS(&user->sessionName, n->ut_line);
        #ifdef __linux__
-        if(n->ut_addr_v6[0] || n->ut_addr_v6[1] || n->ut_addr_v6[2] || n->ut_addr_v6[3])
-            ffStrbufInitF(&user->clientIp, "%u.%u.%u.%u", n->ut_addr_v6[0], n->ut_addr_v6[1], n->ut_addr_v6[2], n->ut_addr_v6[3]);
-        else
-        #endif
+        // https://www.linuxquestions.org/questions/programming-9/get-the-ip-addr-out-from-an-int32_t-value-287687/#post1458622
+        ffStrbufInitS(&user->clientIp, inet_ntoa((struct in_addr) { .s_addr = (in_addr_t) n->ut_addr_v6[0] }));
+        #else
        ffStrbufInit(&user->clientIp);
+        #endif
        user->loginTime = (uint64_t) n->ut_tv.tv_sec * 1000 + (uint64_t) n->ut_tv.tv_usec / 1000;
    }

@@ -32,7 +32,21 @@ void ffDetectVersion(FFVersionResult* version)
    version->cmakeBuiltType = FASTFETCH_PROJECT_CMAKE_BUILD_TYPE;
    version->compileTime = __DATE__ ", " __TIME__;
    #ifdef __clang__
-        version->compiler = "clang " FF_STR(__clang_major__) "." FF_STR(__clang_minor__) "." FF_STR(__clang_patchlevel__);
+        version->compiler =
+            #ifdef _MSC_VER
+                "clang-cl " ;
+            #elif defined(__APPLE__) && defined(__apple_build_version__)
+                "Apple clang "
+            #else
+                "clang "
+            #endif
+
+            FF_STR(__clang_major__) "." FF_STR(__clang_minor__) "." FF_STR(__clang_patchlevel__)
+
+            #if defined(__APPLE__) && defined(__apple_build_version__)
+                " (" FF_STR(__apple_build_version__) ")"
+            #endif
+            ;
    #elif defined(__GNUC__)
        version->compiler = "gcc " FF_STR(__GNUC__) "." FF_STR(__GNUC_MINOR__) "." FF_STR(__GNUC_PATCHLEVEL__);
    #elif defined(_MSC_VER)
@@ -18,7 +18,7 @@ static inline void applyVulkanVersion(uint32_t vulkanVersion, FFVersion* ffVersi
    ffVersion->patch = VK_VERSION_PATCH(vulkanVersion);
 }

-static void applyDriverName(VkPhysicalDeviceDriverProperties* properties, FFstrbuf* result)
+static void applyDriverName(VkPhysicalDeviceDriverPropertiesKHR* properties, FFstrbuf* result)
 {
    if(!ffStrSet(properties->driverName))
        return;
@@ -127,8 +127,8 @@ static const char* detectVulkan(FFVulkanResult* result)
        //On VK 1.1 and up, we use vkGetPhysicalDeviceProperties2, so we can put VkPhysicalDeviceDriverProperties in the pNext chain.
        //This is required to get the driver name and conformance version.

-        VkPhysicalDeviceDriverProperties driverProperties = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
+        VkPhysicalDeviceDriverPropertiesKHR driverProperties = {
+            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
        };
        VkPhysicalDeviceProperties2 physicalDeviceProperties = {
            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
@@ -1,16 +1,19 @@
 #include "weather.h"

+#define FF_UNITIALIZED ((const char*)(uintptr_t) -1)
 static FFNetworkingState state;
-static int status = -1;
+static const char* status = FF_UNITIALIZED;

 void ffPrepareWeather(FFWeatherOptions* options)
 {
-    if (status != -1)
+    if (status != FF_UNITIALIZED)
    {
        fputs("Error: this module can only be used once due to internal limitations\n", stderr);
        exit(1);
    }

+    state.timeout = options->timeout;
+
    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateS("/");
    if (options->location.length)
        ffStrbufAppend(&path, &options->location);
@@ -21,18 +24,24 @@ void ffPrepareWeather(FFWeatherOptions* options)

 const char* ffDetectWeather(FFWeatherOptions* options, FFstrbuf* result)
 {
-    if(status == -1)
+    if(status == FF_UNITIALIZED)
        ffPrepareWeather(options);

-    if(status == 0)
-        return "Failed to connect to 'wttr.in'";
+    if(status != NULL)
+        return status;

    ffStrbufEnsureFree(result, 4095);
-    bool success = ffNetworkingRecvHttpResponse(&state, result, options->timeout);
-    if (success) ffStrbufSubstrAfterFirstS(result, "\r\n\r\n");
+    const char* error = ffNetworkingRecvHttpResponse(&state, result);
+    if (error == NULL)
+    {
+        ffStrbufSubstrAfterFirstS(result, "\r\n\r\n");
+        ffStrbufTrimRightSpace(result);
+    }
+    else
+        return error;

-    if(!success || result->length == 0)
-        return "Failed to receive the server response";
+    if(result->length == 0)
+        return "Empty server response received";

    return NULL;
 }
@@ -1,20 +1,15 @@
 #include "fastfetch.h"
 #include "common/commandoption.h"
-#include "common/printing.h"
-#include "common/parsing.h"
 #include "common/io/io.h"
-#include "common/time.h"
 #include "common/jsonconfig.h"
 #include "detection/version/version.h"
 #include "util/stringUtils.h"
 #include "util/mallocHelper.h"
-#include "logo/logo.h"
 #include "fastfetch_datatext.h"

 #include <stdlib.h>
 #include <ctype.h>
 #include <string.h>
-#include <inttypes.h>

 #ifdef WIN32
    #include "util/windows/getline.h"
@@ -824,7 +819,7 @@ static void run(FFdata* data)
        ffPrintCommandOption(data, instance.state.resultDoc);

    if (instance.state.resultDoc)
-        yyjson_mut_write_fp(stdout, instance.state.resultDoc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES, NULL, NULL);
+        yyjson_mut_write_fp(stdout, instance.state.resultDoc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES | YYJSON_WRITE_NEWLINE_AT_END, NULL, NULL);
    else
        ffFinish();
 }
@@ -843,11 +838,11 @@ static void writeConfigFile(FFdata* data, const FFstrbuf* filename)
    ffMigrateCommandOptionToJsonc(data, doc);

    if (ffStrbufEqualS(filename, "-"))
-        yyjson_mut_write_fp(stdout, doc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES, NULL, NULL);
+        yyjson_mut_write_fp(stdout, doc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES | YYJSON_WRITE_NEWLINE_AT_END, NULL, NULL);
    else
    {
        size_t len;
-        FF_AUTO_FREE const char* str = yyjson_mut_write(doc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES, &len);
+        FF_AUTO_FREE const char* str = yyjson_mut_write(doc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES | YYJSON_WRITE_NEWLINE_AT_END, &len);
        if (!str)
        {
            printf("Error: failed to generate config file\n");
@@ -21,6 +21,7 @@ int main(void)
        &options->title,
        &options->separator,
        &options->os,
+        &options->host,
        &options->kernel,
        &options->uptime,
        &options->packages,
@@ -1,4 +1,4 @@
-${c1}          A
+          A
         ooo
        ooooo
       ooooooo
@@ -1,8 +1,8 @@
-${c2}                    /==\\
-                    \\==/
+${c2}                    /==\
+                    \==/
 ${c1}               · · · · · · ·
            · · · · · · · · · ·
-	   · · · ${c2}.-======-.${c1}· · · ·
+           · · · ${c2}.-======-.${c1}· · · ·
 ${c2}        .::.${c1} ·${c2}.-============-.${c1}· ${c2}.::.
     .:==:${c1}· ${c2}.:===:'${c1}. ·· .${c2}':===:.${c1} ·${c2}:==:.
  .:===:${c1} · ${c2}:===.${c1} ·  ${c3}.--.${c1}  · ${c2}.===:${c1} · ${c2}:===:.
@@ -12,8 +12,8 @@ ${c2}        .::.${c1} ·${c2}.-============-.${c1}· ${c2}.::.
  ':===:${c1} · ${c2}:===.${c1} ·  ${c3}'--'${c1}  · ${c2}.===:${c1} · ${c2}:===:'
     ':==:${c1}· ${c2}':===:.${c1}' ·· '${c2}.:===:'${c1} ·${c2}:==:'
        '::'${c1} · ${c2}'===-.  .-==='${c1} · ${c2}'::'
-  ${c2}/==\\${c1}     · · · ${c2}:===  ===:${c1} · · ·     ${c2}/==\\
-  \\==/${c1}      · · ·${c2}:===${c1} ·${c2}===:${c1}· · ·      ${c2}\\==/${c2}
+  ${c2}/==\${c1}     · · · ${c2}:===  ===:${c1} · · ·     ${c2}/==\
+  \==/${c1}      · · ·${c2}:===${c1} ·${c2}===:${c1}· · ·      ${c2}\==/${c2}
         .-.   ${c1}· ${c2}:===${c1}· ${c2}===:${c1} ·${c2}   ${c2}.-.
         .===.   .===  ===.   .===.
           .========    ========.
@@ -0,0 +1,10 @@
+             ⣀⣠⣴⣶⣶⣿⣿⣿⣿⣶⣶⣦⣄⣀
+          ⢀⣴⣾⣿⠿⠛⠉⠉    ⠉⠉⠛⠿⣿⣷⣦⡀
+         ⣴⣿⡿⠋              ⠙⢿⣿⣦
+        ⣾⣿⡟     ⣠⣴⣶⣿⣿⣶⣦⣄     ⢻⣿⣷
+⣠⣤⣤⣤⣤⣤⣤⣼⣿⣿     ⣼⣿⡟⠉  ⠉⢻⣿⣧     ⣿⣿⣧⣤⣤⣤⣤⣤⣤⣄
+⠙⠛⠛⠛⠛⠛⠛⢻⣿⣿     ⢻⣿⣧⡀  ⢀⣼⣿⡟     ⣿⣿⡟⠛⠛⠛⠛⠛⠛⠋
+        ⢿⣿⣇     ⠙⠿⣿⣿⣿⣿⠿⠋     ⣸⣿⡿
+        ⠈⢻⣿⣧⣀              ⣀⣾⣿⡟⠁
+          ⠙⠻⣿⣷⣦⣄⣀      ⣀⣠⣴⣾⣿⠟⠋
+             ⠉⠛⠿⢿⣿⣿⣿⣿⣿⣿⡿⠿⠛⠉
@@ -224,7 +224,7 @@ static const FFlogo A[] = {
        .colors = {
            FF_COLOR_FG_BLUE,
            FF_COLOR_FG_BLACK,
-            FF_COLOR_FG_GREEN,
+            FF_COLOR_FG_RED,
            FF_COLOR_FG_YELLOW,
        },
    },
@@ -413,7 +413,7 @@ static const FFlogo A[] = {
        .lines = FASTFETCH_DATATEXT_LOGO_ARCO,
        .colors = {
            FF_COLOR_FG_BLUE,
-            FF_COLOR_FG_GREEN,
+            FF_COLOR_FG_WHITE,
        },
        .colorKeys = FF_COLOR_FG_BLUE,
        .colorTitle = FF_COLOR_FG_BLUE,
@@ -425,7 +425,7 @@ static const FFlogo A[] = {
        .lines = FASTFETCH_DATATEXT_LOGO_ARCO_SMALL,
        .colors = {
            FF_COLOR_FG_BLUE,
-            FF_COLOR_FG_GREEN,
+            FF_COLOR_FG_WHITE,
        },
        .colorKeys = FF_COLOR_FG_BLUE,
        .colorTitle = FF_COLOR_FG_BLUE,
@@ -2932,6 +2932,14 @@ static const FFlogo O[] = {
        .colorKeys = FF_COLOR_FG_GREEN,
        .colorTitle = FF_COLOR_FG_GREEN,
    },
+    // openSuseMicroOS
+    {
+        .names = {"opensuse-microos", "opensuse_microos"},
+        .lines = FASTFETCH_DATATEXT_LOGO_OPENSUSE_MICROOS,
+        .colors = {
+            FF_COLOR_FG_GREEN,
+        },
+    },
    // OpenSuseLeap
    {
        .names = {"opensuse_leap", "open_suse_leap", "opensuse-leap", "open-suse-leap", "suse_leap", "suse-leap", "opensuseleap"},
@@ -3299,6 +3307,17 @@ static const FFlogo P[] = {
            FF_COLOR_FG_WHITE,
        },
    },
+    // Proxmox
+    {
+        .names = {"proxmox"},
+        .lines = FASTFETCH_DATATEXT_LOGO_PROXMOX,
+        .colors = {
+            FF_COLOR_FG_WHITE,
+            FF_COLOR_FG_256 "202"
+        },
+        .colorKeys = FF_COLOR_FG_WHITE,
+        .colorTitle = FF_COLOR_FG_256 "202",
+    },
    // PuffOS
    {
        .names = {"PuffOS"},
@@ -3558,17 +3577,6 @@ static const FFlogo R[] = {
        .colorKeys = FF_COLOR_FG_BLUE,
        .colorTitle = FF_COLOR_FG_BLUE,
    },
-    // Proxmox
-    {
-        .names = {"proxmox"},
-        .lines = FASTFETCH_DATATEXT_LOGO_PROXMOX,
-        .colors = {
-            FF_COLOR_FG_WHITE,
-            FF_COLOR_FG_256 "202"
-        },
-        .colorKeys = FF_COLOR_FG_WHITE,
-        .colorTitle = FF_COLOR_FG_256 "202",
-    },
    // LAST
    {},
 };
@@ -768,10 +768,8 @@ static bool printImageIfExistsSlowPath(FFLogoType type, bool printError)
    requestData.characterPixelWidth = 1;
    requestData.characterPixelHeight = 1;

-    if(
-        (type != FF_LOGO_TYPE_IMAGE_CHAFA || instance.config.logo.width == 0 || instance.config.logo.height == 0) &&
-        !getCharacterPixelDimensions(&requestData)
-    ) {
+    if(!getCharacterPixelDimensions(&requestData))
+    {
        if(printError)
            fputs("Logo: getCharacterPixelDimensions() failed", stderr);
        return false;
@@ -7,7 +7,7 @@
 #include "modules/battery/battery.h"
 #include "util/stringUtils.h"

-#define FF_BATTERY_NUM_FORMAT_ARGS 8
+#define FF_BATTERY_NUM_FORMAT_ARGS 9

 static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uint8_t index)
 {
@@ -61,7 +61,7 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
        ffPercentAppendNum(&capacityStr, result->capacity, options->percent, false);
        FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
        ffTempsAppendNum(result->temperature, &tempStr, options->tempConfig);
-        ffPrintFormat(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_BATTERY_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result->technology},
@@ -71,7 +71,7 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
            {FF_FORMAT_ARG_TYPE_UINT, &result->cycleCount},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result->serial},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufactureDate},
-        });
+        }));
    }
 }

@@ -83,7 +83,7 @@ void ffPrintBattery(FFBatteryOptions* options)

    if (error)
    {
-        ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
    }
    else
    {
@@ -100,7 +100,7 @@ void ffPrintBattery(FFBatteryOptions* options)
            ffStrbufDestroy(&result->manufactureDate);
        }
        if(results.length == 0)
-            ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "No batteries found");
+            ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No batteries found");
    }
 }

@@ -155,7 +155,7 @@ void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module)
        if (ffPercentParseJsonObject(key, val, &options->percent))
            continue;

-        ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -216,7 +216,7 @@ void ffGenerateBatteryJsonResult(FFBatteryOptions* options, yyjson_mut_doc* doc,

 void ffPrintBatteryHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_BATTERY_MODULE_NAME, "{4}, {5}", FF_BATTERY_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_BATTERY_MODULE_NAME, "{4}, {5}", FF_BATTERY_NUM_FORMAT_ARGS, ((const char* []) {
        "Battery manufactor",
        "Battery model",
        "Battery technology",
@@ -226,7 +226,7 @@ void ffPrintBatteryHelpFormat(void)
        "Battery cycle count",
        "Battery serial number",
        "Battery manufactor date",
-    });
+    }));
 }

 void ffInitBatteryOptions(FFBatteryOptions* options)
@@ -21,13 +21,13 @@ void ffPrintBios(FFBiosOptions* options)

    if(error)
    {
-        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        goto exit;
    }

    if(bios.version.length == 0)
    {
-        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "bios_version is not set.");
+        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "bios_version is not set.");
        goto exit;
    }

@@ -43,9 +43,9 @@ void ffPrintBios(FFBiosOptions* options)
    else
    {
        ffStrbufClear(&key);
-        ffParseFormatString(&key, &options->moduleArgs.key, 3, (FFformatarg[]){
+        FF_PARSE_FORMAT_STRING_CHECKED(&key, &options->moduleArgs.key, 1, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.type},
-        });
+        }));
    }

    if(options->moduleArgs.outputFormat.length == 0)
@@ -59,13 +59,13 @@ void ffPrintBios(FFBiosOptions* options)
    }
    else
    {
-        ffPrintFormat(key.chars, 0, &options->moduleArgs, FF_BIOS_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        FF_PRINT_FORMAT_CHECKED(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_BIOS_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.date},
            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.release},
            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.vendor},
            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.version},
            {FF_FORMAT_ARG_TYPE_STRBUF, &bios.type},
-        });
+        }));
    }

 exit:
@@ -99,7 +99,7 @@ void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -151,13 +151,13 @@ exit:

 void ffPrintBiosHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_BIOS_MODULE_NAME, "{4} ({2})", FF_BIOS_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_BIOS_MODULE_NAME, "{4} ({2})", FF_BIOS_NUM_FORMAT_ARGS, ((const char* []) {
        "bios date",
        "bios release",
        "bios vendor",
        "bios version",
        "firmware type",
-    });
+    }));
 }

 void ffInitBiosOptions(FFBiosOptions* options)
@@ -32,12 +32,12 @@ static void printDevice(FFBluetoothOptions* options, const FFBluetoothResult* de
        FF_STRBUF_AUTO_DESTROY percentageStr = ffStrbufCreate();
        ffPercentAppendNum(&percentageStr, device->battery, options->percent, false);

-        ffPrintFormat(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs, FF_BLUETOOTH_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        FF_PRINT_FORMAT_CHECKED(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_BLUETOOTH_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->name},
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->address},
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->type},
            {FF_FORMAT_ARG_TYPE_STRBUF, &percentageStr}
-        });
+        }));
    }
 }

@@ -48,7 +48,7 @@ void ffPrintBluetooth(FFBluetoothOptions* options)

    if(error)
    {
-        ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
    }
    else
    {
@@ -64,7 +64,7 @@ void ffPrintBluetooth(FFBluetoothOptions* options)

        if(filtered.length == 0)
        {
-            ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "No bluetooth devices found");
+            ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No bluetooth devices found");
        }

        for(uint32_t i = 0; i < filtered.length; i++)
@@ -123,7 +123,7 @@ void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module)
        if (ffPercentParseJsonObject(key, val, &options->percent))
            continue;

-        ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -175,12 +175,12 @@ void ffGenerateBluetoothJsonResult(FF_MAYBE_UNUSED FFBluetoothOptions* options,

 void ffPrintBluetoothHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_BLUETOOTH_MODULE_NAME, "{1} ({4})", FF_BLUETOOTH_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_BLUETOOTH_MODULE_NAME, "{1} ({4})", FF_BLUETOOTH_NUM_FORMAT_ARGS, ((const char* []) {
        "Name",
        "Address",
        "Type",
        "Battery percentage"
-    });
+    }));
 }

 void ffInitBluetoothOptions(FFBluetoothOptions* options)
@@ -4,7 +4,7 @@
 #include "modules/board/board.h"
 #include "util/stringUtils.h"

-#define FF_BOARD_NUM_FORMAT_ARGS 3
+#define FF_BOARD_NUM_FORMAT_ARGS 4

 void ffPrintBoard(FFBoardOptions* options)
 {
@@ -17,13 +17,13 @@ void ffPrintBoard(FFBoardOptions* options)
    const char* error = ffDetectBoard(&result);
    if(error)
    {
-        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        goto exit;
    }

    if(result.name.length == 0)
    {
-        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "board_name is not set.");
+        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "board_name is not set.");
        goto exit;
    }

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

 exit:
@@ -75,7 +75,7 @@ void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -124,12 +124,12 @@ exit:

 void ffPrintBoardHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_BOARD_MODULE_NAME, "{1} ({3})", FF_BOARD_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_BOARD_MODULE_NAME, "{1} ({3})", FF_BOARD_NUM_FORMAT_ARGS, ((const char* []) {
        "board name",
        "board vendor",
        "board version",
        "board serial number",
-    });
+    }));
 }

 void ffInitBoardOptions(FFBoardOptions* options)
@@ -15,13 +15,13 @@ void ffPrintBrightness(FFBrightnessOptions* options)

    if(error)
    {
-        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

    if(result.length == 0)
    {
-        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "No result is detected.");
+        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No result is detected.");
        return;
    }

@@ -37,10 +37,10 @@ void ffPrintBrightness(FFBrightnessOptions* options)
        else
        {
            uint32_t moduleIndex = result.length == 1 ? 0 : index + 1;
-            ffParseFormatString(&key, &options->moduleArgs.key, 2, (FFformatarg[]){
+            FF_PARSE_FORMAT_STRING_CHECKED(&key, &options->moduleArgs.key, 2, ((FFformatarg[]){
                {FF_FORMAT_ARG_TYPE_UINT, &moduleIndex},
                {FF_FORMAT_ARG_TYPE_STRBUF, &item->name}
-            });
+            }));
        }

        const double percent = (item->current - item->min) / (item->max - item->min) * 100;
@@ -69,13 +69,13 @@ void ffPrintBrightness(FFBrightnessOptions* options)
        {
            FF_STRBUF_AUTO_DESTROY valueStr = ffStrbufCreate();
            ffPercentAppendNum(&valueStr, percent, options->percent, false);
-            ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_BRIGHTNESS_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            FF_PRINT_FORMAT_CHECKED(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_BRIGHTNESS_NUM_FORMAT_ARGS, ((FFformatarg[]) {
                {FF_FORMAT_ARG_TYPE_STRBUF, &valueStr},
                {FF_FORMAT_ARG_TYPE_STRBUF, &item->name},
                {FF_FORMAT_ARG_TYPE_DOUBLE, &item->max},
                {FF_FORMAT_ARG_TYPE_DOUBLE, &item->min},
                {FF_FORMAT_ARG_TYPE_DOUBLE, &item->current},
-            });
+            }));
        }

        ffStrbufClear(&key);
@@ -125,7 +125,7 @@ void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* modul
        if (ffPercentParseJsonObject(key, val, &options->percent))
            continue;

-        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -180,13 +180,13 @@ void ffGenerateBrightnessJsonResult(FF_MAYBE_UNUSED FFBrightnessOptions* options

 void ffPrintBrightnessHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_BRIGHTNESS_MODULE_NAME, "{1}", FF_BRIGHTNESS_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_BRIGHTNESS_MODULE_NAME, "{1}", FF_BRIGHTNESS_NUM_FORMAT_ARGS, ((const char* []) {
        "Screen brightness (percentage)",
        "Screen name",
        "Maximum brightness value",
        "Minimum brightness value",
        "Current brightness value",
-    });
+    }));
 }

 void ffInitBrightnessOptions(FFBrightnessOptions* options)
@@ -5,7 +5,7 @@
 #include "modules/camera/camera.h"
 #include "util/stringUtils.h"

-#define FF_CAMERA_NUM_FORMAT_ARGS 5
+#define FF_CAMERA_NUM_FORMAT_ARGS 6

 static void printDevice(FFCameraOptions* options, const FFCameraResult* device, uint8_t index)
 {
@@ -27,14 +27,14 @@ static void printDevice(FFCameraOptions* options, const FFCameraResult* device,
    }
    else
    {
-        ffPrintFormat(FF_CAMERA_MODULE_NAME, index, &options->moduleArgs, FF_CAMERA_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        FF_PRINT_FORMAT_CHECKED(FF_CAMERA_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_CAMERA_NUM_FORMAT_ARGS, (((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->name},
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->vendor},
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->colorspace},
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->id},
            {FF_FORMAT_ARG_TYPE_UINT, &device->width},
            {FF_FORMAT_ARG_TYPE_UINT, &device->height},
-        });
+        })));
    }
 }

@@ -45,13 +45,13 @@ void ffPrintCamera(FFCameraOptions* options)

    if (error)
    {
-        ffPrintError(FF_CAMERA_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_CAMERA_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

    if (result.length == 0)
    {
-        ffPrintError(FF_CAMERA_MODULE_NAME, 0, &options->moduleArgs, "No camera found");
+        ffPrintError(FF_CAMERA_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No camera found");
        return;
    }

@@ -92,7 +92,7 @@ void ffParseCameraJsonObject(FFCameraOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_CAMERA_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_CAMERA_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -138,14 +138,14 @@ void ffGenerateCameraJsonResult(FF_MAYBE_UNUSED FFCameraOptions* options, yyjson

 void ffPrintCameraHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_CAMERA_MODULE_NAME, "{1} ({4}px x {5}px)", FF_CAMERA_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_CAMERA_MODULE_NAME, "{1} ({4}px x {5}px)", FF_CAMERA_NUM_FORMAT_ARGS, ((const char* []) {
        "Device name",
        "Vendor",
        "Color space",
        "Identifier",
        "Width (in px)",
        "Height (in px)",
-    });
+    }));
 }

 void ffInitCameraOptions(FFCameraOptions* options)
@@ -4,7 +4,7 @@
 #include "modules/chassis/chassis.h"
 #include "util/stringUtils.h"

-#define FF_CHASSIS_NUM_FORMAT_ARGS 3
+#define FF_CHASSIS_NUM_FORMAT_ARGS 4

 void ffPrintChassis(FFChassisOptions* options)
 {
@@ -18,13 +18,13 @@ void ffPrintChassis(FFChassisOptions* options)

    if(error)
    {
-        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        goto exit;
    }

    if(result.type.length == 0)
    {
-        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "chassis_type is not set by O.E.M.");
+        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "chassis_type is not set by O.E.M.");
        goto exit;
    }

@@ -38,12 +38,12 @@ void ffPrintChassis(FFChassisOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_CHASSIS_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        FF_PRINT_FORMAT_CHECKED(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_CHASSIS_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &result.type},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result.vendor},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result.version},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result.serial},
-        });
+        }));
    }

 exit:
@@ -76,7 +76,7 @@ void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -125,12 +125,12 @@ exit:

 void ffPrintChassisHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_CHASSIS_MODULE_NAME, "{1}", FF_CHASSIS_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_CHASSIS_MODULE_NAME, "{1}", FF_CHASSIS_NUM_FORMAT_ARGS, ((const char* []) {
        "chassis type",
        "chassis vendor",
        "chassis version",
        "chassis serial number",
-    });
+    }));
 }

 void ffInitChassisOptions(FFChassisOptions* options)
@@ -88,7 +88,7 @@ void ffPrintColors(FFColorsOptions* options)

    if (!flag)
    {
-        ffPrintError(FF_COLORS_MODULE_NAME, 0, &options->moduleArgs, "%s", "Nothing to print");
+        ffPrintError(FF_COLORS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", "Nothing to print");
    }
 }

@@ -166,7 +166,7 @@ void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module)
                {},
            });
            if (error)
-                ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error);
+                ffPrintError(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error);
            else
                options->symbol = (FFColorsSymbol) value;
            continue;
@@ -181,7 +181,7 @@ void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module)
        if (ffStrEqualsIgnCase(key, "block"))
        {
            if (!yyjson_is_obj(val))
-                ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: must be an object", key);
+                ffPrintError(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: must be an object", key);
            else
            {
                yyjson_val* width = yyjson_obj_get(val, "width");
@@ -192,15 +192,15 @@ void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module)
                if (range)
                {
                    if (!yyjson_is_arr(range) || yyjson_arr_size(range) != 2)
-                        ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s.range value: must be an array of 2 elements", key);
+                        ffPrintError(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s.range value: must be an array of 2 elements", key);
                    else
                    {
                        uint8_t start = (uint8_t) yyjson_get_uint(yyjson_arr_get(range, 0));
                        uint8_t end = (uint8_t) yyjson_get_uint(yyjson_arr_get(range, 1));
                        if (start > end)
-                            ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s.range value: range[0] > range[1]", key);
+                            ffPrintError(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s.range value: range[0] > range[1]", key);
                        else if (end > 15)
-                            ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s.range value: range[1] > 15", key);
+                            ffPrintError(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s.range value: range[1] > 15", key);
                        else
                        {
                            options->block.range[0] = start;
@@ -212,7 +212,7 @@ void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module)
            continue;
        }

-        ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key);
+        ffPrintError(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key);
    }
 }

@@ -22,13 +22,13 @@ void ffPrintCommand(FFCommandOptions* options)

    if(error)
    {
-        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

    if(!result.length)
    {
-        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "No result printed");
+        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No result printed");
        return;
    }

@@ -39,9 +39,9 @@ void ffPrintCommand(FFCommandOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, FF_COMMAND_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_COMMAND_NUM_FORMAT_ARGS, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &result}
-        });
+        }));
    }
 }

@@ -92,7 +92,7 @@ void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module)
            continue;
        }

-        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -141,9 +141,9 @@ void ffGenerateCommandJsonResult(FF_MAYBE_UNUSED FFCommandOptions* options, yyjs

 void ffPrintCommandHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_COMMAND_MODULE_NAME, "{1}", FF_COMMAND_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_COMMAND_MODULE_NAME, "{1}", FF_COMMAND_NUM_FORMAT_ARGS, ((const char* []) {
        "Command result"
-    });
+    }));
 }

 void ffInitCommandOptions(FFCommandOptions* options)
@@ -13,7 +13,7 @@ void ffPrintCPU(FFCPUOptions* options)
    FFCPUResult cpu;
    cpu.temperature = FF_CPU_TEMP_UNSET;
    cpu.coresPhysical = cpu.coresLogical = cpu.coresOnline = 0;
-    cpu.frequencyMax = cpu.frequencyMin = 0;
+    cpu.frequencyMin = cpu.frequencyMax = cpu.frequencyBase = 0.0/0.0;
    ffStrbufInit(&cpu.name);
    ffStrbufInit(&cpu.vendor);

@@ -21,11 +21,11 @@ void ffPrintCPU(FFCPUOptions* options)

    if(error)
    {
-        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
    }
    else if(cpu.vendor.length == 0 && cpu.name.length == 0 && cpu.coresOnline <= 1)
    {
-        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "No CPU detected");
+        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No CPU detected");
    }
    else
    {
@@ -48,8 +48,11 @@ void ffPrintCPU(FFCPUOptions* options)
            if(cpu.coresOnline > 1)
                ffStrbufAppendF(&str, " (%u)", cpu.coresOnline);

-            if(cpu.frequencyMax > 0.0)
-                ffStrbufAppendF(&str, " @ %.*f GHz", options->freqNdigits, cpu.frequencyMax);
+            double freq = cpu.frequencyMax;
+            if(freq != freq)
+                freq = cpu.frequencyBase;
+            if(freq == freq)
+                ffStrbufAppendF(&str, " @ %.*f GHz", options->freqNdigits, freq);

            if(cpu.temperature == cpu.temperature) //FF_CPU_TEMP_UNSET
            {
@@ -63,16 +66,16 @@ void ffPrintCPU(FFCPUOptions* options)
        {
            FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
            ffTempsAppendNum(cpu.temperature, &tempStr, options->tempConfig);
-            ffPrintFormat(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
+            FF_PRINT_FORMAT_CHECKED(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_CPU_NUM_FORMAT_ARGS, ((FFformatarg[]){
                {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.name},
                {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.vendor},
                {FF_FORMAT_ARG_TYPE_UINT16, &cpu.coresPhysical},
                {FF_FORMAT_ARG_TYPE_UINT16, &cpu.coresLogical},
                {FF_FORMAT_ARG_TYPE_UINT16, &cpu.coresOnline},
-                {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMin},
+                {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyBase},
                {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMax},
                {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr}
-            });
+            }));
        }
    }

@@ -121,7 +124,7 @@ void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module)
            continue;
        }

-        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -143,7 +146,7 @@ void ffGenerateCPUJsonResult(FFCPUOptions* options, yyjson_mut_doc* doc, yyjson_
    FFCPUResult cpu;
    cpu.temperature = FF_CPU_TEMP_UNSET;
    cpu.coresPhysical = cpu.coresLogical = cpu.coresOnline = 0;
-    cpu.frequencyMax = cpu.frequencyMin = 0;
+    cpu.frequencyMin = cpu.frequencyMax = cpu.frequencyBase = 0.0/0.0;
    ffStrbufInit(&cpu.name);
    ffStrbufInit(&cpu.vendor);

@@ -169,8 +172,9 @@ void ffGenerateCPUJsonResult(FFCPUOptions* options, yyjson_mut_doc* doc, yyjson_
        yyjson_mut_obj_add_uint(doc, cores, "online", cpu.coresOnline);

        yyjson_mut_val* frequency = yyjson_mut_obj_add_obj(doc, obj, "frequency");
-        yyjson_mut_obj_add_real(doc, frequency, "min", cpu.frequencyMin);
+        yyjson_mut_obj_add_real(doc, frequency, "base", cpu.frequencyBase);
        yyjson_mut_obj_add_real(doc, frequency, "max", cpu.frequencyMax);
+        yyjson_mut_obj_add_real(doc, frequency, "min", cpu.frequencyMin);

        yyjson_mut_obj_add_real(doc, obj, "temperature", cpu.temperature);
    }
@@ -181,16 +185,16 @@ void ffGenerateCPUJsonResult(FFCPUOptions* options, yyjson_mut_doc* doc, yyjson_

 void ffPrintCPUHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_CPU_MODULE_NAME, "{1} ({5}) @ {7} GHz", FF_CPU_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_CPU_MODULE_NAME, "{1} ({5}) @ {7} GHz", FF_CPU_NUM_FORMAT_ARGS, ((const char* []) {
        "Name",
        "Vendor",
        "Physical core count",
        "Logical core count",
        "Online core count",
-        "Min frequency",
+        "Base frequency",
        "Max frequency",
        "Temperature (formatted)"
-    });
+    }));
 }

 void ffInitCPUOptions(FFCPUOptions* options)
@@ -15,7 +15,7 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options)

    if(error)
    {
-        ffPrintError(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

@@ -79,13 +79,13 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options)
        ffPercentAppendNum(&minStr, minValue, options->percent, false);
        FF_STRBUF_AUTO_DESTROY maxStr = ffStrbufCreate();
        ffPercentAppendNum(&maxStr, maxValue, options->percent, false);
-        ffPrintFormat(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, FF_CPUUSAGE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_CPUUSAGE_NUM_FORMAT_ARGS, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &avgStr},
            {FF_FORMAT_ARG_TYPE_STRBUF, &maxStr},
            {FF_FORMAT_ARG_TYPE_UINT, &maxIndex},
            {FF_FORMAT_ARG_TYPE_STRBUF, &minStr},
            {FF_FORMAT_ARG_TYPE_UINT, &minIndex},
-        });
+        }));
    }
 }

@@ -130,7 +130,7 @@ void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module)
        if (ffPercentParseJsonObject(key, val, &options->percent))
            continue;

-        ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -166,13 +166,13 @@ void ffGenerateCPUUsageJsonResult(FF_MAYBE_UNUSED FFCPUUsageOptions* options, yy

 void ffPrintCPUUsageHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_CPUUSAGE_MODULE_NAME, "{1}", FF_CPUUSAGE_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_CPUUSAGE_MODULE_NAME, "{1}", FF_CPUUSAGE_NUM_FORMAT_ARGS, ((const char* []) {
        "CPU usage (percentage, average)",
        "CPU usage (percentage, maximum)",
        "CPU core index of maximum usage",
        "CPU usage (percentage, minimum)",
        "CPU core index of minimum usage",
-    });
+    }));
 }

 void ffInitCPUUsageOptions(FFCPUUsageOptions* options)
@@ -16,7 +16,7 @@ void ffPrintCursor(FFCursorOptions* options)
    ffDetectCursor(&result);

    if(result.error.length)
-        ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "%s", result.error.chars);
+        ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", result.error.chars);
    else
    {
        ffStrbufRemoveIgnCaseEndS(&result.theme, "cursors");
@@ -38,10 +38,10 @@ void ffPrintCursor(FFCursorOptions* options)
        }
        else
        {
-            ffPrintFormat(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_CURSOR_NUM_FORMAT_ARGS, (FFformatarg[]){
+            FF_PRINT_FORMAT_CHECKED(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_CURSOR_NUM_FORMAT_ARGS, ((FFformatarg[]) {
                {FF_FORMAT_ARG_TYPE_STRBUF, &result.theme},
                {FF_FORMAT_ARG_TYPE_STRBUF, &result.size}
-            });
+            }));
        }
    }

@@ -73,7 +73,7 @@ void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -112,10 +112,10 @@ void ffGenerateCursorJsonResult(FF_MAYBE_UNUSED FFCursorOptions* options, yyjson

 void ffPrintCursorHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_CURSOR_MODULE_NAME, "{1} ({2}px)", FF_CURSOR_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_CURSOR_MODULE_NAME, "{1} ({2}px)", FF_CURSOR_NUM_FORMAT_ARGS, ((const char* []) {
        "Cursor theme",
        "Cursor size"
-    });
+    }));
 }

 void ffInitCursorOptions(FFCursorOptions* options)
@@ -8,7 +8,7 @@ void ffPrintCustom(FFCustomOptions* options)
 {
    if (options->moduleArgs.outputFormat.length == 0)
    {
-        ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "output format must be set for custom module");
+        ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "output format must be set for custom module");
        return;
    }

@@ -48,7 +48,7 @@ void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -65,7 +65,7 @@ void ffPrintDateTimeFormat(struct tm* tm, const FFModuleArgs* moduleArgs)
    strftime(result.offsetFromUtc, sizeof(result.offsetFromUtc), "%z", tm);
    strftime(result.timezoneName, sizeof(result.timezoneName), "%Z", tm);

-    ffPrintFormat(FF_DATETIME_DISPLAY_NAME, 0, moduleArgs, FF_DATETIME_NUM_FORMAT_ARGS, (FFformatarg[]) {
+    FF_PRINT_FORMAT_CHECKED(FF_DATETIME_DISPLAY_NAME, 0, moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_DATETIME_NUM_FORMAT_ARGS, ((FFformatarg[]) {
        {FF_FORMAT_ARG_TYPE_UINT16, &result.year}, // 1
        {FF_FORMAT_ARG_TYPE_UINT8, &result.yearShort}, // 2
        {FF_FORMAT_ARG_TYPE_UINT8, &result.month}, // 3
@@ -88,7 +88,7 @@ void ffPrintDateTimeFormat(struct tm* tm, const FFModuleArgs* moduleArgs)
        {FF_FORMAT_ARG_TYPE_STRING, result.secondPretty}, // 20
        {FF_FORMAT_ARG_TYPE_STRING, result.offsetFromUtc}, // 21
        {FF_FORMAT_ARG_TYPE_STRING, result.timezoneName}, // 22
-    });
+    }));
 }

 void ffPrintDateTime(FFDateTimeOptions* options)
@@ -106,7 +106,7 @@ void ffPrintDateTime(FFDateTimeOptions* options)
    char buffer[32];
    if (strftime(buffer, sizeof(buffer), "%F %T", tm) == 0) //yyyy-MM-dd HH:mm:ss
    {
-        ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, "strftime() failed");
+        ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "strftime() failed");
        return;
    }

@@ -138,7 +138,7 @@ void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -157,7 +157,7 @@ void ffGenerateDateTimeJsonResult(FF_MAYBE_UNUSED FFDateTimeOptions* options, yy

 void ffPrintDateTimeHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_DATETIME_MODULE_NAME, "{1}-{4}-{11} {14}:{18}:{20}", FF_DATETIME_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_DATETIME_MODULE_NAME, "{1}-{4}-{11} {14}:{18}:{20}", FF_DATETIME_NUM_FORMAT_ARGS, ((const char* []) {
        "year",
        "last two digits of year",
        "month",
@@ -180,7 +180,7 @@ void ffPrintDateTimeHelpFormat(void)
        "second with leading zero",
        "offset from UTC in the ISO 8601 format",
        "locale-dependent timezone name or abbreviation",
-    });
+    }));
 }

 void ffInitDateTimeOptions(FFDateTimeOptions* options)
@@ -13,7 +13,7 @@ void ffPrintDE(FFDEOptions* options)

    if(result->dePrettyName.length == 0)
    {
-        ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, "No DE found");
+        ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No DE found");
        return;
    }

@@ -36,11 +36,11 @@ void ffPrintDE(FFDEOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_DE_MODULE_NAME, 0, &options->moduleArgs, FF_DE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_DE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_DE_NUM_FORMAT_ARGS, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &result->deProcessName},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result->dePrettyName},
            {FF_FORMAT_ARG_TYPE_STRBUF, &version}
-        });
+        }));
    }
 }

@@ -79,7 +79,7 @@ void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module)
            continue;
        }

-        ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -115,11 +115,11 @@ void ffGenerateDEJsonResult(FF_MAYBE_UNUSED FFDEOptions* options, yyjson_mut_doc

 void ffPrintDEHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_DE_MODULE_NAME, "{2} {3}", FF_DE_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_DE_MODULE_NAME, "{2} {3}", FF_DE_NUM_FORMAT_ARGS, ((const char* []) {
        "DE process name",
        "DE pretty name",
        "DE version"
-    });
+    }));
 }

 void ffInitDEOptions(FFDEOptions* options)
@@ -2,11 +2,12 @@
 #include "common/jsonconfig.h"
 #include "common/parsing.h"
 #include "common/percent.h"
+#include "common/time.h"
 #include "detection/disk/disk.h"
 #include "modules/disk/disk.h"
 #include "util/stringUtils.h"

-#define FF_DISK_NUM_FORMAT_ARGS 11
+#define FF_DISK_NUM_FORMAT_ARGS 12
 #pragma GCC diagnostic ignored "-Wsign-conversion"

 static void printDisk(FFDiskOptions* options, const FFDisk* disk)
@@ -34,11 +35,11 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk)
    }
    else
    {
-        ffParseFormatString(&key, &options->moduleArgs.key, 3, (FFformatarg[]){
+        FF_PARSE_FORMAT_STRING_CHECKED(&key, &options->moduleArgs.key, 3, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &disk->mountpoint},
            {FF_FORMAT_ARG_TYPE_STRBUF, &disk->name},
            {FF_FORMAT_ARG_TYPE_STRBUF, &disk->mountFrom},
-        });
+        }));
    }

    FF_STRBUF_AUTO_DESTROY usedPretty = ffStrbufCreate();
@@ -112,7 +113,8 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk)
        bool isExternal = !!(disk->type & FF_DISK_VOLUME_TYPE_EXTERNAL_BIT);
        bool isHidden = !!(disk->type & FF_DISK_VOLUME_TYPE_HIDDEN_BIT);
        bool isReadOnly = !!(disk->type & FF_DISK_VOLUME_TYPE_READONLY_BIT);
-        ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISK_NUM_FORMAT_ARGS, (FFformatarg[]){
+
+        FF_PRINT_FORMAT_CHECKED(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISK_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &usedPretty},
            {FF_FORMAT_ARG_TYPE_STRBUF, &totalPretty},
            {FF_FORMAT_ARG_TYPE_STRBUF, &bytesPercentageStr},
@@ -124,7 +126,8 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk)
            {FF_FORMAT_ARG_TYPE_STRBUF, &disk->filesystem},
            {FF_FORMAT_ARG_TYPE_STRBUF, &disk->name},
            {FF_FORMAT_ARG_TYPE_BOOL, &isReadOnly},
-        });
+            {FF_FORMAT_ARG_TYPE_STRING, ffTimeToShortStr(disk->createTime)},
+        }));
    }
 }

@@ -139,7 +142,7 @@ static void printMountpoint(FFDiskOptions* options, const FFlist* disks, const c
        }
    }

-    ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "No disk found for mountpoint: %s", mountpoint);
+    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)
@@ -183,7 +186,7 @@ void ffPrintDisk(FFDiskOptions* options)

    if(error)
    {
-        ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
    }
    else
    {
@@ -360,7 +363,7 @@ void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module)
        if (ffPercentParseJsonObject(key, val, &options->percent))
            continue;

-        ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -422,8 +425,16 @@ void ffGenerateDiskJsonResult(FFDiskOptions* options, yyjson_mut_doc* doc, yyjso
        yyjson_mut_obj_add_uint(doc, bytes, "used", item->bytesUsed);

        yyjson_mut_val* files = yyjson_mut_obj_add_obj(doc, obj, "files");
-        yyjson_mut_obj_add_uint(doc, files, "total", item->filesTotal);
-        yyjson_mut_obj_add_uint(doc, files, "used", item->filesUsed);
+        if (item->filesTotal == 0 && item->filesUsed == 0)
+        {
+            yyjson_mut_obj_add_null(doc, files, "total");
+            yyjson_mut_obj_add_null(doc, files, "used");
+        }
+        else
+        {
+            yyjson_mut_obj_add_uint(doc, files, "total", item->filesTotal);
+            yyjson_mut_obj_add_uint(doc, files, "used", item->filesUsed);
+        }

        yyjson_mut_obj_add_strbuf(doc, obj, "filesystem", &item->filesystem);
        yyjson_mut_obj_add_strbuf(doc, obj, "mountpoint", &item->mountpoint);
@@ -440,6 +451,12 @@ void ffGenerateDiskJsonResult(FFDiskOptions* options, yyjson_mut_doc* doc, yyjso
            yyjson_mut_arr_add_str(doc, typeArr, "Hidden");
        if(item->type & FF_DISK_VOLUME_TYPE_READONLY_BIT)
            yyjson_mut_arr_add_str(doc, typeArr, "Read-only");
+
+        const char* pstr = ffTimeToFullStr(item->createTime);
+        if (*pstr)
+            yyjson_mut_obj_add_strcpy(doc, obj, "createTime", pstr);
+        else
+            yyjson_mut_obj_add_null(doc, obj, "createTime");
    }

    FF_LIST_FOR_EACH(FFDisk, item, disks)
@@ -453,7 +470,7 @@ void ffGenerateDiskJsonResult(FFDiskOptions* options, yyjson_mut_doc* doc, yyjso

 void ffPrintDiskHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_DISK_MODULE_NAME, "{1} / {2} ({3}) - {9}", FF_DISK_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_DISK_MODULE_NAME, "{1} / {2} ({3}) - {9}", FF_DISK_NUM_FORMAT_ARGS, ((const char* []) {
        "Size used",
        "Size total",
        "Size percentage",
@@ -462,8 +479,11 @@ void ffPrintDiskHelpFormat(void)
        "Files percentage",
        "True if external volume",
        "True if hidden volume",
-        "Filesystem"
-    });
+        "Filesystem",
+        "Label / name",
+        "True if read-only",
+        "Create time in local timezone",
+    }));
 }

 void ffInitDiskOptions(FFDiskOptions* options)
@@ -22,11 +22,11 @@ static void formatKey(const FFDiskIOOptions* options, FFDiskIOResult* dev, uint3
    else
    {
        ffStrbufClear(key);
-        ffParseFormatString(key, &options->moduleArgs.key, 2, (FFformatarg[]){
+        FF_PARSE_FORMAT_STRING_CHECKED(key, &options->moduleArgs.key, 3, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_UINT, &index},
            {FF_FORMAT_ARG_TYPE_STRBUF, &dev->name},
            {FF_FORMAT_ARG_TYPE_STRBUF, &dev->devPath},
-        });
+        }));
    }
 }

@@ -37,7 +37,7 @@ void ffPrintDiskIO(FFDiskIOOptions* options)

    if(error)
    {
-        ffPrintError(FF_DISKIO_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_DISKIO_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

@@ -74,7 +74,7 @@ void ffPrintDiskIO(FFDiskIOOptions* options)
            ffParseSize(dev->bytesWritten, &buffer2);
            if (!options->detectTotal) ffStrbufAppendS(&buffer, "/s");

-            ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISKIO_NUM_FORMAT_ARGS, (FFformatarg[]){
+            FF_PRINT_FORMAT_CHECKED(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISKIO_NUM_FORMAT_ARGS, ((FFformatarg[]){
                {FF_FORMAT_ARG_TYPE_STRBUF, &buffer},
                {FF_FORMAT_ARG_TYPE_STRBUF, &buffer2},
                {FF_FORMAT_ARG_TYPE_STRBUF, &dev->name},
@@ -83,7 +83,7 @@ void ffPrintDiskIO(FFDiskIOOptions* options)
                {FF_FORMAT_ARG_TYPE_UINT64, &dev->bytesWritten},
                {FF_FORMAT_ARG_TYPE_UINT64, &dev->readCount},
                {FF_FORMAT_ARG_TYPE_UINT64, &dev->writeCount},
-            });
+            }));
        }
        ++index;
    }
@@ -142,7 +142,7 @@ void ffParseDiskIOJsonObject(FFDiskIOOptions* options, yyjson_val* module)
            continue;
        }

-        ffPrintError(FF_DISKIO_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_DISKIO_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -192,7 +192,7 @@ void ffGenerateDiskIOJsonResult(FFDiskIOOptions* options, yyjson_mut_doc* doc, y

 void ffPrintDiskIOHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_DISKIO_MODULE_NAME, "{1} (R) - {2} (W)", FF_DISKIO_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_DISKIO_MODULE_NAME, "{1} (R) - {2} (W)", FF_DISKIO_NUM_FORMAT_ARGS, ((const char* []) {
        "Size of data read [per second] (formatted)",
        "Size of data written [per second] (formatted)",
        "Device name",
@@ -201,7 +201,7 @@ void ffPrintDiskIOHelpFormat(void)
        "Size of data written [per second] (in bytes)",
        "Number of reads",
        "Number of writes",
-    });
+    }));
 }

 void ffInitDiskIOOptions(FFDiskIOOptions* options)
@@ -4,7 +4,7 @@
 #include "modules/display/display.h"
 #include "util/stringUtils.h"

-#define FF_DISPLAY_NUM_FORMAT_ARGS 8
+#define FF_DISPLAY_NUM_FORMAT_ARGS 9

 static int sortByNameAsc(FFDisplayResult* a, FFDisplayResult* b)
 {
@@ -22,7 +22,7 @@ void ffPrintDisplay(FFDisplayOptions* options)

    if(dsResult->displays.length == 0)
    {
-        ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Couldn't detect display");
+        ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Couldn't detect display");
        return;
    }

@@ -89,11 +89,11 @@ void ffPrintDisplay(FFDisplayOptions* options)
        }
        else
        {
-            ffParseFormatString(&key, &options->moduleArgs.key, 3, (FFformatarg[]){
+            FF_PARSE_FORMAT_STRING_CHECKED(&key, &options->moduleArgs.key, 3, ((FFformatarg[]){
                {FF_FORMAT_ARG_TYPE_UINT, &moduleIndex},
                {FF_FORMAT_ARG_TYPE_STRBUF, &result->name},
                {FF_FORMAT_ARG_TYPE_STRING, displayType},
-            });
+            }));
        }

        if(options->moduleArgs.outputFormat.length == 0)
@@ -125,7 +125,7 @@ void ffPrintDisplay(FFDisplayOptions* options)
        }
        else
        {
-            ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISPLAY_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            FF_PRINT_FORMAT_CHECKED(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISPLAY_NUM_FORMAT_ARGS, ((FFformatarg[]) {
                {FF_FORMAT_ARG_TYPE_UINT, &result->width},
                {FF_FORMAT_ARG_TYPE_UINT, &result->height},
                {FF_FORMAT_ARG_TYPE_DOUBLE, &result->refreshRate},
@@ -135,7 +135,7 @@ void ffPrintDisplay(FFDisplayOptions* options)
                {FF_FORMAT_ARG_TYPE_STRING, displayType},
                {FF_FORMAT_ARG_TYPE_UINT, &result->rotation},
                {FF_FORMAT_ARG_TYPE_BOOL, &result->primary},
-            });
+            }));
        }
    }
 }
@@ -205,7 +205,7 @@ void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module)
                {},
            });
            if (error)
-                ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error);
+                ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Invalid %s value: %s", key, error);
            else
                options->compactType = (FFDisplayCompactType) value;
            continue;
@@ -227,13 +227,13 @@ void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module)
                {},
            });
            if (error)
-                ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error);
+                ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Invalid %s value: %s", key, error);
            else
                options->order = (FFDisplayOrder) value;
            continue;
        }

-        ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -309,7 +309,7 @@ void ffGenerateDisplayJsonResult(FF_MAYBE_UNUSED FFDisplayOptions* options, yyjs

 void ffPrintDisplayHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_DISPLAY_MODULE_NAME, "{1}x{2} @ {3}Hz (as {4}x{5}) [{7}]", FF_DISPLAY_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_DISPLAY_MODULE_NAME, "{1}x{2} @ {3}Hz (as {4}x{5}) [{7}]", FF_DISPLAY_NUM_FORMAT_ARGS, ((const char* []) {
        "Screen width (in pixels)",
        "Screen height (in pixels)",
        "Screen refresh rate (in Hz)",
@@ -318,7 +318,8 @@ void ffPrintDisplayHelpFormat(void)
        "Screen name",
        "Screen type (builtin, external or unknown)",
        "Screen rotation (in degrees)",
-    });
+        "True if being the primary screen",
+    }));
 }

 void ffInitDisplayOptions(FFDisplayOptions* options)
@@ -17,7 +17,7 @@ void ffPrintFont(FFFontOptions* options)

    if(error)
    {
-        ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
    }
    else
    {
@@ -28,13 +28,13 @@ void ffPrintFont(FFFontOptions* options)
        }
        else
        {
-            ffPrintFormat(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, FF_FONT_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            FF_PRINT_FORMAT_CHECKED(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_FONT_NUM_FORMAT_ARGS, ((FFformatarg[]) {
                {FF_FORMAT_ARG_TYPE_STRBUF, &font.fonts[0]},
                {FF_FORMAT_ARG_TYPE_STRBUF, &font.fonts[1]},
                {FF_FORMAT_ARG_TYPE_STRBUF, &font.fonts[2]},
                {FF_FORMAT_ARG_TYPE_STRBUF, &font.fonts[3]},
                {FF_FORMAT_ARG_TYPE_STRBUF, &font.display},
-            });
+            }));
        }
    }

@@ -66,7 +66,7 @@ void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -106,13 +106,13 @@ void ffGenerateFontJsonResult(FF_MAYBE_UNUSED FFFontOptions* options, yyjson_mut

 void ffPrintFontHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_FONT_MODULE_NAME, "{5}", FF_FONT_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_FONT_MODULE_NAME, "{5}", FF_FONT_NUM_FORMAT_ARGS, ((const char* []) {
        "Font 1",
        "Font 2",
        "Font 3",
        "Font 4",
        "Combined fonts"
-    });
+    }));
 }

 void ffInitFontOptions(FFFontOptions* options)
@@ -5,7 +5,7 @@
 #include "modules/gamepad/gamepad.h"
 #include "util/stringUtils.h"

-#define FF_GAMEPAD_NUM_FORMAT_ARGS 2
+#define FF_GAMEPAD_NUM_FORMAT_ARGS 3

 static void printDevice(FFGamepadOptions* options, const FFGamepadDevice* device, uint8_t index)
 {
@@ -28,11 +28,11 @@ static void printDevice(FFGamepadOptions* options, const FFGamepadDevice* device
        FF_STRBUF_AUTO_DESTROY percentageStr = ffStrbufCreate();
        ffPercentAppendNum(&percentageStr, device->battery, options->percent, false);

-        ffPrintFormat(FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs, FF_GAMEPAD_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        FF_PRINT_FORMAT_CHECKED(FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_GAMEPAD_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->name},
            {FF_FORMAT_ARG_TYPE_STRBUF, &device->serial},
            {FF_FORMAT_ARG_TYPE_STRBUF, &percentageStr},
-        });
+        }));
    }
 }

@@ -44,13 +44,13 @@ void ffPrintGamepad(FFGamepadOptions* options)

    if(error)
    {
-        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

    if(!result.length)
    {
-        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "No devices detected");
+        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No devices detected");
        return;
    }

@@ -92,7 +92,7 @@ void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module)
        if (ffPercentParseJsonObject(key, val, &options->percent))
            continue;

-        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -141,11 +141,11 @@ void ffGenerateGamepadJsonResult(FF_MAYBE_UNUSED FFGamepadOptions* options, yyjs

 void ffPrintGamepadHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_GAMEPAD_MODULE_NAME, "{1} ({3})", FF_GAMEPAD_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_GAMEPAD_MODULE_NAME, "{1} ({3})", FF_GAMEPAD_NUM_FORMAT_ARGS, ((const char* []) {
        "Name",
        "Serial number",
        "Battery percentage",
-    });
+    }));
 }

 void ffInitGamepadOptions(FFGamepadOptions* options)
@@ -75,7 +75,7 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu
    {
        FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
        ffTempsAppendNum(gpu->temperature, &tempStr, options->tempConfig);
-        ffPrintFormat(FF_GPU_MODULE_NAME, index, &options->moduleArgs, FF_GPU_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_GPU_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_GPU_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->vendor},
            {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->name},
            {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->driver},
@@ -88,7 +88,7 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu
            {FF_FORMAT_ARG_TYPE_UINT64, &gpu->shared.used},
            {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->platformApi},
            {FF_FORMAT_ARG_TYPE_DOUBLE, &gpu->frequency},
-        });
+        }));
    }
 }

@@ -98,7 +98,7 @@ void ffPrintGPU(FFGPUOptions* options)
    const char* error = ffDetectGPU(options, &gpus);
    if (error)
    {
-        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

@@ -120,7 +120,7 @@ void ffPrintGPU(FFGPUOptions* options)
        printGPUResult(options, selectedGPUs.length == 1 ? 0 : (uint8_t) (i + 1), * (const FFGPUResult**) ffListGet(&selectedGPUs, i));

    if(selectedGPUs.length == 0)
-        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "No GPUs found");
+        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No GPUs found");

    FF_LIST_FOR_EACH(FFGPUResult, gpu, gpus)
    {
@@ -206,7 +206,7 @@ void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module)
                {},
            });
            if (error)
-                ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error);
+                ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Invalid %s value: %s", key, error);
            else
                options->hideType = (FFGPUType) value;
            continue;
@@ -215,7 +215,7 @@ void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module)
        if (ffPercentParseJsonObject(key, val, &options->percent))
            continue;

-        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -332,7 +332,7 @@ void ffGenerateGPUJsonResult(FFGPUOptions* options, yyjson_mut_doc* doc, yyjson_

 void ffPrintGPUHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_GPU_MODULE_NAME, "{1} {2}", FF_GPU_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_GPU_MODULE_NAME, "{1} {2}", FF_GPU_NUM_FORMAT_ARGS, ((const char* []) {
        "GPU vendor",
        "GPU name",
        "GPU driver",
@@ -345,7 +345,7 @@ void ffPrintGPUHelpFormat(void)
        "GPU used shared memory",
        "The platform API that GPU supports",
        "Current frequency in GHz",
-    });
+    }));
 }

 void ffInitGPUOptions(FFGPUOptions* options)
@@ -20,13 +20,13 @@ void ffPrintHost(FFHostOptions* options)
    const char* error = ffDetectHost(&host);
    if(error)
    {
-        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        goto exit;
    }

    if(host.family.length == 0 && host.name.length == 0)
    {
-        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "neither product_family nor product_name is set by O.E.M.");
+        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "neither product_family nor product_name is set by O.E.M.");
        goto exit;
    }

@@ -48,7 +48,7 @@ void ffPrintHost(FFHostOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_HOST_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        FF_PRINT_FORMAT_CHECKED(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_HOST_NUM_FORMAT_ARGS, ((FFformatarg[]) {
            {FF_FORMAT_ARG_TYPE_STRBUF, &host.family},
            {FF_FORMAT_ARG_TYPE_STRBUF, &host.name},
            {FF_FORMAT_ARG_TYPE_STRBUF, &host.version},
@@ -56,7 +56,7 @@ void ffPrintHost(FFHostOptions* options)
            {FF_FORMAT_ARG_TYPE_STRBUF, &host.vendor},
            {FF_FORMAT_ARG_TYPE_STRBUF, &host.serial},
            {FF_FORMAT_ARG_TYPE_STRBUF, &host.uuid},
-        });
+        }));
    }

 exit:
@@ -92,7 +92,7 @@ void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -149,7 +149,7 @@ exit:

 void ffPrintHostHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_HOST_MODULE_NAME, "{2} {3}", FF_HOST_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_HOST_MODULE_NAME, "{2} {3}", FF_HOST_NUM_FORMAT_ARGS, ((const char* []) {
        "product family",
        "product name",
        "product version",
@@ -157,7 +157,7 @@ void ffPrintHostHelpFormat(void)
        "product vendor",
        "product serial number",
        "product uuid",
-    });
+    }));
 }

 void ffInitHostOptions(FFHostOptions* options)
@@ -13,7 +13,7 @@ void ffPrintIcons(FFIconsOptions* options)

    if(error)
    {
-        ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

@@ -24,9 +24,9 @@ void ffPrintIcons(FFIconsOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, FF_ICONS_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_ICONS_NUM_FORMAT_ARGS, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &icons}
-        });
+        }));
    }
 }

@@ -53,7 +53,7 @@ void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -81,9 +81,9 @@ void ffGenerateIconsJsonResult(FF_MAYBE_UNUSED FFIconsOptions* options, yyjson_m

 void ffPrintIconsHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_ICONS_MODULE_NAME, "{1}", FF_ICONS_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_ICONS_MODULE_NAME, "{1}", FF_ICONS_NUM_FORMAT_ARGS, ((const char* []) {
        "Combined icons"
-    });
+    }));
 }

 void ffInitIconsOptions(FFIconsOptions* options)
@@ -3,7 +3,7 @@
 #include "modules/kernel/kernel.h"
 #include "util/stringUtils.h"

-#define FF_KERNEL_NUM_FORMAT_ARGS 4
+#define FF_KERNEL_NUM_FORMAT_ARGS 5

 void ffPrintKernel(FFKernelOptions* options)
 {
@@ -20,13 +20,13 @@ void ffPrintKernel(FFKernelOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, FF_KERNEL_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_KERNEL_NUM_FORMAT_ARGS, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &platform->systemName},
            {FF_FORMAT_ARG_TYPE_STRBUF, &platform->systemRelease},
            {FF_FORMAT_ARG_TYPE_STRBUF, &platform->systemVersion},
            {FF_FORMAT_ARG_TYPE_STRBUF, &platform->systemArchitecture},
            {FF_FORMAT_ARG_TYPE_STRBUF, &platform->systemDisplayVersion}
-        });
+        }));
    }
 }

@@ -53,7 +53,7 @@ void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -77,11 +77,13 @@ void ffGenerateKernelJsonResult(FF_MAYBE_UNUSED FFKernelOptions* options, yyjson

 void ffPrintKernelHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_KERNEL_MODULE_NAME, "{2}", FF_KERNEL_NUM_FORMAT_ARGS, (const char* []) {
-        "Kernel sysname",
-        "Kernel release",
-        "Kernel version"
-    });
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_KERNEL_MODULE_NAME, "{2}", FF_KERNEL_NUM_FORMAT_ARGS, ((const char* []) {
+        "Sysname",
+        "Release",
+        "Version",
+        "Architecture",
+        "Display version",
+    }));
 }

 void ffInitKernelOptions(FFKernelOptions* options)
@@ -16,13 +16,13 @@ void ffPrintLM(FFLMOptions* options)

    if(error)
    {
-        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
        return;
    }

    if(result.service.length == 0)
    {
-        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "No LM service found");
+        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No LM service found");
        return;
    }

@@ -38,11 +38,11 @@ void ffPrintLM(FFLMOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_LM_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_LM_NUM_FORMAT_ARGS, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &result.service},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result.type},
            {FF_FORMAT_ARG_TYPE_STRBUF, &result.version},
-        });
+        }));
    }
    ffStrbufDestroy(&result.service);
    ffStrbufDestroy(&result.type);
@@ -72,7 +72,7 @@ void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -117,11 +117,11 @@ exit:

 void ffPrintLMHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_LM_MODULE_NAME, "{1} {3} ({2})", FF_LM_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_LM_MODULE_NAME, "{1} {3} ({2})", FF_LM_NUM_FORMAT_ARGS, ((const char* []) {
        "LM service",
        "LM type",
        "LM version"
-    });
+    }));
 }

 void ffInitLMOptions(FFLMOptions* options)
@@ -13,7 +13,7 @@ void ffPrintLocale(FFLocaleOptions* options)
    ffDetectLocale(&locale);
    if(locale.length == 0)
    {
-        ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "No locale found");
+        ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No locale found");
        return;
    }

@@ -24,9 +24,9 @@ void ffPrintLocale(FFLocaleOptions* options)
    }
    else
    {
-        ffPrintFormat(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        FF_PRINT_FORMAT_CHECKED(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_LOCALE_NUM_FORMAT_ARGS, ((FFformatarg[]){
            {FF_FORMAT_ARG_TYPE_STRBUF, &locale}
-        });
+        }));
    }
 }

@@ -53,7 +53,7 @@ void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module)
        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
            continue;

-        ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+        ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
    }
 }

@@ -81,9 +81,9 @@ void ffGenerateLocaleJsonResult(FF_MAYBE_UNUSED FFLocaleOptions* options, yyjson

 void ffPrintLocaleHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_LOCALE_MODULE_NAME, "{1}", FF_LOCALE_NUM_FORMAT_ARGS, (const char* []) {
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_LOCALE_MODULE_NAME, "{1}", FF_LOCALE_NUM_FORMAT_ARGS, ((const char* []) {
        "Locale code"
-    });
+    }));
 }

 void ffInitLocaleOptions(FFLocaleOptions* options)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Carter Li	6769410753	Merge pull request #794 from fastfetch-cli/dev Release: v2.9.2	2024-04-16 10:45:39 +08:00
李通洲	40b9af6c36	Release: v2.9.2	2024-04-16 10:16:31 +08:00
李通洲	e63dfdd8b1	Packages: fix parsing of JSON config; fix wording of json_schema	2024-04-16 10:16:31 +08:00
李通洲	a6639d7211	JsonSchema: don't generate error at custom options	2024-04-16 09:55:21 +08:00
李通洲	3e251f602a	Packages: fix parsing of option `--packages-disabled`	2024-04-16 09:50:24 +08:00
李通洲	ec25ca9fc7	Shell: ignore `time`	2024-04-15 20:01:40 +08:00
李通洲	396d20f2da	Presets: fix compatibility of newer nerd fonts Fix #792	2024-04-14 22:51:49 +08:00
李通洲	49181fd0bf	Doc: update changelog	2024-04-14 18:03:34 +08:00
李通洲	5eb1dbe7bf	Logo (Builtin): add openSUSE MicroOS Fix #789	2024-04-14 18:02:59 +08:00
Anjia Wang	690e988cab	Logo: fix logo color of AOSC OS (#791 ) Resolve issue: https://github.com/fastfetch-cli/fastfetch/issues/790	2024-04-13 16:44:46 +08:00
Ulices	fd41770d6e	Fix: bad LainOS logo (#788 ) - No need to scape '\' - Replace a tab with spaces	2024-04-13 08:09:51 +08:00
李通洲	fb26cb1394	Disk (Android): fix build Android does support `statx`, but it requires targeting newer ANDROID_API version to be available	2024-04-11 19:49:57 +08:00
李通洲	4e4efa67e6	Doc: update issue templates	2024-04-11 14:47:00 +08:00
李通洲	0dfb1b6bb1	Doc: add code of conduct	2024-04-11 14:10:25 +08:00
李通洲	bcbca38b1e	Terminal: tidy	2024-04-10 10:11:31 +08:00
李通洲	3f0ccf802c	Presets: fix #786 [ci skip]	2024-04-09 22:51:16 +08:00
李通洲	691cb4ac24	Global: use time string when generating JSON result	2024-04-09 20:47:06 +08:00
李通洲	282939f548	Disk (Windows): detect create time	2024-04-09 20:47:06 +08:00
李通洲	6f35b2f382	Disk (Linux): detect create time	2024-04-09 20:47:06 +08:00
李通洲	6700f63091	Disk (macOS): detect create time	2024-04-09 15:15:33 +08:00
李通洲	5c37ebec70	Doc: update changelog	2024-04-09 09:05:10 +08:00
李通洲	28a419d252	fastfetch: always provide trailing new line when generating JSON output	2024-04-09 09:01:28 +08:00
李通洲	95128ee95f	3rdparty (yyjson): upgrade to 0.9.0 To make use of `YYJSON_WRITE_NEWLINE_AT_END`	2024-04-09 08:58:04 +08:00
李通洲	c94180b3d2	Terminal (Windows): ignore `far.exe` Ref: https://github.com/fastfetch-cli/fastfetch/issues/784#issuecomment-2043052512	2024-04-08 23:37:53 +08:00
李通洲	12ca1a0cf7	TerminalFont (Windows): better portable mode detection of Windows Terminal `.portable` can be a folder. Fix #784	2024-04-08 22:29:24 +08:00
apocelipes	67564dfa2c	Platform: fix a memory leak (#782 )	2024-04-08 09:10:03 +08:00
Carter Li	a1e79a9522	Merge pull request #779 from fastfetch-cli/dev Release v2.9.1	2024-04-07 20:49:37 +08:00
李通洲	e16f8ef349	Release: v2.9.1	2024-04-07 20:47:19 +08:00
李通洲	fd1a2072b3	Cursor: tidy	2024-04-07 20:44:17 +08:00
李通洲	aa45e70910	Revert "fastfetch: add the missing new-line in config files (#772 )" Fix #778 This reverts commit `4430b7145e`.	2024-04-07 20:41:01 +08:00
李通洲	5374feb24b	Cursor (Linux): support hyprcursor detection Fix: #776	2024-04-07 20:09:35 +08:00
李通洲	12ac0ac7a9	Cursor: tidy	2024-04-07 20:09:05 +08:00
李通洲	3d78666ed3	Doc: update changelog weston-terminal font detection was not pushed in v2.9.0	2024-04-06 17:37:31 +08:00
Carter Li	dd2cc116bd	TerminalFont (Linux): support weston-terminal	2024-04-06 16:56:17 +08:00
Carter Li	ba2636dc1a	Merge pull request #775 from fastfetch-cli/dev Release: v2.9.0	2024-04-04 12:24:44 +08:00
李通洲	69589f1ad5	Release: v2.9.0	2024-04-04 12:22:52 +08:00
Carter Li	39da11de8e	LocalIP (BSD): fix build	2024-04-04 19:42:33 +08:00
李通洲	8b7a4daeda	TerminalFont: use system mono font if no config file is find	2024-04-04 11:09:28 +08:00
李通洲	82af7a5b52	Doc: update changelog	2024-04-04 10:52:42 +08:00
李通洲	a2d99695fd	LocalIP: add new option `localip-show-prefix-len`	2024-04-04 10:42:44 +08:00
李通洲	3a2786a89f	LocalIP: support network prefix detection for IPv6	2024-04-04 10:19:01 +08:00
李通洲	a6cb30d6c8	LocalIP: print all IPs if multiple IPs are assigned to the same interface	2024-04-04 10:09:06 +08:00
李通洲	de6b1f9542	LocalIP (Linux): fix network prefix detection when the value is greater than 24	2024-04-04 10:08:26 +08:00
李通洲	77431671bb	Packages (Linux): add `am` support Fix: #771	2024-04-03 21:08:55 +08:00
apocelipes	4430b7145e	fastfetch: add the missing new-line in config files (#772 )	2024-04-03 20:02:38 +08:00
kojq	898859cc7a	Flashfetch: add the skipped "host" option from "Flashfetch: simplify implementation" (#770 )	2024-04-02 22:36:20 +08:00
李通洲	43b96df112	Version: detect apple clang	2024-04-02 14:28:25 +08:00
李通洲	bb97893bd0	Doc: update changelog	2024-03-29 14:36:11 +08:00
李通洲	9b21ec6e1f	Terminal (Linux): support weston-terminal version detection	2024-03-28 13:46:11 +08:00
李通洲	ffac354368	Terminal (Linux): support Lxterminal version detection	2024-03-26 19:28:07 +08:00
李通洲	a9aab51764	Doc: update changelog [ci skip]	2024-03-26 09:06:23 +08:00
Carter Li	4d1fc9ceb1	Packaging: update debian stuff	2024-03-25 15:04:24 +08:00
Carter Li	e897a98153	Merge pull request #765 from fastfetch-cli/dev Release v2.8.10	2024-03-25 14:22:43 +08:00
李通洲	0a8056d835	TerminalShell (Windows): adjustments 1. Don't pretty print CMD 2. Print conhost as Windows Console	2024-03-25 14:10:08 +08:00
李通洲	9681e176b3	Terminal (Windows): don't use wininit as terminal	2024-03-25 11:12:30 +08:00
李通洲	1f8be43881	Disk (Windows): use MS-DOS device name as mountFrom result, instead of useless GUID volume name	2024-03-25 10:09:35 +08:00
李通洲	30813551be	Release: v2.8.10	2024-03-25 09:17:03 +08:00
李通洲	beb564f374	CI: try fixing Windows build	2024-03-25 09:17:03 +08:00
李通洲	5c97c012a9	Font (Linux): try fixing style detection	2024-03-24 18:32:50 +08:00
Carter Li	50da7cabd6	GPU (Apple): always use metal to detect vmem	2024-03-23 17:34:09 +08:00
李通洲	a6528cdfd6	Chore: simpify gitignore [ci skip] And make scc happy	2024-03-22 10:09:58 +08:00
李通洲	588201fe46	Windows: update version.rc	2024-03-21 16:26:56 +08:00
李通洲	6184b5ee96	Doc: update changelog	2024-03-21 11:04:53 +08:00
李通洲	5e7baa9d0a	PublicIP: error out if non-http protocol is specified	2024-03-21 11:01:23 +08:00
李通洲	79ae650c58	Networking: avoid short recv	2024-03-21 10:42:25 +08:00
李通洲	44107f289e	Network (Windows): fix compiling	2024-03-20 16:09:17 +08:00
李通洲	75927a87b2	Networking: add timeout support for TCP connecting	2024-03-20 15:04:29 +08:00
李通洲	85da30ccf5	Networking: report detailed error messages; support `--thread false` for debugging	2024-03-20 13:54:27 +08:00
李通洲	f73c3b85c2	Doc: update changelog	2024-03-19 21:18:25 +08:00
李通洲	66bef2fc19	Network: trim trailing white spaces	2024-03-19 21:18:25 +08:00
李通洲	7c5eb021ee	Terminal (Linux): ignore `chezmoi` Fix #762	2024-03-18 09:03:10 +08:00
李通洲	f902e3b3d8	CPU (Android): don't detect manufactor of Qualcomm as ARM	2024-03-17 19:19:33 +08:00
李通洲	553124ab5b	Presets: a new example Ref: #761	2024-03-16 22:25:35 +08:00
李通洲	6c6d93370d	Logo: fix colors of arco linux Fix #759	2024-03-15 20:32:29 +08:00
Carter Li	55ae3a7dbd	CPU (FreeBSD): don't display 0.00 GHz	2024-03-15 11:15:23 +08:00
Carter Li	586874080f	Packaging: update debian stuff	2024-03-15 10:51:53 +08:00
Carter Li	d5b91a8983	Merge pull request #758 from fastfetch-cli/dev Release: v2.8.9	2024-03-15 09:50:54 +08:00
李通洲	72fee13112	Release: v2.8.9	2024-03-15 09:21:13 +08:00
李通洲	20ae897f39	fastfetch: remove unused `#include`s	2024-03-15 08:37:58 +08:00
李通洲	6f756d103f	Doc: update changelog	2024-03-14 20:43:17 +08:00
李通洲	c9dd858ce3	CPU (Linux): bing cpuMHz back It's used in WSL	2024-03-14 20:40:40 +08:00
李通洲	2e201eaaf7	CPU: bring min frequency back & code optimizations	2024-03-14 19:24:03 +08:00
李通洲	7c54dcba69	CPU (Linux): fix detection when `.../base_frequency` doesn't exist	2024-03-14 10:32:34 +08:00
李通洲	a107395707	Logo (Chafa): fix blurry result when specifying both width and height Who knows why it was coded like that Fix #757	2024-03-14 10:18:17 +08:00
李通洲	8a9fe22855	Logo: fix proxmox Fix #756	2024-03-13 23:58:40 +08:00
李通洲	7e04e23528	CPU: rename min frequency to base frequency	2024-03-13 23:42:59 +08:00
李通洲	8d779f68f3	CPU: detect base frequency	2024-03-13 23:41:11 +08:00
李通洲	98ba08c1a0	CI (macOS): fix build	2024-03-13 10:37:45 +08:00
李通洲	a1499b82f8	Doc: update changelog	2024-03-13 08:44:09 +08:00
李通洲	c6c866d78a	Host (Apple): add MacBook Air 2024	2024-03-12 18:27:02 +08:00
李通洲	7a6999bd20	Fastfetch: print final new line in `--format json`	2024-03-09 12:07:07 +08:00
李通洲	1084cf3523	Terminal (Linux): actually ignore `SessionLeader`	2024-03-09 11:52:31 +08:00
Carter Li	ed5f2a3968	Chore: update screenshots	2024-03-08 15:58:47 +08:00
Carter Li	17e1d4b72d	Package: update debian stuff	2024-03-08 10:03:31 +08:00
Carter Li	912f6c4f3c	Merge pull request #752 from fastfetch-cli/dev Release: v2.8.8	2024-03-08 09:54:06 +08:00
李通洲	77d71b5fef	Doc: update changelog	2024-03-08 09:36:35 +08:00
Carter Li	6938a73a8a	Users (Linux): fix detection of client ip	2024-03-08 09:17:40 +08:00
李通洲	cee9df189d	Release: v2.8.8	2024-03-08 08:40:40 +08:00
李通洲	2a125e226b	Terminal (Linux): ignore `SessionLeader` I don't know why it's there, but let's ignore it for now	2024-03-07 22:38:03 +08:00
李通洲	4a7e60ef57	CPU (Linux): don't crash if `/sys/devices/system/cpu/cpufreq/` doesn't exist Ref: #750	2024-03-07 21:31:23 +08:00
李通洲	0a6140346e	DisplayServer (Linux): fix old libdrm version compatibility Ref: #748	2024-03-07 19:20:56 +08:00
Carter Li	01862ebc04	Display (Linux): fix width being detected as height when using libdrm	2024-03-07 14:39:13 +08:00
李通洲	3185299214	Doc: update changelog	2024-03-07 14:00:57 +08:00
李通洲	5b6ebe4f11	Doc: update README	2024-03-07 13:56:40 +08:00
李通洲	6274ef591b	Vulkan: try fixing old vulkan-header library compatibility Ref: #748	2024-03-07 13:34:31 +08:00
李通洲	7acdaebee4	Printing: merge `ffPrintError` and `ffPrintErrorString`	2024-03-07 11:10:18 +08:00
李通洲	6dcfb6b88f	Fastfetch: fully resolve the format arg num issue Ref: #749	2024-03-07 10:47:28 +08:00
李通洲	064972aecd	Disk: fix segfault with `--help disk-format` Fix #749	2024-03-07 09:04:22 +08:00