Merge pull request #701 from fastfetch-cli/dev

Release v2.7.0

.github/ISSUE_TEMPLATE/bug_report.md

@@ -19,7 +19,10 @@ assignees: ''
 
 # Often helpful information:
 
-The content of the configuration file you use (if any)
+Screenshot:
+<!-- Paste the screenshot here -->
+
+The content of the configuration file you use (if any):
 ```
 //paste here
 ```

.github/workflows/ci.yml

@@ -402,6 +402,9 @@ jobs:
           echo -e "\n---\n\n<details><summary>SHA256SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
           sha256sum fastfetch-*/* >> fastfetch-release-notes.md
           echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
+          echo -e "\n<details><summary>SHA512SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
+          sha512sum fastfetch-*/* >> fastfetch-release-notes.md
+          echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
 
       - name: update release body
         if: needs.linux.outputs.ffversion != steps.get_version_release.outputs.release

CHANGELOG.md

@@ -1,3 +1,49 @@
+# 2.7.0
+
+Features:
+* Add new module `TerminalTheme`, which prints the foreground and background color of the current terminal window. Currently doesn't work on Windows.
+* Allow command substitution when expanding paths. For example, now it's possible to use `"source": "$(ls ~/path/to/images/*.png | shuf -n 1)"` in JSONC config file to randomly choose an image to display. (#698)
+* Use native methods instead of pciutils to detect GPUs in FreeBSD. (GPU, FreeBSD)
+
+Bugfixes:
+* Fix text formatting (Wifi, Linux)
+* Fix terminal detection in some cases (Terminal)
+* Remove trailing `\0` in JSON results (FreeBSD)
+* Fix uninitialized variables (GPU, Linux)
+* Fix a possible segfault (OpenCL)
+
+Logo:
+* Add ASCII logos for fedora immutable variants (#700)
+
+# 2.6.3
+
+Bugfixes:
+* Fix module not working (Bluetooth)
+
+# 2.6.2
+
+Bugfixes:
+* Fix building for GCC in Windows (Windows)
+
+# 2.6.1
+
+Features:
+* Improve xonsh shell detection (Shell)
+* Support colored percentage values (Bluetooth / Gamepad / Sound)
+* Add `--<module>-percent-[green|yellow]` options to specify threshold of percentage colors
+    * eg. `--disk-percent-green 20 --disk-percent-yellow 50` will show green if disk usage is less than 20%, yellow if disk usage is less then 50%, and red otherwise.
+* Add `--percent-color-[green|yellow|red]` options to specify color of different percent value states.
+    * eg. `--percent-color-green blue` will show blue color if percent value falls in green state.
+* Improve Intel macbook support (macOS)
+
+Bugfixes:
+* Fix segfault in CPU module when running in aarch64 machine without `lscpu` installed (CPU, Linux)
+* Don't use `login` as terminal process (Terminal, Linux)
+* Silence warnings when building in 32bit machines.
+* Create sub folders when writing config file (#690)
+* Improve user specific locale detection; fix locale detection in Windows 7 (Locale)
+* Fix GPU type detection (GPU, macOS)
+
 # 2.6.0
 
 Changes:

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url
 
 project(fastfetch
-    VERSION 2.6.0
+    VERSION 2.7.0
     LANGUAGES C
     DESCRIPTION "Fast neofetch-like system information tool"
     HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -265,7 +265,7 @@ file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}")
 #######################
 
 set(LIBFASTFETCH_SRC
-    src/common/bar.c
+    src/common/percent.c
     src/common/commandoption.c
     src/common/font.c
     src/common/format.c
@@ -293,6 +293,7 @@ set(LIBFASTFETCH_SRC
     src/detection/os/os.c
     src/detection/packages/packages.c
     src/detection/publicip/publicip.c
+    src/detection/terminaltheme/terminaltheme.c
     src/detection/terminalfont/terminalfont.c
     src/detection/terminalshell/terminalshell.c
     src/detection/version/version.c
@@ -348,6 +349,7 @@ set(LIBFASTFETCH_SRC
     src/modules/swap/swap.c
     src/modules/media/media.c
     src/modules/terminal/terminal.c
+    src/modules/terminaltheme/terminaltheme.c
     src/modules/terminalfont/terminalfont.c
     src/modules/terminalsize/terminalsize.c
     src/modules/theme/theme.c
@@ -514,7 +516,7 @@ elseif(BSD)
         src/detection/displayserver/linux/xcb.c
         src/detection/displayserver/linux/xlib.c
         src/detection/font/font_linux.c
-        src/detection/gpu/gpu_linux.c
+        src/detection/gpu/gpu_bsd.c
         src/detection/gtk_qt/gtk.c
         src/detection/host/host_bsd.c
         src/detection/lm/lm_linux.c

doc/json_schema.json

@@ -26,6 +26,24 @@
         "format": {
             "description": "Output format of the module",
             "type": "string"
+        },
+        "percent": {
+            "description": "Threshold of percentage colors",
+            "type": "object",
+            "properties": {
+                "green": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 100,
+                    "description": "Value less then green will be shown in green"
+                },
+                "yellow": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 100,
+                    "description": "Value greater than green and less then yellow will be shown in yellow.\nValue greater than yellow will be shown in red"
+                }
+            }
         }
     },
     "type": "object",
@@ -439,6 +457,24 @@
                             "minimum": 0,
                             "maximum": 9,
                             "default": 0
+                        },
+                        "color": {
+                            "type": "object",
+                            "description": "Set color used in different states of percentage bars and numbers",
+                            "properties": {
+                                "green": {
+                                    "description": "Color used in green state",
+                                    "$ref": "#/$defs/colors"
+                                },
+                                "yellow": {
+                                    "description": "Color used in yellow state",
+                                    "$ref": "#/$defs/colors"
+                                },
+                                "red": {
+                                    "description": "Color used in red state",
+                                    "$ref": "#/$defs/colors"
+                                }
+                            }
                         }
                     }
                 },
@@ -612,6 +648,7 @@
                             "terminal",
                             "terminalfont",
                             "terminalsize",
+                            "terminaltheme",
                             "title",
                             "theme",
                             "uptime",
@@ -672,10 +709,6 @@
                                                 "const": "font",
                                                 "description": "Print system font name"
                                             },
-                                            {
-                                                "const": "gamepad",
-                                                "description": "List connected gamepads"
-                                            },
                                             {
                                                 "const": "host",
                                                 "description": "Print product name of your computer"
@@ -700,10 +733,6 @@
                                                 "const": "media",
                                                 "description": "Print playing song name"
                                             },
-                                            {
-                                                "const": "memory",
-                                                "description": "Print system memory usage info"
-                                            },
                                             {
                                                 "const": "monitor",
                                                 "description": "Print connected physical monitor information"
@@ -732,10 +761,6 @@
                                                 "const": "shell",
                                                 "description": "Print current shell name and version"
                                             },
-                                            {
-                                                "const": "swap",
-                                                "description": "Print swap (paging file) space usage"
-                                            },
                                             {
                                                 "const": "terminal",
                                                 "description": "Print current terminal name and version"
@@ -748,6 +773,10 @@
                                                 "const": "terminalsize",
                                                 "description": "Print current terminal size"
                                             },
+                                            {
+                                                "const": "terminaltheme",
+                                                "description": "Print current terminal theme (foreground and background colors)"
+                                            },
                                             {
                                                 "const": "theme",
                                                 "description": "Print current theme of desktop environment"
@@ -814,6 +843,9 @@
                                         "type": "boolean",
                                         "default": false
                                     },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
                                     "key": {
                                         "$ref": "#/$defs/key"
                                     },
@@ -841,6 +873,9 @@
                                         "type": "boolean",
                                         "default": false
                                     },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
                                     "key": {
                                         "$ref": "#/$defs/key"
                                     },
@@ -863,6 +898,9 @@
                                         "const": "brightness",
                                         "description": "Print current brightness level of your monitors"
                                     },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
                                     "ddcciSleep": {
                                         "type": "integer",
                                         "description": "Set the sleep times (in ms) when sending DDC/CI requests.\nSee <https://www.ddcutil.com/performance_options/#option-sleep-multiplier> for detail",
@@ -934,6 +972,9 @@
                                         "const": "cpuusage",
                                         "description": "Print CPU usage. Costs some time to collect data"
                                     },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
                                     "separate": {
                                         "type": "boolean",
                                         "description": "Display CPU usage per CPU logical core, instead of an average result",
@@ -1103,6 +1144,9 @@
                                         "description": "Use f_bavail (lpFreeBytesAvailableToCaller for Windows) instead of f_bfree to calculate used bytes",
                                         "default": false
                                     },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
                                     "key": {
                                         "$ref": "#/$defs/key"
                                     },
@@ -1170,6 +1214,31 @@
                                     }
                                 }
                             },
+                            {
+                                "title": "Gamepad",
+                                "properties": {
+                                    "type": {
+                                        "const": "gamepad",
+                                        "description": "List connected gamepads"
+                                    },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
+                                    },
+                                    "keyColor": {
+                                        "$ref": "#/$defs/keyColor"
+                                    },
+                                    "keyWidth": {
+                                        "$ref": "#/$defs/keyWidth"
+                                    },
+                                    "format": {
+                                        "$ref": "#/$defs/format"
+                                    }
+                                },
+                                "additionalProperties": false
+                            },
                             {
                                 "title": "GPU",
                                 "properties": {
@@ -1272,6 +1341,31 @@
                                 },
                                 "additionalProperties": false
                             },
+                            {
+                                "title": "Memory",
+                                "properties": {
+                                    "type": {
+                                        "const": "memory",
+                                        "description": "Print system memory usage info"
+                                    },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
+                                    },
+                                    "keyColor": {
+                                        "$ref": "#/$defs/keyColor"
+                                    },
+                                    "keyWidth": {
+                                        "$ref": "#/$defs/keyWidth"
+                                    },
+                                    "format": {
+                                        "$ref": "#/$defs/format"
+                                    }
+                                },
+                                "additionalProperties": false
+                            },
                             {
                                 "title": "NetIO",
                                 "properties": {
@@ -1458,6 +1552,34 @@
                                         ],
                                         "default": "main"
                                     },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
+                                    "key": {
+                                        "$ref": "#/$defs/key"
+                                    },
+                                    "keyColor": {
+                                        "$ref": "#/$defs/keyColor"
+                                    },
+                                    "keyWidth": {
+                                        "$ref": "#/$defs/keyWidth"
+                                    },
+                                    "format": {
+                                        "$ref": "#/$defs/format"
+                                    }
+                                },
+                                "additionalProperties": false
+                            },
+                            {
+                                "title": "Swap",
+                                "properties": {
+                                    "type": {
+                                        "const": "swap",
+                                        "description": "Print swap (paging file) space usage"
+                                    },
+                                    "percent": {
+                                        "$ref": "#/$defs/percent"
+                                    },
                                     "key": {
                                         "$ref": "#/$defs/key"
                                     },

presets/all.jsonc

@@ -28,6 +28,7 @@
         "terminal",
         "terminalfont",
         "terminalsize",
+        "terminaltheme",
         "cpu",
         "cpuusage",
         "gpu",

presets/ci.jsonc

@@ -34,6 +34,7 @@
     "terminal",
     "terminalfont",
     "terminalsize",
+    "terminaltheme",
     "cpu",
     "cpuusage",
     "gpu",

src/common/bar.c

@@ -1,111 +0,0 @@
-#include "common/bar.h"
-#include "common/color.h"
-#include "util/textModifier.h"
-
-void ffAppendPercentBar(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, uint8_t red)
-{
-    assert(green <= 100 && yellow <= 100 && red <= 100);
-
-    const FFOptionsDisplay* options = &instance.config.display;
-
-    uint32_t blocksPercent = (uint32_t) (percent / 100.0 * options->barWidth + 0.5);
-    uint32_t blocksGreen = (uint32_t) (green / 100.0 * options->barWidth + 0.5);
-    uint32_t blocksYellow = (uint32_t) (yellow / 100.0 * options->barWidth + 0.5);
-    uint32_t blocksRed = (uint32_t) (red / 100.0 * options->barWidth + 0.5);
-    assert(blocksPercent <= options->barWidth);
-
-    if(options->barBorder)
-    {
-        if(!options->pipe)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m[ ");
-        else
-            ffStrbufAppendS(buffer, "[ ");
-    }
-
-    for (uint32_t i = 0; i < blocksPercent; ++i)
-    {
-        if(!options->pipe)
-        {
-            if (i == blocksGreen)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m");
-            else if (i == blocksYellow)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m");
-            else if (i == blocksRed)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m");
-        }
-        ffStrbufAppend(buffer, &options->barCharElapsed);
-    }
-
-    if (blocksPercent < options->barWidth)
-    {
-        if(!options->pipe)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
-        for (uint32_t i = blocksPercent; i < options->barWidth; ++i)
-            ffStrbufAppend(buffer, &options->barCharTotal);
-    }
-
-    if(options->barBorder)
-    {
-        if(!options->pipe)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m ]");
-        else
-            ffStrbufAppendS(buffer, " ]");
-    }
-
-    if(!options->pipe)
-        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
-}
-
-// if (green < yellow)
-// [0, green]: print green
-// (green, yellow]: print yellow
-// (yellow, 100]: print red
-//
-// if (green > yellow)
-// [green, 100]: print green
-// [yellow, green): print yellow
-// [0, yellow): PRINT RED
-void ffAppendPercentNum(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, bool parentheses)
-{
-    assert(green <= 100 && yellow <= 100);
-
-    const FFOptionsDisplay* options = &instance.config.display;
-
-    bool colored = !!(options->percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
-
-    if (parentheses)
-        ffStrbufAppendC(buffer, '(');
-
-    if (colored && !options->pipe)
-    {
-        if(percent != percent)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_BLACK "m");
-        else if(green < yellow)
-        {
-            if (percent <= green)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m");
-            else if (percent <= yellow)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m");
-            else
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m");
-        }
-        else
-        {
-            if (percent >= green)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m");
-            else if (percent >= yellow)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m");
-            else
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m");
-        }
-    }
-    ffStrbufAppendF(buffer, "%.*f%%", options->percentNdigits, percent);
-
-    if (colored && !options->pipe)
-    {
-        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
-    }
-
-    if (parentheses)
-        ffStrbufAppendC(buffer, ')');
-}

src/common/bar.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include "fastfetch.h"
-
-enum
-{
-    FF_PERCENTAGE_TYPE_NUM_BIT = 1 << 0,
-    FF_PERCENTAGE_TYPE_BAR_BIT = 1 << 1,
-    FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT = 1 << 2,
-    FF_PERCENTAGE_TYPE_NUM_COLOR_BIT = 1 << 3,
-};
-
-void ffAppendPercentBar(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, uint8_t red);
-void ffAppendPercentNum(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, bool parentheses);

src/common/format.c

@@ -57,7 +57,7 @@ static inline uint32_t getArgumentIndex(const FFstrbuf* placeholderValue)
     uint32_t result = UINT32_MAX;
 
     if(placeholderValue->chars[0] != '-')
-        sscanf(placeholderValue->chars, "%u", &result);
+        sscanf(placeholderValue->chars, "%" PRIu32, &result);
 
     return result == 0 ? UINT32_MAX : result;
 }

src/common/io/io_unix.c

@@ -115,7 +115,7 @@ bool ffPathExpandEnv(FF_MAYBE_UNUSED const char* in, FF_MAYBE_UNUSED FFstrbuf* o
     #if __has_include(<wordexp.h>) // https://github.com/termux/termux-packages/pull/7056
 
     wordexp_t exp;
-    if(wordexp(in, &exp, WRDE_NOCMD) != 0)
+    if(wordexp(in, &exp, 0) != 0)
         return false;
 
     if (exp.we_wordc == 1)

src/common/modules.c

@@ -124,6 +124,7 @@ static FFModuleBaseInfo* T[] = {
     (void*) &instance.config.modules.terminal,
     (void*) &instance.config.modules.terminalFont,
     (void*) &instance.config.modules.terminalSize,
+    (void*) &instance.config.modules.terminalTheme,
     (void*) &instance.config.modules.title,
     (void*) &instance.config.modules.theme,
     NULL,

src/common/option.c

@@ -143,7 +143,7 @@ void ffOptionParseColor(const char* value, FFstrbuf* buffer)
     while(*value != '\0')
     {
         #define FF_APPEND_COLOR_CODE_COND(prefix, code) \
-            if(strncasecmp(value, #prefix, strlen(#prefix)) == 0) { ffStrbufAppendS(buffer, code); value += strlen(#prefix); }
+            if(ffStrStartsWithIgnCase(value, #prefix)) { ffStrbufAppendS(buffer, code); value += strlen(#prefix); }
 
         FF_APPEND_COLOR_CODE_COND(reset_, FF_COLOR_MODE_RESET)
         else FF_APPEND_COLOR_CODE_COND(bright_, FF_COLOR_MODE_BOLD)

src/common/percent.c

@@ -0,0 +1,211 @@
+#include "fastfetch.h"
+#include "common/percent.h"
+#include "common/color.h"
+#include "common/option.h"
+#include "common/jsonconfig.h"
+#include "util/textModifier.h"
+#include "util/stringUtils.h"
+
+void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFPercentConfig config)
+{
+    uint8_t green = config.green, yellow = config.yellow;
+    assert(green <= 100 && yellow <= 100);
+
+    const FFOptionsDisplay* options = &instance.config.display;
+
+    uint32_t blocksPercent = (uint32_t) (percent / 100.0 * options->barWidth + 0.5);
+    assert(blocksPercent <= options->barWidth);
+
+    if(options->barBorder)
+    {
+        if(!options->pipe)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m[ ");
+        else
+            ffStrbufAppendS(buffer, "[ ");
+    }
+
+    if (percent != percent)
+    {
+        if(!options->pipe)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_BLACK "m");
+
+        for (uint32_t i = 0; i < options->barWidth; ++i)
+            ffStrbufAppend(buffer, &options->barCharElapsed);
+    }
+    else
+    {
+        const char* colorGreen = instance.config.display.percentColorGreen.chars;
+        const char* colorYellow = instance.config.display.percentColorYellow.chars;
+        const char* colorRed = instance.config.display.percentColorRed.chars;
+
+        for (uint32_t i = 0; i < blocksPercent; ++i)
+        {
+            if(!options->pipe)
+            {
+                uint32_t section1Begin = (uint32_t) ((green <= yellow ? green : yellow) / 100.0 * options->barWidth + 0.5);
+                uint32_t section2Begin = (uint32_t) ((green > yellow ? green : yellow) / 100.0 * options->barWidth + 0.5);
+                if (i == section2Begin)
+                    ffStrbufAppendF(buffer, "\e[%sm", (green > yellow ? colorGreen : colorRed));
+                else if (i == section1Begin)
+                    ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
+                else if (i == 0)
+                    ffStrbufAppendF(buffer, "\e[%sm", (green <= yellow ? colorGreen : colorRed));
+            }
+            ffStrbufAppend(buffer, &options->barCharElapsed);
+        }
+
+        if (blocksPercent < options->barWidth)
+        {
+            if(!options->pipe)
+                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
+            for (uint32_t i = blocksPercent; i < options->barWidth; ++i)
+                ffStrbufAppend(buffer, &options->barCharTotal);
+        }
+    }
+
+    if(options->barBorder)
+    {
+        if(!options->pipe)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m ]");
+        else
+            ffStrbufAppendS(buffer, " ]");
+    }
+
+    if(!options->pipe)
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+}
+
+void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentConfig config, bool parentheses)
+{
+    uint8_t green = config.green, yellow = config.yellow;
+    assert(green <= 100 && yellow <= 100);
+
+    const FFOptionsDisplay* options = &instance.config.display;
+
+    bool colored = !!(options->percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
+
+    if (parentheses)
+        ffStrbufAppendC(buffer, '(');
+
+    if (colored && !options->pipe)
+    {
+        const char* colorGreen = instance.config.display.percentColorGreen.chars;
+        const char* colorYellow = instance.config.display.percentColorYellow.chars;
+        const char* colorRed = instance.config.display.percentColorRed.chars;
+
+        if(percent != percent)
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_BLACK "m");
+        else if(green <= yellow)
+        {
+            if (percent > yellow)
+                ffStrbufAppendF(buffer, "\e[%sm", colorRed);
+            else if (percent > green)
+                ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
+            else
+                ffStrbufAppendF(buffer, "\e[%sm", colorGreen);
+
+        }
+        else
+        {
+            if (percent < yellow)
+                ffStrbufAppendF(buffer, "\e[%sm", colorRed);
+            else if (percent < green)
+                ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
+            else
+                ffStrbufAppendF(buffer, "\e[%sm", colorGreen);
+        }
+    }
+    ffStrbufAppendF(buffer, "%.*f%%", options->percentNdigits, percent);
+
+    if (colored && !options->pipe)
+    {
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+    }
+
+    if (parentheses)
+        ffStrbufAppendC(buffer, ')');
+}
+
+bool ffPercentParseCommandOptions(const char* key, const char* subkey, const char* value, FFPercentConfig* config)
+{
+    if (!ffStrStartsWithIgnCase(subkey, "percent-"))
+        return false;
+
+    subkey += strlen("percent-");
+
+    if (ffStrEqualsIgnCase(subkey, "green"))
+    {
+        uint32_t num = ffOptionParseUInt32(key, value);
+        if (num > 100)
+        {
+            fprintf(stderr, "Error: usage: %s must be between 0 and 100\n", key);
+            exit(480);
+        }
+        config->green = (uint8_t) num;
+        return true;
+    }
+
+    if (ffStrEqualsIgnCase(subkey, "yellow"))
+    {
+        uint32_t num = ffOptionParseUInt32(key, value);
+        if (num > 100)
+        {
+            fprintf(stderr, "Error: usage: %s must be between 0 and 100\n", key);
+            exit(480);
+        }
+        config->yellow = (uint8_t) num;
+        return true;
+    }
+
+    return false;
+}
+
+bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFPercentConfig* config)
+{
+    if (!ffStrEqualsIgnCase(key, "percent"))
+        return false;
+
+    if (!yyjson_is_obj(value))
+    {
+        fprintf(stderr, "Error: usage: %s must be an object\n", key);
+        exit(480);
+    }
+
+    yyjson_val* greenVal = yyjson_obj_get(value, "green");
+    if (greenVal)
+    {
+        int num = yyjson_get_int(greenVal);
+        if (num < 0 || num > 100)
+        {
+            fputs("Error: usage: percent.green must be between 0 and 100\n", stderr);
+            exit(480);
+        }
+        config->green = (uint8_t) num;
+    }
+
+    yyjson_val* yellowVal = yyjson_obj_get(value, "yellow");
+    if (yellowVal)
+    {
+        int num = yyjson_get_int(yellowVal);
+        if (num < 0 || num > 100)
+        {
+            fputs("Error: usage: percent.yellow must be between 0 and 100\n", stderr);
+            exit(480);
+        }
+        config->yellow = (uint8_t) num;
+    }
+
+    return true;
+}
+
+void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFPercentConfig defaultConfig, FFPercentConfig config)
+{
+    if (config.green == defaultConfig.green && config.yellow == defaultConfig.yellow)
+        return;
+
+    yyjson_mut_val* percent = yyjson_mut_obj_add_obj(doc, module, "percent");
+    if (config.green != defaultConfig.green)
+        yyjson_mut_obj_add_uint(doc, percent, "green", config.green);
+    if (config.yellow != defaultConfig.yellow)
+        yyjson_mut_obj_add_uint(doc, percent, "yellow", config.yellow);
+}

src/common/percent.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "util/FFstrbuf.h"
+
+enum
+{
+    FF_PERCENTAGE_TYPE_NUM_BIT = 1 << 0,
+    FF_PERCENTAGE_TYPE_BAR_BIT = 1 << 1,
+    FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT = 1 << 2,
+    FF_PERCENTAGE_TYPE_NUM_COLOR_BIT = 1 << 3,
+};
+
+typedef struct FFPercentConfig
+{
+    uint8_t green;
+    uint8_t yellow;
+} FFPercentConfig;
+
+// if (green <= yellow)
+// [0, green]: print green
+// (green, yellow]: print yellow
+// (yellow, 100]: print red
+//
+// if (green > yellow)
+// [green, 100]: print green
+// [yellow, green): print yellow
+// [0, yellow): print red
+
+void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFPercentConfig config);
+void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentConfig config, bool parentheses);
+
+typedef struct yyjson_val yyjson_val;
+typedef struct yyjson_mut_doc yyjson_mut_doc;
+typedef struct yyjson_mut_val yyjson_mut_val;
+bool ffPercentParseCommandOptions(const char* key, const char* subkey, const char* value, FFPercentConfig* config);
+bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFPercentConfig* config);
+void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFPercentConfig defaultConfig, FFPercentConfig config);

src/common/processing_linux.c

@@ -13,13 +13,6 @@
 
 enum { FF_PIPE_BUFSIZ = 8192 };
 
-static inline void waitpid_wrapper(const pid_t* pid)
-{
-    // remove zombie processes
-    if (*pid > 0)
-        waitpid(*pid, NULL, 0);
-}
-
 static inline int ffPipe2(int *fds, int flags)
 {
     #ifdef __APPLE__
@@ -41,7 +34,7 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
     if(ffPipe2(pipes, O_CLOEXEC) == -1)
         return "pipe() failed";
 
-    __attribute__((__cleanup__(waitpid_wrapper))) pid_t childPid = fork();
+    pid_t childPid = fork();
     if(childPid == -1)
     {
         close(pipes[0]);
@@ -74,11 +67,13 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
             if (poll(&pollfd, 1, timeout) == 0)
             {
                 kill(childPid, SIGTERM);
+                waitpid(childPid, NULL, 0);
                 return "poll(&pollfd, 1, timeout) timeout";
             }
             else if (pollfd.revents & POLLERR)
             {
                 kill(childPid, SIGTERM);
+                waitpid(childPid, NULL, 0);
                 return "poll(&pollfd, 1, timeout) error";
             }
         }
@@ -87,7 +82,19 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
         if (nRead > 0)
             ffStrbufAppendNS(buffer, (uint32_t) nRead, str);
         else if (nRead == 0)
-            return NULL;
+        {
+            int stat_loc = 0;
+            if (waitpid(childPid, &stat_loc, 0) == childPid)
+            {
+                if (!WIFEXITED(stat_loc))
+                    return "child process exited abnormally";
+                if (WEXITSTATUS(stat_loc) == 127)
+                    return "command was not found";
+                // We only handle 127 as an error. See `getTerminalVersionUrxvt` in `terminalshell.c`
+                return NULL;
+            }
+            return "waitpid() failed";
+        }
         else if (nRead < 0)
             break;
     };

src/common/time.h

@@ -42,6 +42,6 @@ static inline void ffTimeSleep(uint32_t msec)
     #ifdef _WIN32
         SleepEx(msec, TRUE);
     #else
-        nanosleep(&(struct timespec){ msec / 1000, (msec % 1000) * 1000000 }, NULL);
+        nanosleep(&(struct timespec){ msec / 1000, (long) (msec % 1000) * 1000000 }, NULL);
     #endif
 }

src/data/help.json

@@ -198,6 +198,7 @@
         {
             "long": "logo-color-[1-9]",
             "desc": "Overwrite a color in the logo",
+            "remark": "See `-h color` for the list of available colors",
             "arg": {
                 "type": "color"
             },
@@ -432,6 +433,7 @@
         {
             "long": "color-keys",
             "desc": "Set the color of the keys",
+            "remark": "See `-h color` for the list of available colors",
             "arg": {
                 "type": "color"
             }
@@ -439,6 +441,7 @@
         {
             "long": "color-title",
             "desc": "Set the color of the title",
+            "remark": "See `-h color` for the list of available colors",
             "arg": {
                 "type": "color"
             }
@@ -548,6 +551,33 @@
                 "default": 0
             }
         },
+        {
+            "long": "percent-color-green",
+            "desc": "Set color used in green state of percentage bars and numbers",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "green"
+            }
+        },
+        {
+            "long": "percent-color-yellow",
+            "desc": "Set color used in yellow state of percentage bars and numbers",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "light_yellow"
+            }
+        },
+        {
+            "long": "percent-color-red",
+            "desc": "Set color used in red state of percentage bars and numbers",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "light_red"
+            }
+        },
         {
             "long": "bar-char-elapsed",
             "desc": "Set the character to use in elapsed part of percentage bars",
@@ -821,6 +851,7 @@
         {
             "long": "title-color-user",
             "desc": "Set color of the user name (left part)",
+            "remark": "See `-h color` for the list of available colors",
             "arg": {
                 "type": "color",
                 "default": "Use color of \"--color-title\""
@@ -829,6 +860,7 @@
         {
             "long": "title-color-at",
             "desc": "Set color of the @ symbol (middle part)",
+            "remark": "See `-h color` for the list of available colors",
             "arg": {
                 "type": "color",
                 "default": "Use color of \"--color-title\""
@@ -837,6 +869,7 @@
         {
             "long": "title-color-host",
             "desc": "Set color of the host name (right part)",
+            "remark": "See `-h color` for the list of available colors",
             "arg": {
                 "type": "color",
                 "default": "default"
@@ -1351,6 +1384,29 @@
                 "type": "num"
             },
             "pseudo": true
+        },
+        {
+            "long": "<module>-percent-green",
+            "desc": [
+                "Threshold of percentage colors",
+                "Value less then percent-green will be shown in green"
+            ],
+            "arg": {
+                "type": "num"
+            },
+            "pseudo": true
+        },
+        {
+            "long": "<module>-percent-yellow",
+            "desc": [
+                "Threshold of percentage colors",
+                "Value greater than percent-green and less then yellow will be shown in yellow",
+                "Value greater than percent-yellow will be shown in red"
+            ],
+            "arg": {
+                "type": "num"
+            },
+            "pseudo": true
         }
     ]
 }

src/detection/battery/battery_apple.c

@@ -44,10 +44,12 @@ const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 
         ffCfDictGetString(properties, CFSTR(kIOPMDeviceNameKey), &battery->modelName);
         ffCfDictGetString(properties, CFSTR(kIOPMPSSerialKey), &battery->serial);
+        ffCfDictGetString(properties, CFSTR(kIOPMPSManufacturerKey), &battery->manufacturer);
 
         if (!ffCfDictGetBool(properties, CFSTR("built-in"), &boolValue) && boolValue)
         {
-            ffStrbufAppendS(&battery->manufacturer, "Apple Inc.");
+            if (!battery->manufacturer.length)
+                ffStrbufAppendS(&battery->manufacturer, "Apple Inc.");
             ffStrbufAppendS(&battery->technology, "Lithium");
             if (!battery->modelName.length)
                 ffStrbufAppendS(&battery->modelName, "Built-in");
@@ -68,17 +70,28 @@ const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
         ffStrbufTrimRight(&battery->status, ' ');
         ffStrbufTrimRight(&battery->status, ',');
 
-        CFDictionaryRef batteryData;
-        if (ffCfDictGetDict(properties, CFSTR("BatteryData"), &batteryData) == NULL)
+        int sbdsManufactureDate = 0;
+        if (ffCfDictGetInt(properties, CFSTR(kIOPMPSManufactureDateKey), &sbdsManufactureDate) == NULL)
         {
-            char manufactureDate[sizeof(uint64_t)];
-            if (ffCfDictGetInt64(batteryData, CFSTR(kIOPMPSManufactureDateKey), (int64_t*) manufactureDate) == NULL)
+            int day = sbdsManufactureDate & 0b11111;
+            int month = (sbdsManufactureDate >> 5) & 0b1111;
+            int year = (sbdsManufactureDate >> 9) + 1800;
+            ffStrbufSetF(&battery->manufactureDate, "%.4d-%.2d-%.2d", year, month, day);
+        }
+        else
+        {
+            CFDictionaryRef batteryData;
+            if (ffCfDictGetDict(properties, CFSTR("BatteryData"), &batteryData) == NULL)
             {
-                // https://github.com/AsahiLinux/linux/blob/b5c05cbffb0488c7618106926d522cc3b43d93d5/drivers/power/supply/macsmc_power.c#L410-L419
-                int year = (manufactureDate[0] - '0') * 10 + (manufactureDate[1] - '0') + 2000 - 8;
-                int month = (manufactureDate[2] - '0') * 10 + (manufactureDate[3] - '0');
-                int day = (manufactureDate[4] - '0') * 10 + (manufactureDate[3] - '5');
-                ffStrbufSetF(&battery->manufactureDate, "%.4d-%.2d-%.2d", year, month, day);
+                char manufactureDate[sizeof(uint64_t)];
+                if (ffCfDictGetInt64(batteryData, CFSTR(kIOPMPSManufactureDateKey), (int64_t*) manufactureDate) == NULL)
+                {
+                    // https://github.com/AsahiLinux/linux/blob/b5c05cbffb0488c7618106926d522cc3b43d93d5/drivers/power/supply/macsmc_power.c#L410-L419
+                    int year = (manufactureDate[0] - '0') * 10 + (manufactureDate[1] - '0') + 2000 - 8;
+                    int month = (manufactureDate[2] - '0') * 10 + (manufactureDate[3] - '0');
+                    int day = (manufactureDate[4] - '0') * 10 + (manufactureDate[3] - '5');
+                    ffStrbufSetF(&battery->manufactureDate, "%.4d-%.2d-%.2d", year, month, day);
+                }
             }
         }
 

src/detection/battery/battery_windows.c

@@ -203,9 +203,9 @@ const char* detectBySmbios(FFBatteryResult* battery)
     }
     else if (data->Header.Length > offsetof(FFSmbiosPortableBattery, SbdsManufactureDate))
     {
-        uint16_t day = data->SbdsManufactureDate & 0b11111;
-        uint16_t month = (data->SbdsManufactureDate >> 5) & 0b1111;
-        uint16_t year = (data->SbdsManufactureDate >> 9) + 1800;
+        int day = data->SbdsManufactureDate & 0b11111;
+        int month = (data->SbdsManufactureDate >> 5) & 0b1111;
+        int year = (data->SbdsManufactureDate >> 9) + 1800;
         ffStrbufSetF(&battery->manufactureDate, "%.4d-%.2d-%.2d", year, month, day);
     }
 

src/detection/cpu/cpu_linux.c

@@ -191,6 +191,8 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
                             ffStrbufAppendS(&cpu->vendor, pstart);
                         }
                         pstart = pend + 1;
+                        if (pstart >= buffer.chars + buffer.length)
+                            return NULL;
                     }
                 }
             }
@@ -207,7 +209,10 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 
                 if (*pstart == '-')
                 {
-                    ffStrbufAppendS(&cpu->name, "Unknown");
+                    if (cpu->vendor.length > 0)
+                        ffStrbufAppend(&cpu->name, &cpu->vendor);
+                    else
+                        ffStrbufAppendS(&cpu->name, "Unknown");
                     ++pstart;
                     continue;
                 }
@@ -222,6 +227,8 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
                 }
 
                 pstart = pend + 1;
+                if (pstart >= buffer.chars + buffer.length)
+                    return NULL;
             }
         }
     }

src/detection/diskio/diskio_linux.c

@@ -5,6 +5,7 @@
 
 #include <ctype.h>
 #include <limits.h>
+#include <inttypes.h>
 
 const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
 {
@@ -89,7 +90,7 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
             ssize_t fileSize = ffReadFileData(pathSysBlock, sizeof(sysBlockStat) - 1, sysBlockStat);
             if (fileSize <= 0) continue;
             sysBlockStat[fileSize] = '\0';
-            if (sscanf(sysBlockStat, "%lu%*u%lu%*u%lu%*u%lu%*u", &nRead, &sectorRead, &nWritten, &sectorWritten) <= 0)
+            if (sscanf(sysBlockStat, "%" PRIu64 "%*u%" PRIu64 "%*u%" PRIu64 "%*u%" PRIu64 "%*u", &nRead, &sectorRead, &nWritten, &sectorWritten) <= 0)
                 continue;
         }
 

src/detection/displayserver/linux/drm.c

@@ -46,7 +46,7 @@ static const char* drmParseSysfs(FFDisplayServerResult* result)
             continue;
         }
 
-        uint32_t width = 0, height = 0;
+        unsigned width = 0, height = 0;
 
         int scanned = sscanf(modes, "%ux%u", &width, &height);
         if(scanned == 2 && width > 0 && height > 0)

src/detection/gpu/gpu_apple.m

@@ -32,7 +32,7 @@ const char* ffGpuDetectMetal(FFlist* gpus)
             else if ([device supportsFamily:MTLGPUFamilyCommon1])
                 ffStrbufSetStatic(&gpu->platformApi, "Metal Common 1");
 
-            if (gpu->type == device.hasUnifiedMemory)
+            if (device.hasUnifiedMemory)
             {
                 gpu->type = FF_GPU_TYPE_INTEGRATED;
                 gpu->shared.total = device.recommendedMaxWorkingSetSize;

src/detection/gpu/gpu_bsd.c

@@ -0,0 +1,160 @@
+#include "gpu_driver_specific.h"
+
+#include "common/io/io.h"
+#include "3rdparty/nvml/nvml.h"
+#include "util/mallocHelper.h"
+#include "common/io/io.h"
+
+#include <dev/pci/pcireg.h>
+#include <sys/pciio.h>
+#include <fcntl.h>
+#include <paths.h>
+
+static bool loadPciIds(FFstrbuf* pciids)
+{
+    // https://github.com/freebsd/freebsd-src/blob/main/usr.sbin/pciconf/pathnames.h
+
+    ffReadFileBuffer(_PATH_LOCALBASE "/share/pciids/pci.ids", pciids);
+    if (pciids->length > 0) return true;
+
+    ffReadFileBuffer("/usr/share/pciids/pci.ids", pciids);
+    if (pciids->length > 0) return true;
+
+    return false;
+}
+
+const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
+{
+    FF_AUTO_CLOSE_FD int fd = open("/dev/pci", O_RDONLY, 0);
+    struct pci_conf confs[128];
+    struct pci_match_conf match = {
+        .pc_class = PCIC_DISPLAY,
+        .flags = PCI_GETCONF_MATCH_CLASS,
+    };
+    struct pci_conf_io pcio = {
+        .pat_buf_len = sizeof(match),
+        .num_patterns = 1,
+        .patterns = &match,
+        .match_buf_len = sizeof(confs),
+        .matches = confs,
+    };
+
+    if (ioctl(fd, PCIOCGETCONF, &pcio) < 0)
+        return "ioctl(fd, PCIOCGETCONF, &pc) failed";
+
+    if (pcio.status == PCI_GETCONF_ERROR)
+        return "ioctl(fd, PCIOCGETCONF, &pc) returned error";
+
+    FF_STRBUF_AUTO_DESTROY pciids = ffStrbufCreate();
+    loadPciIds(&pciids);
+
+    for (uint32_t i = 0; i < pcio.num_matches; ++i)
+    {
+        struct pci_conf* pc = &confs[i];
+
+        FFGPUResult* gpu = (FFGPUResult*)ffListAdd(gpus);
+        ffStrbufInitStatic(&gpu->vendor, ffGetGPUVendorString(pc->pc_vendor));
+        ffStrbufInit(&gpu->name);
+        ffStrbufInitS(&gpu->driver, pc->pd_name);
+        ffStrbufInit(&gpu->platformApi);
+        gpu->temperature = FF_GPU_TEMP_UNSET;
+        gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
+        gpu->type = FF_GPU_TYPE_UNKNOWN;
+        gpu->dedicated.total = gpu->dedicated.used = gpu->shared.total = gpu->shared.used = FF_GPU_VMEM_SIZE_UNSET;
+        gpu->deviceId = ((uint64_t) pc->pc_vendor << 16) + pc->pc_device;
+        gpu->frequency = FF_GPU_FREQUENCY_UNSET;
+
+        if (pciids.length)
+        {
+            char buffer[32];
+            uint32_t len = (uint32_t) snprintf(buffer, sizeof(buffer), "\n%04x  ", pc->pc_vendor);
+            char* start = (char*) memmem(pciids.chars, pciids.length, buffer, len);
+            char* end = pciids.chars + pciids.length;
+            if (start)
+            {
+                start += len;
+                end = memchr(start, '\n', (uint32_t) (end - start));
+                if (!end)
+                    end = pciids.chars + pciids.length;
+                if (!gpu->vendor.length)
+                    ffStrbufSetNS(&gpu->vendor, (uint32_t) (end - start), start);
+
+                start = end; // point to '\n' of vendor
+                end = start + 1; // point to start of devices
+                // find the start of next vendor
+                while (end[0] == '\t' || end[0] == '#')
+                {
+                    end = strchr(end, '\n');
+                    if (!end)
+                    {
+                        end = pciids.chars + pciids.length;
+                        break;
+                    }
+                    else
+                        end++;
+                }
+
+                len = (uint32_t) snprintf(buffer, sizeof(buffer), "\n\t%04x  ", pc->pc_device);
+                start = memmem(start, (size_t) (end - start), buffer, len);
+                if (start)
+                {
+                    start += len;
+                    end = memchr(start, '\n', (uint32_t) (end - start));
+                    if (!end)
+                        end = pciids.chars + pciids.length;
+
+                    char* openingBracket = memchr(start, '[', (uint32_t) (end - start));
+                    if (openingBracket)
+                    {
+                        openingBracket++;
+                        char* closingBracket = memchr(openingBracket, ']', (uint32_t) (end - openingBracket));
+                        if (closingBracket)
+                            ffStrbufSetNS(&gpu->name, (uint32_t) (closingBracket - openingBracket), openingBracket);
+                    }
+                    if (!gpu->name.length)
+                        ffStrbufSetNS(&gpu->name, (uint32_t) (end - start), start);
+                }
+            }
+        }
+
+        if (!gpu->name.length)
+        {
+            const char* subclass;
+            switch (pc->pc_subclass)
+            {
+            case PCIS_DISPLAY_VGA: subclass = " (VGA compatible)"; break;
+            case PCIS_DISPLAY_XGA: subclass = " (XGA compatible)"; break;
+            case PCIS_DISPLAY_3D: subclass = " (3D)"; break;
+            default: subclass = ""; break;
+            }
+
+            ffStrbufSetF(&gpu->name, "%s Device %04X%s", gpu->vendor.length ? gpu->vendor.chars : "Unknown", pc->pc_device, subclass);
+        }
+
+        #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
+        if (gpu->vendor.chars == FF_GPU_VENDOR_NAME_NVIDIA && (options->temp || options->driverSpecific))
+        {
+            ffDetectNvidiaGpuInfo(&(FFGpuDriverCondition) {
+                .type = FF_GPU_DRIVER_CONDITION_TYPE_BUS_ID,
+                .pciBusId = {
+                    .domain = (uint32_t) pc->pc_sel.pc_domain,
+                    .bus = pc->pc_sel.pc_bus,
+                    .device = pc->pc_sel.pc_dev,
+                    .func = pc->pc_sel.pc_func,
+                },
+            }, (FFGpuDriverResult) {
+                .temp = options->temp ? &gpu->temperature : NULL,
+                .memory = options->driverSpecific ? &gpu->dedicated : NULL,
+                .coreCount = options->driverSpecific ? (uint32_t*) &gpu->coreCount : NULL,
+                .type = &gpu->type,
+                .frequency = &gpu->frequency,
+            }, "libnvidia-ml.so");
+
+            if (gpu->dedicated.total != FF_GPU_VMEM_SIZE_UNSET)
+                gpu->type = gpu->dedicated.total > (uint64_t)1024 * 1024 * 1024 ? FF_GPU_TYPE_DISCRETE : FF_GPU_TYPE_INTEGRATED;
+        }
+        #endif // FF_USE_PROPRIETARY_GPU_DRIVER_API
+    }
+
+    return NULL;
+}

src/detection/gpu/gpu_linux.c

@@ -209,16 +209,8 @@ static void pciHandleDevice(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist*
 {
     pci->ffpci_fill_info(device, PCI_FILL_CLASS);
 
-    char class[1024];
-    pci->ffpci_lookup_name(pci->access, class, sizeof(class) - 1, PCI_LOOKUP_CLASS, device->device_class);
-
-    if(
-        //https://pci-ids.ucw.cz/read/PD/03
-        strcasecmp("VGA compatible controller", class) != 0 &&
-        strcasecmp("XGA compatible controller", class) != 0 &&
-        strcasecmp("3D controller", class)             != 0 &&
-        strcasecmp("Display controller", class)        != 0
-    ) return;
+    if (device->device_class >> 8 != PCI_BASE_CLASS_DISPLAY)
+        return;
 
     pci->ffpci_fill_info(device, PCI_FILL_IDENT);
 

src/detection/gpu/gpu_windows.c

@@ -77,7 +77,7 @@ const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist*
 
         // See: https://download.nvidia.com/XFree86/Linux-x86_64/545.23.06/README/supportedchips.html
         // displayDevice.DeviceID = MatchingDeviceId "PCI\\VEN_10DE&DEV_2782&SUBSYS_513417AA&REV_A1"
-        uint32_t vendorId = 0, deviceId = 0, subSystemId = 0, revId = 0;
+        unsigned vendorId = 0, deviceId = 0, subSystemId = 0, revId = 0;
         swscanf(displayDevice.DeviceID, L"PCI\\VEN_%x&DEV_%x&SUBSYS_%x&REV_%x", &vendorId, &deviceId, &subSystemId, &revId);
 
         FFGPUResult* gpu = (FFGPUResult*)ffListAdd(gpus);

src/detection/gpu/gpu_wsl.cpp

@@ -68,6 +68,7 @@ const char* ffGPUDetectByDirectX(FF_MAYBE_UNUSED const FFGPUOptions* options, FF
         gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
         gpu->temperature = FF_GPU_TEMP_UNSET;
         gpu->frequency = FF_GPU_FREQUENCY_UNSET;
+        ffStrbufInitStatic(&gpu->platformApi, "DXCore");
 
         ffStrbufInit(&gpu->driver);
         uint64_t value = 0;

src/detection/locale/locale_linux.c

@@ -1,61 +1,15 @@
 #include "detection/locale/locale.h"
 
-#include "common/properties.h"
-#include "common/parsing.h"
-#include <stdlib.h>
 #include <locale.h>
 
-FF_MAYBE_UNUSED
-static void getLocaleFromEnv(FFstrbuf* locale)
-{
-    ffStrbufAppendS(locale, getenv("LANG"));
-    if(locale->length > 0)
-        return;
-
-    ffStrbufAppendS(locale, getenv("LC_ALL"));
-    if(locale->length > 0)
-        return;
-
-    ffStrbufAppendS(locale, getenv("LC_MESSAGES"));
-}
-
-static void getLocaleFromStdFn(FFstrbuf* locale)
-{
-    #ifdef LC_MESSAGES
-    ffStrbufAppendS(locale, setlocale(LC_MESSAGES, NULL));
-
-    if(locale->length > 0)
-        return;
-    #endif
-
-    ffStrbufAppendS(locale, setlocale(LC_ALL, NULL));
-}
-
 void ffDetectLocale(FFstrbuf* result)
 {
-    #if !(defined(__APPLE__) || defined(_WIN32))
-
-        //Ubuntu (and deriviates) use a non standard locale file.
-        //Parse it first, because on distributions where it exists, it takes precedence.
-        //Otherwise use the standard etc/locale.conf file.
-        ffParsePropFile(FASTFETCH_TARGET_DIR_ETC"/default/locale", "LANG =", result);
-
-        if(result->length > 0)
-            return;
-
-        ffParsePropFile(FASTFETCH_TARGET_DIR_ETC"/locale.conf", "LANG =", result);
-        if(result->length > 0)
-            return;
+    #ifdef LC_MESSAGES
+    ffStrbufAppendS(result, setlocale(LC_MESSAGES, NULL));
 
+    if(result->length > 0)
+        return;
     #endif
 
-    #ifndef _WIN32
-
-        getLocaleFromEnv(result);
-        if(result->length > 0)
-            return;
-
-    #endif
-
-    getLocaleFromStdFn(result);
+    ffStrbufAppendS(result, setlocale(LC_ALL, NULL));
 }

src/detection/locale/locale_windows.c

@@ -9,10 +9,5 @@ void ffDetectLocale(FFstrbuf* result)
     wchar_t name[LOCALE_NAME_MAX_LENGTH];
     int size = GetUserDefaultLocaleName(name, LOCALE_NAME_MAX_LENGTH);
     if (size > 1) // including '\0'
-    {
         ffStrbufSetNWS(result, (uint32_t)size - 1, name);
-        ffStrbufAppendS(result, ".UTF-8"); // set explicitly in `ffInitInstance`
-    }
-    else
-        ffStrbufSetS(result, setlocale(LC_ALL, NULL));
 }

src/detection/opencl/opencl.c

@@ -23,15 +23,15 @@ typedef struct OpenCLData
 
 static const char* openCLHandleData(OpenCLData* data, FFOpenCLResult* result)
 {
-    cl_platform_id platformID;
-    cl_uint numPlatforms;
+    cl_platform_id platformID = NULL;
+    cl_uint numPlatforms = 0;
     data->ffclGetPlatformIDs(1, &platformID, &numPlatforms);
 
     if(numPlatforms == 0)
         return "clGetPlatformIDs returned 0 platforms";
 
-    cl_device_id deviceID;
-    cl_uint numDevices;
+    cl_device_id deviceID = NULL;
+    cl_uint numDevices = 0;
     data->ffclGetDeviceIDs(platformID, CL_DEVICE_TYPE_GPU, 1, &deviceID, &numDevices);
 
     if(numDevices == 0)
@@ -40,7 +40,7 @@ static const char* openCLHandleData(OpenCLData* data, FFOpenCLResult* result)
     if(numDevices == 0)
         return "clGetDeviceIDs returned 0 devices";
 
-    char version[64];
+    char version[64] = "";
     data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VERSION, sizeof(version), version, NULL);
     if(!ffStrSet(version))
         return "clGetDeviceInfo returned NULL or empty string";

src/detection/poweradapter/poweradapter_apple.c

@@ -7,7 +7,6 @@
 
 const char* ffDetectPowerAdapter(FFlist* results)
 {
-    FF_CFTYPE_AUTO_RELEASE CFDictionaryRef details = IOPSCopyExternalPowerAdapterDetails();
     FFPowerAdapterResult* adapter = ffListAdd(results);
 
     ffStrbufInit(&adapter->name);
@@ -17,13 +16,24 @@ const char* ffDetectPowerAdapter(FFlist* results)
     ffStrbufInit(&adapter->serial);
     adapter->watts = FF_POWERADAPTER_NOT_CONNECTED;
 
+    FF_CFTYPE_AUTO_RELEASE CFDictionaryRef details = IOPSCopyExternalPowerAdapterDetails();
     if (details)
     {
         ffCfDictGetString(details, CFSTR(kIOPSNameKey), &adapter->name);
-        ffCfDictGetString(details, CFSTR("Model"), &adapter->modelName);
+        if (ffCfDictGetString(details, CFSTR("Model"), &adapter->modelName) != NULL)
+        {
+            int adapterId;
+            if (ffCfDictGetInt(details, CFSTR(kIOPSPowerAdapterIDKey), &adapterId) == 0)
+                ffStrbufSetF(&adapter->modelName, "%d", adapterId);
+        }
         ffCfDictGetString(details, CFSTR("Manufacturer"), &adapter->manufacturer);
         ffCfDictGetString(details, CFSTR("Description"), &adapter->description);
-        ffCfDictGetString(details, CFSTR("SerialString"), &adapter->serial);
+        if (ffCfDictGetString(details, CFSTR("SerialString"), &adapter->serial) != NULL)
+        {
+            int serialNumber;
+            if (ffCfDictGetInt(details, CFSTR(kIOPSPowerAdapterSerialNumberKey), &serialNumber) == 0)
+                ffStrbufSetF(&adapter->serial, "%X", serialNumber);
+        }
         ffCfDictGetInt(details, CFSTR(kIOPSPowerAdapterWattsKey), &adapter->watts);
     }
 

src/detection/processes/processes_bsd.c

@@ -6,13 +6,17 @@
     #include <sys/user.h>
 #endif
 
+#ifndef KERN_PROC_PROC
+    #define KERN_PROC_PROC KERN_PROC_ALL // Apple
+#endif
+
 const char* ffDetectProcesses(uint32_t* result)
 {
-    int request[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
+    int request[] = {CTL_KERN, KERN_PROC, KERN_PROC_PROC};
     size_t length;
 
     if(sysctl(request, sizeof(request) / sizeof(*request), NULL, &length, NULL, 0) != 0)
-        return "sysctl({CTL_KERN, KERN_PROC, KERN_PROC_ALL}) failed";
+        return "sysctl({CTL_KERN, KERN_PROC, KERN_PROC_PROC}) failed";
 
     *result = (uint32_t)(length / sizeof(struct kinfo_proc));
     return NULL;

src/detection/terminalfont/terminalfont_linux.c

@@ -315,7 +315,7 @@ void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFo
         detectFromConfigFile("lxterminal/lxterminal.conf", "fontname =", terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminal->processName, "tilix"))
         detectFromGSettings("/com/gexperts/Tilix/profiles/", "com.gexperts.Tilix.ProfilesList", "com.gexperts.Tilix.Profile", "default", terminalFont);
-    else if(ffStrbufStartsWithIgnCaseS(&terminal->processName, "gnome-terminal-"))
+    else if(ffStrbufStartsWithIgnCaseS(&terminal->processName, "gnome-terminal"))
         detectFromGSettings("/org/gnome/terminal/legacy/profiles:/:", "org.gnome.Terminal.ProfilesList", "org.gnome.Terminal.Legacy.Profile", "default", terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminal->processName, "kgx"))
         detectKgx(terminalFont);

src/detection/terminalshell/terminalshell.c

@@ -168,6 +168,23 @@ static bool getShellVersionAsh(FFstrbuf* exe, FFstrbuf* version)
     return true;
 }
 
+static bool getShellVersionXonsh(FFstrbuf* exe, FFstrbuf* version)
+{
+    ffStrbufSetS(version, getenv("XONSH_VERSION"));
+    if (version->length) return true;
+
+    if(ffProcessAppendStdErr(version, (char* const[]) {
+        exe->chars,
+        "--version",
+        NULL
+    }) != NULL)
+        return false;
+
+    // xonsh/0.14.1
+    ffStrbufSubstrAfterFirstC(version, '/');
+    return true;
+}
+
 #ifdef _WIN32
 static bool getShellVersionWinPowerShell(FFstrbuf* exe, FFstrbuf* version)
 {
@@ -228,11 +245,8 @@ bool fftsGetShellVersion(FFstrbuf* exe, const char* exeName, FFstrbuf* version)
         return getExeVersionRaw(exe, version);
     if(strcasecmp(exeName, "ash") == 0)
         return getShellVersionAsh(exe, version);
-    if(strcasecmp(exeName, "python") == 0 && getenv("XONSH_VERSION"))
-    {
-        ffStrbufSetS(version, getenv("XONSH_VERSION"));
-        return true;
-    }
+    if(strcasecmp(exeName, "xonsh") == 0)
+        return getShellVersionXonsh(exe, version);
 
     #ifdef _WIN32
     if(strcasecmp(exeName, "powershell") == 0 || strcasecmp(exeName, "powershell_ise") == 0)
@@ -267,7 +281,7 @@ FF_MAYBE_UNUSED static bool getTerminalVersionGnome(FFstrbuf* version)
 FF_MAYBE_UNUSED static bool getTerminalVersionKgx(FFstrbuf* version)
 {
     if(ffProcessAppendStdOut(version, (char* const[]){
-        "gnome-terminal",
+        "kgx",
         "--version",
         NULL
     })) return false;
@@ -386,6 +400,15 @@ static bool getTerminalVersionContour(FFstrbuf* exe, FFstrbuf* version)
     return version->length > 0;
 }
 
+static bool getTerminalVersionScreen(FFstrbuf* exe, FFstrbuf* version)
+{
+    if(!getExeVersionRaw(exe, version)) return false;
+    // Screen version 4.09.01 (GNU) 20-Aug-23
+    ffStrbufSubstrAfter(version, strlen("Screen version ") - 1);
+    ffStrbufSubstrBeforeFirstC(version, ' ');
+    return version->length > 0;
+}
+
 #ifdef _WIN32
 
 static bool getTerminalVersionWindowsTerminal(FFstrbuf* exe, FFstrbuf* version)
@@ -426,7 +449,7 @@ bool fftsGetTerminalVersion(FFstrbuf* processName, FF_MAYBE_UNUSED FFstrbuf* exe
 
     #if defined(__linux__) || defined(__FreeBSD__)
 
-    if(ffStrbufStartsWithIgnCaseS(processName, "gnome-terminal-"))
+    if(ffStrbufStartsWithIgnCaseS(processName, "gnome-terminal"))
         return getTerminalVersionGnome(version);
 
     if(ffStrbufIgnCaseEqualS(processName, "konsole"))
@@ -497,6 +520,9 @@ bool fftsGetTerminalVersion(FFstrbuf* processName, FF_MAYBE_UNUSED FFstrbuf* exe
     if(ffStrbufStartsWithIgnCaseS(processName, "contour"))
         return getTerminalVersionContour(exe, version);
 
+    if(ffStrbufStartsWithIgnCaseS(processName, "screen"))
+        return getTerminalVersionScreen(exe, version);
+
     const char* termProgramVersion = getenv("TERM_PROGRAM_VERSION");
     if(termProgramVersion)
     {

src/detection/terminalshell/terminalshell.h

@@ -5,12 +5,14 @@
 typedef struct FFShellResult
 {
     FFstrbuf processName;
-    FFstrbuf exe;
+    FFstrbuf exe; //Actually arg0 in *nix
     const char* exeName; //pointer to a char in exe
+    FFstrbuf exePath; //Full real path to executable file
     FFstrbuf prettyName;
     FFstrbuf version;
     uint32_t pid;
     uint32_t ppid;
+    int32_t tty;
 } FFShellResult;
 
 typedef struct FFTerminalResult
@@ -19,6 +21,7 @@ typedef struct FFTerminalResult
     FFstrbuf exe;
     FFstrbuf prettyName;
     const char* exeName; //pointer to a char in exe
+    FFstrbuf exePath; //Full real path to executable file
     FFstrbuf version;
     uint32_t pid;
     uint32_t ppid;

src/detection/terminalshell/terminalshell_linux.c

@@ -4,14 +4,13 @@
 #include "common/processing.h"
 #include "common/thread.h"
 #include "util/stringUtils.h"
+#include "util/mallocHelper.h"
 
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 
-#ifdef __APPLE__
-    #include <libproc.h>
-#elif defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__APPLE__)
     #include <sys/types.h>
     #include <sys/user.h>
     #include <sys/sysctl.h>
@@ -25,38 +24,94 @@ static void setExeName(FFstrbuf* exe, const char** exeName)
         *exeName = exe->chars + lastSlashIndex + 1;
 }
 
-static void getProcessInformation(pid_t pid, FFstrbuf* processName, FFstrbuf* exe, const char** exeName)
+static void getProcessInformation(pid_t pid, FFstrbuf* processName, FFstrbuf* exe, const char** exeName, FFstrbuf* exePath)
 {
     assert(processName->length > 0);
     ffStrbufClear(exe);
 
     #ifdef __linux__
 
-    char cmdlineFilePath[64];
-    snprintf(cmdlineFilePath, sizeof(cmdlineFilePath), "/proc/%d/cmdline", (int)pid);
+    char filePath[64];
+    snprintf(filePath, sizeof(filePath), "/proc/%d/cmdline", (int)pid);
 
-    if(ffAppendFileBuffer(cmdlineFilePath, exe))
+    if(ffAppendFileBuffer(filePath, exe))
     {
         ffStrbufTrimRightSpace(exe);
-        ffStrbufSubstrBeforeFirstC(exe, '\0'); //Trim the arguments
-        ffStrbufTrimLeft(exe, '-'); //Happens in TTY
+        ffStrbufRecalculateLength(exe); //Trim the arguments
+        ffStrbufTrimLeft(exe, '-'); //Login shells start with a dash
+    }
+
+    snprintf(filePath, sizeof(filePath), "/proc/%d/exe", (int)pid);
+    ffStrbufEnsureFixedLengthFree(exePath, PATH_MAX);
+    ssize_t length = readlink(filePath, exePath->chars, exePath->allocated - 1);
+    if (length > 0) // doesn't contain trailing NUL
+    {
+        exePath->chars[length + 1] = '\0';
+        exePath->length = (uint32_t) length;
     }
 
     #elif defined(__APPLE__)
 
-    int length = proc_pidpath((int)pid, exe->chars, exe->allocated);
-    if(length > 0)
-        exe->length = (uint32_t)length;
+    size_t len = 0;
+    int mibs[] = { CTL_KERN, KERN_PROCARGS2, pid };
+    if (sysctl(mibs, sizeof(mibs) / sizeof(*mibs), NULL, &len, NULL, 0) == 0)
+    {
+        FF_AUTO_FREE char* const procArgs2 = malloc(len);
+        if (sysctl(mibs, sizeof(mibs) / sizeof(*mibs), procArgs2, &len, NULL, 0) == 0)
+        {
+            // https://gist.github.com/nonowarn/770696#file-getargv-c-L46
+            uint32_t argc = *(uint32_t*) procArgs2;
+            const char* realExePath = procArgs2 + sizeof(argc);
+
+            const char* arg0 = memchr(realExePath, '\0', len - (size_t) (realExePath - procArgs2));
+            ffStrbufSetNS(exePath, (uint32_t) (arg0 - realExePath), realExePath);
+
+            do arg0++; while (*arg0 == '\0');
+            assert(arg0 < procArgs2 + len);
+            if (*arg0 == '-') arg0++; // Login shells
+
+            ffStrbufSetS(exe, arg0);
+        }
+    }
 
     #elif defined(__FreeBSD__)
 
-    size_t size = exe->allocated;
-    if(!sysctl(
+    size_t size = ARG_MAX;
+    FF_AUTO_FREE char* args = malloc(size);
+
+    static_assert(ARG_MAX > PATH_MAX, "");
+
+    if(sysctl(
         (int[]){CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, pid}, 4,
-        exe->chars, &size,
+        args, &size,
         NULL, 0
-    ))
-        exe->length = (uint32_t)size - 1;
+    ) == 0)
+        ffStrbufSetNS(exePath, (uint32_t) (size - 1), args);
+
+    size = ARG_MAX;
+    if(sysctl(
+        (int[]){CTL_KERN, KERN_PROC, KERN_PROC_ARGS, pid}, 4,
+        args, &size,
+        NULL, 0
+    ) == 0)
+    {
+        char* arg0 = args;
+        size_t arg0Len = strlen(args);
+        if (size > arg0Len + 1)
+        {
+            char* p = (char*) memrchr(args, '/', arg0Len);
+            if (p)
+            {
+                p++;
+                if (ffStrStartsWith(p, "python")) // /usr/local/bin/python3.9 /home/carter/.local/bin/xonsh
+                {
+                    arg0 += arg0Len + 1;
+                }
+            }
+        }
+        if (arg0[0] == '-') arg0++;
+        ffStrbufSetS(exe, arg0);
+    }
 
     #endif
 
@@ -66,8 +121,11 @@ static void getProcessInformation(pid_t pid, FFstrbuf* processName, FFstrbuf* ex
     setExeName(exe, exeName);
 }
 
-static const char* getProcessNameAndPpid(pid_t pid, char* name, pid_t* ppid)
+static const char* getProcessNameAndPpid(pid_t pid, char* name, pid_t* ppid, int32_t* tty)
 {
+    if (pid <= 0)
+        return "Invalid pid";
+
     #ifdef __linux__
 
     char statFilePath[64];
@@ -79,21 +137,43 @@ static const char* getProcessNameAndPpid(pid_t pid, char* name, pid_t* ppid)
     buf[nRead] = '\0';
 
     *ppid = 0;
+    static_assert(sizeof(*ppid) == sizeof(int), "");
+
+    int tty_;
     if(
-        sscanf(buf, "%*s (%255[^)]) %*c %d", name, ppid) != 2 || //stat (comm) state ppid
+        sscanf(buf, "%*s (%255[^)]) %*c %d %*d %*d %d", name, ppid, &tty_) < 2 || //stat (comm) state ppid pgrp session tty
         !ffStrSet(name) ||
         *ppid == 0
     )
         return "sscanf(stat) failed";
 
+    if (tty)
+    {
+        if ((tty_ >> 8) == 0x88)
+            *tty = tty_ & 0xFF;
+        else
+            *tty = -1;
+    }
+
     #elif defined(__APPLE__)
 
-    struct proc_bsdshortinfo proc;
-    if(proc_pidinfo(pid, PROC_PIDT_SHORTBSDINFO, 0, &proc, PROC_PIDT_SHORTBSDINFO_SIZE) <= 0)
-        return "proc_pidinfo(pid) failed";
+    struct kinfo_proc proc;
+    size_t size = sizeof(proc);
+    if(sysctl(
+        (int[]){CTL_KERN, KERN_PROC, KERN_PROC_PID, pid}, 4,
+        &proc, &size,
+        NULL, 0
+    ))
+        return "sysctl(KERN_PROC_PID) failed";
 
-    *ppid = (pid_t)proc.pbsi_ppid;
-    strncpy(name, proc.pbsi_comm, 16); //trancated to 16 chars
+    *ppid = (pid_t)proc.kp_eproc.e_ppid;
+    strcpy(name, proc.kp_proc.p_comm); //trancated to 16 chars
+    if (tty)
+    {
+        *tty = ((proc.kp_eproc.e_tdev >> 24) & 0xFF) == 0x10
+            ? proc.kp_eproc.e_tdev & 0xFFFFFF
+            : -1;
+    }
 
     #elif defined(__FreeBSD__)
 
@@ -107,7 +187,20 @@ static const char* getProcessNameAndPpid(pid_t pid, char* name, pid_t* ppid)
         return "sysctl(KERN_PROC_PID) failed";
 
     *ppid = (pid_t)proc.ki_ppid;
-    strncpy(name, proc.ki_comm, COMMLEN);
+    strcpy(name, proc.ki_comm);
+    if (tty)
+    {
+        if (proc.ki_tdev != NODEV && proc.ki_flag & P_CONTROLT)
+        {
+            const char* ttyName = devname(proc.ki_tdev, S_IFCHR);
+            if (ffStrStartsWith(ttyName, "pts/"))
+                *tty = (int32_t) strtol(ttyName + strlen("pts/"), NULL, 10);
+            else
+                *tty = -1;
+        }
+        else
+            *tty = -1;
+    }
 
     #else
 
@@ -124,11 +217,13 @@ static pid_t getShellInfo(FFShellResult* result, pid_t pid)
     name[0] = '\0';
 
     pid_t ppid = 0;
+    int32_t tty = -1;
 
-    while (getProcessNameAndPpid(pid, name, &ppid) == NULL)
+    while (getProcessNameAndPpid(pid, name, &ppid, &tty) == NULL)
     {
         //Common programs that are between terminal and own process, but are not the shell
         if(
+            // tty < 0                                  || //A shell should connect to a tty
             ffStrEquals(name, "sh")                  || //This prevents us from detecting things like pipes and redirects, i hope nobody uses plain `sh` as shell
             ffStrEquals(name, "sudo")                ||
             ffStrEquals(name, "su")                  ||
@@ -152,8 +247,9 @@ static pid_t getShellInfo(FFShellResult* result, pid_t pid)
 
         result->pid = (uint32_t) pid;
         result->ppid = (uint32_t) ppid;
+        result->tty = tty;
         ffStrbufSetS(&result->processName, name);
-        getProcessInformation(pid, &result->processName, &result->exe, &result->exeName);
+        getProcessInformation(pid, &result->processName, &result->exe, &result->exeName, &result->exePath);
         break;
     }
     return ppid;
@@ -166,10 +262,11 @@ static pid_t getTerminalInfo(FFTerminalResult* result, pid_t pid)
 
     pid_t ppid = 0;
 
-    while (getProcessNameAndPpid(pid, name, &ppid) == NULL)
+    while (getProcessNameAndPpid(pid, name, &ppid, NULL) == NULL)
     {
         //Known shells
         if (
+            ffStrEquals(name, "sh")         ||
             ffStrEquals(name, "ash")        ||
             ffStrEquals(name, "bash")       ||
             ffStrEquals(name, "zsh")        ||
@@ -185,7 +282,10 @@ static pid_t getTerminalInfo(FFTerminalResult* result, pid_t pid)
             ffStrEquals(name, "git-shell")  ||
             ffStrEquals(name, "elvish")     ||
             ffStrEquals(name, "oil.ovm")    ||
-            (ffStrEquals(name, "python") && getenv("XONSH_VERSION"))
+            ffStrEquals(name, "xonsh")      || // works in Linux but not in macOS because kernel returns `Python` in this case
+            ffStrEquals(name, "login")      ||
+            ffStrEquals(name, "sshd")       ||
+            ffStrEndsWith(name, ".sh")
         )
         {
             pid = ppid;
@@ -196,19 +296,35 @@ static pid_t getTerminalInfo(FFTerminalResult* result, pid_t pid)
         // https://github.com/fastfetch-cli/fastfetch/discussions/501
         if (ffStrEndsWith(name, " (figterm)") || ffStrEndsWith(name, " (cwterm)"))
         {
-            if (__builtin_expect(getProcessNameAndPpid(ppid, name, &ppid) != NULL, false))
+            if (__builtin_expect(getProcessNameAndPpid(ppid, name, &ppid, NULL) != NULL, false))
                 return 0;
         }
         #endif
 
         result->pid = (uint32_t) pid;
+        result->ppid = (uint32_t) ppid;
         ffStrbufSetS(&result->processName, name);
-        getProcessInformation(pid, &result->processName, &result->exe, &result->exeName);
+        getProcessInformation(pid, &result->processName, &result->exe, &result->exeName, &result->exePath);
         break;
     }
     return ppid;
 }
 
+static bool getTerminalInfoByPidEnv(FFTerminalResult* result, const char* pidEnv)
+{
+    pid_t pid = (pid_t) strtol(getenv(pidEnv), NULL, 10);
+    result->pid = (uint32_t) pid;
+    char name[256];
+    if (getProcessNameAndPpid(pid, name, (pid_t*) &result->ppid, NULL) == NULL)
+    {
+        ffStrbufSetS(&result->processName, name);
+        getProcessInformation(pid, &result->processName, &result->exe, &result->exeName, &result->exePath);
+        return true;
+    }
+
+    return false;
+}
+
 static void getTerminalFromEnv(FFTerminalResult* result)
 {
     if(
@@ -231,58 +347,80 @@ static void getTerminalFromEnv(FFTerminalResult* result)
     const char* term = NULL;
 
     //SSH
-    if(getenv("SSH_CONNECTION") != NULL)
+    if(
+        getenv("SSH_TTY") != NULL
+    )
         term = getenv("SSH_TTY");
+    else if(
+        getenv("KITTY_PID") != NULL ||
+        getenv("KITTY_INSTALLATION_DIR") != NULL
+    )
+    {
+        if (getTerminalInfoByPidEnv(result, "KITTY_PID"))
+            return;
+        term = "kitty";
+    }
 
-    #ifdef __linux__
+    #ifdef __linux__ // WSL
     //Windows Terminal
-    if(!ffStrSet(term) && (
+    else if(
         getenv("WT_SESSION") != NULL ||
         getenv("WT_PROFILE_ID") != NULL
-    )) term = "Windows Terminal";
+    ) term = "Windows Terminal";
 
     //ConEmu
-    if(!ffStrSet(term) && (
+    else if(
         getenv("ConEmuPID") != NULL
-    )) term = "ConEmu";
+    ) term = "ConEmu";
     #endif
 
     //Alacritty
-    if(!ffStrSet(term) && (
+    else if(
         getenv("ALACRITTY_SOCKET") != NULL ||
         getenv("ALACRITTY_LOG") != NULL ||
         getenv("ALACRITTY_WINDOW_ID") != NULL
-    )) term = "Alacritty";
+    ) term = "Alacritty";
 
     #ifdef __ANDROID__
     //Termux
-    if(!ffStrSet(term) && (
+    else if(
         getenv("TERMUX_VERSION") != NULL ||
         getenv("TERMUX_MAIN_PACKAGE_FORMAT") != NULL
-    )) term = "com.termux";
+    )
+    {
+        if (getTerminalInfoByPidEnv(result, "TERMUX_APP__PID"))
+            return;
+        term = "com.termux";
+    }
     #endif
 
-    #ifdef __linux__
+    #if defined(__linux__) || defined(__FreeBSD__)
     //Konsole
-    if(!ffStrSet(term) && (
+    else if(
         getenv("KONSOLE_VERSION") != NULL
-    )) term = "konsole";
+    ) term = "konsole";
+
+    else if(
+        getenv("GNOME_TERMINAL_SCREEN") != NULL ||
+        getenv("GNOME_TERMINAL_SERVICE") != NULL
+    ) term = "gnome-terminal";
     #endif
 
     //MacOS, mintty
-    if(!ffStrSet(term))
+    else if(getenv("TERM_PROGRAM") != NULL)
         term = getenv("TERM_PROGRAM");
 
-    if(!ffStrSet(term))
+    else if(getenv("LC_TERMINAL") != NULL)
         term = getenv("LC_TERMINAL");
 
     //Normal Terminal
-    if(!ffStrSet(term))
+    else
+    {
         term = getenv("TERM");
-
-    //TTY
-    if(!ffStrSet(term) || ffStrEquals(term, "linux"))
-        term = ttyname(STDIN_FILENO);
+        //TTY
+        if(!ffStrSet(term) || ffStrEquals(term, "linux"))
+            term = ttyname(STDIN_FILENO);
+    }
 
     if(ffStrSet(term))
     {
@@ -316,8 +454,6 @@ static void setShellInfoDetails(FFShellResult* result)
         ffStrbufInitStatic(&result->prettyName, "PowerShell");
     else if(ffStrbufEqualS(&result->processName, "nu"))
         ffStrbufInitStatic(&result->prettyName, "nushell");
-    else if(ffStrbufEqualS(&result->processName, "python") && getenv("XONSH_VERSION"))
-        ffStrbufInitStatic(&result->prettyName, "xonsh");
     else if(ffStrbufEqualS(&result->processName, "oil.ovm"))
         ffStrbufInitStatic(&result->prettyName, "Oils");
     else
@@ -343,6 +479,8 @@ static void setTerminalInfoDetails(FFTerminalResult* result)
         ffStrbufInitStatic(&result->prettyName, "WezTerm");
     else if(ffStrbufStartsWithS(&result->processName, "tmux:"))
         ffStrbufInitStatic(&result->prettyName, "tmux");
+    else if(ffStrbufStartsWithS(&result->processName, "screen-"))
+        ffStrbufInitStatic(&result->prettyName, "screen");
 
     #if defined(__ANDROID__)
 
@@ -351,7 +489,7 @@ static void setTerminalInfoDetails(FFTerminalResult* result)
 
     #elif defined(__linux__) || defined(__FreeBSD__)
 
-    else if(ffStrbufStartsWithS(&result->processName, "gnome-terminal-"))
+    else if(ffStrbufStartsWithS(&result->processName, "gnome-terminal"))
         ffStrbufInitStatic(&result->prettyName, "GNOME Terminal");
     else if(ffStrbufStartsWithS(&result->processName, "kgx"))
         ffStrbufInitStatic(&result->prettyName, "GNOME Console");
@@ -377,13 +515,10 @@ static void setTerminalInfoDetails(FFTerminalResult* result)
     else
         ffStrbufInitCopy(&result->prettyName, &result->processName);
 
-    ffStrbufInit(&result->version);
     fftsGetTerminalVersion(&result->processName, &result->exe, &result->version);
 }
 
-#ifdef __APPLE__
-#define FF_EXE_PATH_LEN PROC_PIDPATHINFO_MAXSIZE
-#elif defined(MAXPATH)
+#if defined(MAXPATH)
 #define FF_EXE_PATH_LEN MAXPATH
 #elif defined(PATH_MAX)
 #define FF_EXE_PATH_LEN PATH_MAX
@@ -402,9 +537,11 @@ const FFShellResult* ffDetectShell()
     ffStrbufInit(&result.processName);
     ffStrbufInitA(&result.exe, FF_EXE_PATH_LEN);
     result.exeName = result.exe.chars;
+    ffStrbufInit(&result.exePath);
     ffStrbufInit(&result.version);
     result.pid = 0;
     result.ppid = 0;
+    result.tty = -1;
 
     pid_t ppid = getppid();
     ppid = getShellInfo(&result, ppid);
@@ -425,6 +562,8 @@ const FFTerminalResult* ffDetectTerminal()
     ffStrbufInit(&result.processName);
     ffStrbufInitA(&result.exe, FF_EXE_PATH_LEN);
     result.exeName = result.exe.chars;
+    ffStrbufInit(&result.exePath);
+    ffStrbufInit(&result.version);
     result.pid = 0;
     result.ppid = 0;
 

src/detection/terminalshell/terminalshell_windows.c

@@ -39,15 +39,18 @@ static bool getProductVersion(const wchar_t* filePath, FFstrbuf* version)
     return false;
 }
 
-static bool getProcessInfo(uint32_t pid, uint32_t* ppid, FFstrbuf* pname, FFstrbuf* exe, const char** exeName)
+static bool getProcessInfo(uint32_t pid, uint32_t* ppid, FFstrbuf* pname, FFstrbuf* exe, const char** exeName, FFstrbuf* exePath, bool* gui)
 {
-    HANDLE hProcess = pid == 0
+    FF_AUTO_CLOSE_FD HANDLE hProcess = pid == 0
         ? GetCurrentProcess()
         : OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, TRUE, pid);
 
+    if (gui)
+        *gui = GetGuiResources(hProcess, GR_GDIOBJECTS) > 0;
+
     if(ppid)
     {
-        PROCESS_BASIC_INFORMATION info;
+        PROCESS_BASIC_INFORMATION info = {};
         ULONG size;
         if(NT_SUCCESS(NtQueryInformationProcess(hProcess, ProcessBasicInformation, &info, sizeof(info), &size)))
         {
@@ -55,21 +58,20 @@ static bool getProcessInfo(uint32_t pid, uint32_t* ppid, FFstrbuf* pname, FFstrb
             *ppid = (uint32_t)info.InheritedFromUniqueProcessId;
         }
         else
-        {
-            CloseHandle(hProcess);
             return false;
-        }
     }
     if(exe)
     {
         DWORD bufSize = exe->allocated;
         if(QueryFullProcessImageNameA(hProcess, 0, exe->chars, &bufSize))
-            exe->length = bufSize;
-        else
         {
-            CloseHandle(hProcess);
-            return false;
+            // We use full path here
+            // Querying command line of remote processes in Windows requires either WMI or ReadProcessMemory
+            exe->length = bufSize;
+            if (exePath) ffStrbufSet(exePath, exe);
         }
+        else
+            return false;
     }
     if(pname && exeName)
     {
@@ -77,7 +79,6 @@ static bool getProcessInfo(uint32_t pid, uint32_t* ppid, FFstrbuf* pname, FFstrb
         ffStrbufSetS(pname, *exeName);
     }
 
-    CloseHandle(hProcess);
     return true;
 }
 
@@ -85,9 +86,9 @@ bool fftsGetShellVersion(FFstrbuf* exe, const char* exeName, FFstrbuf* version);
 
 static uint32_t getShellInfo(FFShellResult* result, uint32_t pid)
 {
-    uint32_t ppid;
+    uint32_t ppid = 0;
 
-    while (pid != 0 && getProcessInfo(pid, &ppid, &result->processName, &result->exe, &result->exeName))
+    while (pid != 0 && getProcessInfo(pid, &ppid, &result->processName, &result->exe, &result->exeName, &result->exePath, NULL))
     {
         ffStrbufSet(&result->prettyName, &result->processName);
         if(ffStrbufEndsWithIgnCaseS(&result->prettyName, ".exe"))
@@ -103,7 +104,8 @@ static uint32_t getShellInfo(FFShellResult* result, uint32_t pid)
             ffStrbufIgnCaseEqualS(&result->prettyName, "gdb")           ||
             ffStrbufIgnCaseEqualS(&result->prettyName, "lldb")          ||
             ffStrbufIgnCaseEqualS(&result->prettyName, "guake-wrapped") ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "fastfetch")     || //scoop warps the real binaries with a "shim" exe
+            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")       ||
             ffStrbufStartsWithIgnCaseS(&result->prettyName, "ConEmu") // https://github.com/fastfetch-cli/fastfetch/issues/488#issuecomment-1619982014
@@ -116,9 +118,6 @@ static uint32_t getShellInfo(FFShellResult* result, uint32_t pid)
             continue;
         }
 
-        ffStrbufClear(&result->version);
-        fftsGetShellVersion(&result->exe, result->prettyName.chars, &result->version);
-
         result->pid = pid;
         result->ppid = ppid;
 
@@ -187,7 +186,7 @@ static bool getTerminalFromEnv(FFTerminalResult* result)
         //ConEmu
         uint32_t pid = (uint32_t) strtoul(term, NULL, 10);
         result->pid = pid;
-        if(getProcessInfo(pid, NULL, &result->processName, &result->exe, &result->exeName))
+        if(getProcessInfo(pid, NULL, &result->processName, &result->exe, &result->exeName, &result->exePath, NULL))
         {
             ffStrbufSet(&result->prettyName, &result->processName);
             if(ffStrbufEndsWithIgnCaseS(&result->prettyName, ".exe"))
@@ -243,12 +242,8 @@ static bool detectDefaultTerminal(FFTerminalResult* result)
     DWORD bufSize = 80;
     if (RegGetValueW(HKEY_CURRENT_USER, L"Console\\%%Startup", L"DelegationTerminal", RRF_RT_REG_SZ, NULL, uuid, &bufSize) == ERROR_SUCCESS)
     {
-        if(wcscmp(uuid, L"{00000000-0000-0000-0000-000000000000}") == 0)
-        {
-            // Let Windows decide
-            return false;
-        }
-        if(wcscmp(uuid, L"{B23D10C0-E52E-411E-9D5B-C09FDF709C7D}") == 0)
+        if(wcscmp(uuid, L"{00000000-0000-0000-0000-000000000000}") == 0 || // Let Windows decide
+            wcscmp(uuid, L"{B23D10C0-E52E-411E-9D5B-C09FDF709C7D}") == 0) // Conhost
         {
             goto conhost;
         }
@@ -296,27 +291,13 @@ conhost:
 
 static uint32_t getTerminalInfo(FFTerminalResult* result, uint32_t pid)
 {
-    uint32_t ppid;
+    uint32_t ppid = 0;
+    bool hasGui;
 
-    while (pid != 0 && getProcessInfo(pid, &ppid, &result->processName, &result->exe, &result->exeName))
+    while (pid != 0 && getProcessInfo(pid, &ppid, &result->processName, &result->exe, &result->exeName, &result->exePath, &hasGui))
     {
-        ffStrbufSet(&result->prettyName, &result->processName);
-        if(ffStrbufEndsWithIgnCaseS(&result->prettyName, ".exe"))
-            ffStrbufSubstrBefore(&result->prettyName, result->prettyName.length - 4);
-
-        if(
-            ffStrbufIgnCaseEqualS(&result->prettyName, "pwsh")            ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "cmd")             ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "bash")            ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "zsh")             ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "fish")            ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "nu")              ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "powershell")      ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "powershell_ise")  ||
-            ffStrbufIgnCaseEqualS(&result->prettyName, "wsl")             || // running inside wsl
-            ffStrbufIgnCaseEqualS(&result->prettyName, "servercoreshell") || // ServerCore Shell Launcher
-            ffStrbufStartsWithIgnCaseS(&result->prettyName, "ConEmuC") // wrapper process of ConEmu
-        ) {
+        if(!hasGui)
+        {
             //We are nested shell
             ffStrbufClear(&result->processName);
             ffStrbufClear(&result->prettyName);
@@ -326,20 +307,21 @@ static uint32_t getTerminalInfo(FFTerminalResult* result, uint32_t pid)
             continue;
         }
 
+        ffStrbufSet(&result->prettyName, &result->processName);
+        if(ffStrbufEndsWithIgnCaseS(&result->prettyName, ".exe"))
+            ffStrbufSubstrBefore(&result->prettyName, result->prettyName.length - 4);
+
         if(ffStrbufIgnCaseEqualS(&result->prettyName, "sihost")           ||
             ffStrbufIgnCaseEqualS(&result->prettyName, "explorer")
         ) {
             // A CUI program created by Windows Explorer will spawn a conhost as its child.
             // However the conhost process is just a placeholder;
             // The true terminal can be Windows Terminal or others.
-            if (!getTerminalFromEnv(result) && !detectDefaultTerminal(result))
-            {
-                ffStrbufClear(&result->processName);
-                ffStrbufClear(&result->prettyName);
-                ffStrbufClear(&result->exe);
-                result->exeName = "";
-                return 0;
-            }
+            ffStrbufClear(&result->processName);
+            ffStrbufClear(&result->prettyName);
+            ffStrbufClear(&result->exe);
+            result->exeName = "";
+            return 0;
         }
         else
         {
@@ -380,19 +362,30 @@ const FFShellResult* ffDetectShell(void)
     init = true;
 
     ffStrbufInit(&result.processName);
-    ffStrbufInitA(&result.exe, 128);
+    ffStrbufInitA(&result.exe, MAX_PATH);
     result.exeName = "";
+    ffStrbufInit(&result.exePath);
     ffStrbufInit(&result.prettyName);
     ffStrbufInit(&result.version);
     result.pid = 0;
     result.ppid = 0;
+    result.tty = -1;
 
     uint32_t ppid;
-    if(!getProcessInfo(0, &ppid, NULL, NULL, NULL))
+    if(!getProcessInfo(0, &ppid, NULL, NULL, NULL, NULL, NULL))
         return &result;
 
     ppid = getShellInfo(&result, ppid);
-    setShellInfoDetails(&result);
+
+    if (result.processName.length > 0)
+    {
+        setShellInfoDetails(&result);
+        char tmp[MAX_PATH];
+        strcpy(tmp, result.exeName);
+        char* ext = strrchr(tmp, '.');
+        if (ext) *ext = '\0';
+        fftsGetShellVersion(&result.exe, tmp, &result.version);
+    }
 
     return &result;
 }
@@ -406,8 +399,9 @@ const FFTerminalResult* ffDetectTerminal(void)
     init = true;
 
     ffStrbufInit(&result.processName);
-    ffStrbufInitA(&result.exe, 128);
+    ffStrbufInitA(&result.exe, MAX_PATH);
     result.exeName = "";
+    ffStrbufInit(&result.exePath);
     ffStrbufInit(&result.prettyName);
     ffStrbufInit(&result.version);
     result.pid = 0;
@@ -419,10 +413,14 @@ const FFTerminalResult* ffDetectTerminal(void)
 
     if(result.processName.length == 0)
         getTerminalFromEnv(&result);
+    if(result.processName.length == 0)
+        detectDefaultTerminal(&result);
 
-    setTerminalInfoDetails(&result);
-
-    fftsGetTerminalVersion(&result.processName, &result.exe, &result.version);
+    if(result.processName.length > 0)
+    {
+        setTerminalInfoDetails(&result);
+        fftsGetTerminalVersion(&result.processName, &result.exe, &result.version);
+    }
 
     return &result;
 }

src/detection/terminalsize/terminalsize_linux.c

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

src/detection/terminalsize/terminalsize_windows.c

@@ -14,7 +14,7 @@ bool ffDetectTerminalSize(FFTerminalSizeResult* result)
         }
         else
         {
-            ffGetTerminalResponse("\033[18t", "\033[8;%hu;%hut", &result->rows, &result->columns);
+            ffGetTerminalResponse("\e[18t", "\e[8;%hu;%hut", &result->rows, &result->columns);
         }
     }
 

src/detection/terminaltheme/terminaltheme.c

@@ -0,0 +1,91 @@
+#include "terminaltheme.h"
+#include "common/io/io.h"
+#include "util/stringUtils.h"
+
+#include <inttypes.h>
+
+static bool detectByEscapeCode(FFTerminalThemeResult* result)
+{
+    int command = 0;
+
+    if (ffGetTerminalResponse("\e]10;?\e\\", "\e]%d;rgb:%" SCNx16 "/%" SCNx16 "/%" SCNx16 "\e\\", &command, &result->fg.r, &result->fg.g, &result->fg.b) == NULL)
+    {
+        if (command != 10)
+            return false;
+        if (result->fg.r > 0x0100 || result->fg.g > 0x0100 || result->fg.b > 0x0100)
+            result->fg.r /= 0x0100, result->fg.g /= 0x0100, result->fg.b /= 0x0100;
+    }
+    else
+        return false;
+
+    if (ffGetTerminalResponse("\e]11;?\e\\", "\e]%d;rgb:%" SCNx16 "/%" SCNx16 "/%" SCNx16 "\e\\", &command, &result->bg.r, &result->bg.g, &result->bg.b) == NULL)
+    {
+        if (command != 11)
+            return false;
+        if (result->bg.r > 0x0100 || result->bg.g > 0x0100 || result->bg.b > 0x0100)
+            result->bg.r /= 0x0100, result->bg.g /= 0x0100, result->bg.b /= 0x0100;
+    }
+    else
+        return false;
+
+    return true;
+}
+
+static FFTerminalThemeColor fgbgToColor(int num)
+{
+    // https://github.com/dalance/termbg/blob/13c478a433fa182e65c401d26a1e7792a7f7f453/src/lib.rs#L251
+    switch (num)
+    {
+        case  0: return (FFTerminalThemeColor){  0,   0,   0, false}; // black
+        case  1: return (FFTerminalThemeColor){205,   0,   0, false}; // red
+        case  2: return (FFTerminalThemeColor){  0, 205,   0, false}; // green
+        case  3: return (FFTerminalThemeColor){205, 205,   0, false}; // yellow
+        case  4: return (FFTerminalThemeColor){  0,   0, 238, false}; // blue
+        case  5: return (FFTerminalThemeColor){205,   0, 205, false}; // magenta
+        case  6: return (FFTerminalThemeColor){  0, 205, 205, false}; // cyan
+        case  7: return (FFTerminalThemeColor){229, 229, 229, false}; // white
+
+        case  8: return (FFTerminalThemeColor){127, 127, 127, false}; // bright black
+        case  9: return (FFTerminalThemeColor){255,   0,   0, false}; // bright red
+        case 10: return (FFTerminalThemeColor){  0, 255,   0, false}; // bright green
+        case 11: return (FFTerminalThemeColor){255, 255,   0, false}; // bright yellow
+        case 12: return (FFTerminalThemeColor){ 92,  92, 255, false}; // bright blue
+        case 13: return (FFTerminalThemeColor){255,   0, 255, false}; // bright magenta
+        case 14: return (FFTerminalThemeColor){  0, 255, 255, false}; // bright cyan
+        case 15: return (FFTerminalThemeColor){255, 255, 255, false}; // bright white
+
+        default: return (FFTerminalThemeColor){  0,   0,   0, false}; // invalid
+    }
+}
+
+static bool detectByEnv(FFTerminalThemeResult* result)
+{
+    const char* color = getenv("COLORFGBG"); // 7;0
+
+    if (!ffStrSet(color))
+        return false;
+
+    int f, g;
+    if (sscanf(color, "%d;%d", &f, &g) != 2)
+        return false;
+
+    result->fg = fgbgToColor(f);
+    result->bg = fgbgToColor(g);
+    return true;
+}
+
+static inline bool detectColor(FFTerminalThemeResult* result)
+{
+    if (detectByEscapeCode(result))
+        return true;
+
+    return detectByEnv(result);
+}
+
+bool ffDetectTerminalTheme(FFTerminalThemeResult* result)
+{
+    if (!detectColor(result)) return false;
+    result->fg.dark = result->fg.r * 299 + result->fg.g * 587 + result->fg.b * 114 < 128000;
+    result->bg.dark = result->bg.r * 299 + result->bg.g * 587 + result->bg.b * 114 < 128000;
+    return true;
+}

src/detection/terminaltheme/terminaltheme.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "fastfetch.h"
+
+typedef struct FFTerminalThemeColor
+{
+    uint16_t r;
+    uint16_t g;
+    uint16_t b;
+    bool dark;
+} FFTerminalThemeColor;
+
+typedef struct FFTerminalThemeResult
+{
+    FFTerminalThemeColor fg;
+    FFTerminalThemeColor bg;
+} FFTerminalThemeResult;
+
+bool ffDetectTerminalTheme(FFTerminalThemeResult* result);

src/detection/wifi/wifi_linux.c

@@ -250,7 +250,11 @@ static const char* detectWifiWithIoctls(FFlist* result)
         item->conn.txRate = 0.0/0.0;
 
         ffStrbufSetF(&path, "/sys/class/net/%s/operstate", i->if_name);
-        if (!ffAppendFileBuffer(path.chars, &item->inf.status) || !ffStrbufEqualS(&item->inf.status, "up\n"))
+        if (!ffAppendFileBuffer(path.chars, &item->inf.status))
+            continue;
+
+        ffStrbufTrimRightSpace(&item->inf.status);
+        if (!ffStrbufEqualS(&item->inf.status, "up"))
             continue;
 
         FF_AUTO_CLOSE_FD int sock = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);

src/fastfetch.c

@@ -7,6 +7,7 @@
 #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"
 
@@ -299,7 +300,7 @@ static void listModules(bool pretty)
         {
             ++count;
             if (pretty)
-                printf("%d)%s%-13s: %s\n", count, count > 9 ? " " : "  ", (*modules)->name, (*modules)->description);
+                printf("%d)%s%-14s: %s\n", count, count > 9 ? " " : "  ", (*modules)->name, (*modules)->description);
             else
                 printf("%s:%s\n", (*modules)->name, (*modules)->description);
         }
@@ -482,10 +483,8 @@ static void optionParseConfigFile(FFdata* data, const char* key, const char* val
     if(isJsonConfig ? parseJsoncFile(value) : parseConfigFile(data, value))
         return;
 
-    FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateA(128);
-    if (ffPathExpandEnv(value, &absolutePath))
     {
-        bool success = isJsonConfig ? parseJsoncFile(absolutePath.chars) : parseConfigFile(data, absolutePath.chars);
+        bool success = isJsonConfig ? parseJsoncFile(value) : parseConfigFile(data, value);
 
         if(success)
             return;
@@ -493,6 +492,7 @@ static void optionParseConfigFile(FFdata* data, const char* key, const char* val
 
     //Try to load as a relative path
 
+    FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateA(128);
     FF_LIST_FOR_EACH(FFstrbuf, path, instance.state.platform.dataDirs)
     {
         //We need to copy it, because if a config file loads a config file, the value of path must be unchanged
@@ -831,7 +831,14 @@ static void writeConfigFile(FFdata* data, const FFstrbuf* filename)
         yyjson_mut_write_fp(stdout, doc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES, NULL, NULL);
     else
     {
-        if (yyjson_mut_write_file(filename->chars, doc, YYJSON_WRITE_INF_AND_NAN_AS_NULL | YYJSON_WRITE_PRETTY_TWO_SPACES, NULL, NULL))
+        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);
+        if (!str)
+        {
+            printf("Error: failed to generate config file\n");
+            exit(1);
+        }
+        if (ffWriteFileData(filename->chars, len, str))
             printf("The generated config file has been written in `%s`\n", filename->chars);
         else
         {

src/logo/ascii/fedora_kinoite.txt

@@ -0,0 +1,18 @@
+ ,clll:.$2          .,::::::::::::'
+$1:ooooooo$2        .;::::::::::::::
+$1looooooo$2       ,:::::::::::::::'
+$1looooooo$2      .::::::::::::::::
+$1looooooo$2      ;:::::::::::::::.
+$1looooooo$2     .::::::::::::::::
+$1looooool$2;;;;,::::::::::::::::
+$1looool$2::,   .::::::::::::::
+$1looooc$2::     ;::
+$1looooc$2::;.  .::;
+$1loooool$2:::::::::::.
+$1looooooo$2.    .::::::'
+$1looooooo$2       .::::::,;,..
+$1looooooo$2          :::;' ';:;.
+$1looooooo$2          :::     :::
+$1cooooooo$2          .::'   '::.
+$1 .ooooc $2            ::, ,::
+                      ''''

src/logo/ascii/fedora_sericea.txt

@@ -0,0 +1,17 @@
+              :oooo,  .','
+      .';;;.;oooooooolooooo'
+     coooooooooooooooooooooooolc'
+  .':oooooooooooo$2ll$1ooooooooooooool
+.oooooooooooooooo$2ll$1oooooooooooo$2l$1ool
+ooooooooooooooooo$2ll$1ooooooooooo$2ll$1oo'
+ oooo$2l$1oooooooooo$2lll$1ooooooooo$2lll$1oo
+ .ooooo$2lll$1ooooo$2lll$1ooooooooo$2lll$1ool
+ .ooooooo$2lll$1oo$2llll$1oooo$2lllll$1ooooo:
+  'oooooooo$2llllllllllll$1oooooooo'
+     .c,.oo$2lllll$1oooooooo.$2
+           'll;
+           'll.
+           lll
+           lll
+          ;ll,
+          .l:

src/logo/ascii/fedora_silverblue.txt

@@ -0,0 +1,17 @@
+    .;ooooooooooooooooooooooooooo.
+  ,dddddddddddddddddddddddddddddd'$3;
+$1 lddddddddddddddddddddddddddddd'$3;;;
+$1ddddd$2,XXX.$1ddddd$2,XXX.$1dddd'$2,XXX.$3;;;;;
+$1ddddd$2XX$1x$2XX$1ddddd$2XX$1x$2XX$1ddd'$2,XX$3x$2XX$3;;;;;
+$1ddddd$2'XXX'$1ddddd$2'XXX'$1dd'$2XXXXXX'$3;;;;;
+$1dddddd$2;X;$1ddddddd$2;X:$1d'$2XXX$3;;;;;;;;;;;
+$1dddddd$2;X;$1ddddddd$2;X:$2XXX$3;;;;;;;;;;;;;
+$1dddddd$2;X;$1dddddd'$2;XXX,,,,,,XXX.$3;;;;;
+$1dddddd$2;X;$1dddd'$2XXXX$2XXXXXXXXX$3x$2XX$3;;;;;
+$1dddddd$2;X;$1dd'$2XXX$3;;;;;;;;;;;$2XXX$3;;;;;;
+$1dddddd$2;X;$1'$2XXX$3;;;;;;;;;;;;;;;;;;;;;;
+$1dddddd$2;XXXXX,,,,,,,,,,,,,;XXX:$3;;;;;
+$1dddddd$2:XXXXXXXXXXXXXXXXXXXX$3x$2XX$3;;;;;
+$1ddddd'$3;;;;;;;;;;;;;;;;;;;$2'XXX'$3;;;;'
+$1ddd'$3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+$1o'$3;;;;;;;;;;;;;;;;;;;;;;;;;;;;'

src/logo/builtin.c

@@ -974,7 +974,7 @@ static const FFlogo C[] = {
     // ContainerLinux
     {
         .names = {"ContainerLinux", "Container Linux", "Container Linux by CoreOS"},
-        .lines = FASTFETCH_DATATEXT_LOGO_CONTAINER_LINUX,
+        .lines = FASTFETCH_DATATEXT_LOGO_FEDORA_COREOS,
         .colors = {
             FF_COLOR_FG_BLUE,
             FF_COLOR_FG_WHITE,
@@ -1468,6 +1468,68 @@ static const FFlogo F[] = {
         .colorKeys = FF_COLOR_FG_BLUE,
         .colorTitle = FF_COLOR_FG_BLUE,
     },
+    // FedoraSilverblue
+    {
+        .names = {"Fedora_silverblue", "fedora-silverblue", "fedora-linux-silverblue", "fedora-linux_silverblue"},
+        .type = FF_LOGO_LINE_TYPE_ALTER_BIT,
+        .lines = FASTFETCH_DATATEXT_LOGO_FEDORA_SILVERBLUE,
+        .colors = {
+            FF_COLOR_FG_BLUE,
+            FF_COLOR_FG_WHITE,
+            FF_COLOR_FG_CYAN,
+        },
+        .colorKeys = FF_COLOR_FG_BLUE,
+        .colorTitle = FF_COLOR_FG_BLUE,
+    },
+    // FedoraKinoite
+    {
+        .names = {"Fedora_kinoite", "fedora-kinoite", "fedora-linux-kinoite", "fedora-linux_kinoite"},
+        .type = FF_LOGO_LINE_TYPE_ALTER_BIT,
+        .lines = FASTFETCH_DATATEXT_LOGO_FEDORA_KINOITE,
+        .colors = {
+            FF_COLOR_FG_BLUE,
+            FF_COLOR_FG_WHITE,
+        },
+        .colorKeys = FF_COLOR_FG_BLUE,
+        .colorTitle = FF_COLOR_FG_BLUE,
+    },
+    // FedoraSericea
+    {
+        .names = {"Fedora_sericea", "fedora-sericea", "fedora-linux-sericea", "fedora-linux_sericea"},
+        .type = FF_LOGO_LINE_TYPE_ALTER_BIT,
+        .lines = FASTFETCH_DATATEXT_LOGO_FEDORA_SERICEA,
+        .colors = {
+            FF_COLOR_FG_BLUE,
+            FF_COLOR_FG_WHITE,
+        },
+        .colorKeys = FF_COLOR_FG_BLUE,
+        .colorTitle = FF_COLOR_FG_BLUE,
+    },
+    // FedoraOnyx placeholder - Currently does not have a logo
+    //{
+        //.names = {"Fedora_onyx", "fedora-onyx", "fedora-linux-onyx", "fedora-linux_onyx"},
+        //.type = FF_LOGO_LINE_TYPE_ALTER_BIT,
+        //.lines = FASTFETCH_DATATEXT_LOGO_FEDORA_ONYX,
+        //.colors = {
+            //FF_COLOR_FG_BLUE,
+            //FF_COLOR_FG_WHITE,
+        //},
+        //.colorKeys = FF_COLOR_FG_BLUE,
+        //.colorTitle = FF_COLOR_FG_BLUE,
+    //},
+    // FedoraCoreOS
+    {
+        .names = {"Fedora_coreos", "fedora-coreos", "fedora-linux-coreos", "fedora-linux_coreos"},
+        .type = FF_LOGO_LINE_TYPE_ALTER_BIT,
+        .lines = FASTFETCH_DATATEXT_LOGO_FEDORA_COREOS,
+        .colors = {
+            FF_COLOR_FG_BLUE,
+            FF_COLOR_FG_WHITE,
+            FF_COLOR_FG_RED,
+        },
+        .colorKeys = FF_COLOR_FG_BLUE,
+        .colorTitle = FF_COLOR_FG_WHITE,
+    },
     // FemboyOS
     {
         .names = {"FemboyOS"},

src/modules/battery/battery.c

@@ -1,6 +1,6 @@
 #include "common/printing.h"
 #include "common/jsonconfig.h"
-#include "common/bar.h"
+#include "common/percent.h"
 #include "common/parsing.h"
 #include "detection/battery/battery.h"
 #include "modules/battery/battery.h"
@@ -24,12 +24,7 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
         {
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                if(result->capacity <= 20)
-                    ffAppendPercentBar(&str, result->capacity, 100, 100, 0);
-                else if(result->capacity <= 50)
-                    ffAppendPercentBar(&str, result->capacity, 100, 0, 100);
-                else
-                    ffAppendPercentBar(&str, result->capacity, 0, 100, 100);
+                ffPercentAppendBar(&str, result->capacity, options->percent);
             }
 
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
@@ -37,7 +32,7 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
                 if(str.length > 0)
                     ffStrbufAppendC(&str, ' ');
 
-                ffAppendPercentNum(&str, result->capacity, 51, 21, str.length > 0);
+                ffPercentAppendNum(&str, result->capacity, options->percent, str.length > 0);
             }
         }
 
@@ -62,7 +57,7 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
     else
     {
         FF_STRBUF_AUTO_DESTROY capacityStr = ffStrbufCreate();
-        ffAppendPercentNum(&capacityStr, result->capacity, 51, 21, false);
+        ffPercentAppendNum(&capacityStr, result->capacity, options->percent, false);
         ffPrintFormat(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName},
@@ -127,6 +122,9 @@ bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, co
         }
     #endif
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -157,6 +155,9 @@ void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module)
             continue;
         }
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -175,6 +176,8 @@ void ffGenerateBatteryJsonConfig(FFBatteryOptions* options, yyjson_mut_doc* doc,
 
     if (options->temp != defaultOptions.temp)
         yyjson_mut_obj_add_bool(doc, module, "temp", options->temp);
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateBatteryJsonResult(FFBatteryOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -245,6 +248,7 @@ void ffInitBatteryOptions(FFBatteryOptions* options)
     );
     ffOptionInitModuleArg(&options->moduleArgs);
     options->temp = false;
+    options->percent = (FFPercentConfig) { 50, 20 };
 
     #ifdef _WIN32
         options->useSetupApi = false;

src/modules/battery/option.h

@@ -3,6 +3,7 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef struct FFBatteryOptions
 {
@@ -10,6 +11,7 @@ typedef struct FFBatteryOptions
     FFModuleArgs moduleArgs;
 
     bool temp;
+    FFPercentConfig percent;
 
     #ifdef _WIN32
         bool useSetupApi;

src/modules/bluetooth/bluetooth.c

@@ -1,3 +1,4 @@
+#include "common/percent.h"
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "detection/bluetooth/bluetooth.h"
@@ -11,23 +12,31 @@ static void printDevice(FFBluetoothOptions* options, const FFBluetoothResult* de
     if(options->moduleArgs.outputFormat.length == 0)
     {
         ffPrintLogoAndKey(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
-        ffStrbufWriteTo(&device->name, stdout);
 
-        if(device->battery > 0)
-            printf(" (%d%%)", device->battery);
+        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateCopy(&device->name);
 
-        if(!device->connected)
-            puts(" [disconnected]");
-        else
-            putchar('\n');
+        if (device->battery > 0 && device->battery <= 100)
+        {
+            if (buffer.length)
+                ffStrbufAppendC(&buffer, ' ');
+            ffPercentAppendNum(&buffer, device->battery, options->percent, buffer.length > 0);
+        }
+
+        if (!device->connected)
+            ffStrbufAppendS(&buffer, " [disconnected]");
+
+        ffStrbufPutTo(&buffer, stdout);
     }
     else
     {
+        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_FORMAT_ARG_TYPE_STRBUF, &device->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->address},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->type},
-            {FF_FORMAT_ARG_TYPE_UINT8, &device->battery}
+            {FF_FORMAT_ARG_TYPE_STRBUF, &percentageStr}
         });
     }
 }
@@ -86,6 +95,9 @@ bool ffParseBluetoothCommandOptions(FFBluetoothOptions* options, const char* key
         return true;
     }
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -108,6 +120,9 @@ void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module)
             continue;
         }
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -121,6 +136,8 @@ void ffGenerateBluetoothJsonConfig(FFBluetoothOptions* options, yyjson_mut_doc*
 
     if (options->showDisconnected != defaultOptions.showDisconnected)
         yyjson_mut_obj_add_bool(doc, module, "showDisconnected", options->showDisconnected);
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateBluetoothJsonResult(FF_MAYBE_UNUSED FFBluetoothOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -181,6 +198,7 @@ void ffInitBluetoothOptions(FFBluetoothOptions* options)
     );
     ffOptionInitModuleArg(&options->moduleArgs);
     options->showDisconnected = false;
+    options->percent = (FFPercentConfig) { 50, 20 };
 }
 
 void ffDestroyBluetoothOptions(FFBluetoothOptions* options)

src/modules/bluetooth/option.h

@@ -3,6 +3,7 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef struct FFBluetoothOptions
 {
@@ -10,4 +11,5 @@ typedef struct FFBluetoothOptions
     FFModuleArgs moduleArgs;
 
     bool showDisconnected;
+    FFPercentConfig percent;
 } FFBluetoothOptions;

src/modules/brightness/brightness.c

@@ -1,4 +1,4 @@
-#include "common/bar.h"
+#include "common/percent.h"
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "detection/brightness/brightness.h"
@@ -52,7 +52,7 @@ void ffPrintBrightness(FFBrightnessOptions* options)
 
             if (instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(&str, percent, 0, 100, 100);
+                ffPercentAppendBar(&str, percent, options->percent);
             }
 
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
@@ -60,7 +60,7 @@ void ffPrintBrightness(FFBrightnessOptions* options)
                 if(str.length > 0)
                     ffStrbufAppendC(&str, ' ');
 
-                ffAppendPercentNum(&str, percent, 10, 10, str.length > 0);
+                ffPercentAppendNum(&str, percent, options->percent, str.length > 0);
             }
 
             ffStrbufPutTo(&str, stdout);
@@ -68,7 +68,7 @@ void ffPrintBrightness(FFBrightnessOptions* options)
         else
         {
             FF_STRBUF_AUTO_DESTROY valueStr = ffStrbufCreate();
-            ffAppendPercentNum(&valueStr, percent, 10, 10, false);
+            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_FORMAT_ARG_TYPE_STRBUF, &valueStr},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &item->name},
@@ -97,6 +97,9 @@ bool ffParseBrightnessCommandOptions(FFBrightnessOptions* options, const char* k
         return true;
     }
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -119,6 +122,9 @@ void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* modul
             continue;
         }
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -132,6 +138,8 @@ void ffGenerateBrightnessJsonConfig(FFBrightnessOptions* options, yyjson_mut_doc
 
     if (defaultOptions.ddcciSleep != options->ddcciSleep)
         yyjson_mut_obj_add_uint(doc, module, "ddcciSleep", options->ddcciSleep);
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateBrightnessJsonResult(FF_MAYBE_UNUSED FFBrightnessOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -197,6 +205,7 @@ void ffInitBrightnessOptions(FFBrightnessOptions* options)
     ffOptionInitModuleArg(&options->moduleArgs);
 
     options->ddcciSleep = 10;
+    options->percent = (FFPercentConfig) { 100, 100 };
 }
 
 void ffDestroyBrightnessOptions(FFBrightnessOptions* options)

src/modules/brightness/option.h

@@ -3,6 +3,7 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef struct FFBrightnessOptions
 {
@@ -10,4 +11,5 @@ typedef struct FFBrightnessOptions
     FFModuleArgs moduleArgs;
 
     uint32_t ddcciSleep; // ms
+    FFPercentConfig percent;
 } FFBrightnessOptions;

src/modules/cpuusage/cpuusage.c

@@ -1,6 +1,6 @@
 #include "common/printing.h"
 #include "common/jsonconfig.h"
-#include "common/bar.h"
+#include "common/percent.h"
 #include "detection/cpuusage/cpuusage.h"
 #include "modules/cpuusage/cpuusage.h"
 #include "util/stringUtils.h"
@@ -52,12 +52,12 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options)
         if (!options->separate)
         {
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
-                ffAppendPercentBar(&str, avgValue, 0, 50, 80);
+                ffPercentAppendBar(&str, avgValue, options->percent);
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
             {
                 if(str.length > 0)
                     ffStrbufAppendC(&str, ' ');
-                ffAppendPercentNum(&str, avgValue, 50, 80, str.length > 0);
+                ffPercentAppendNum(&str, avgValue, options->percent, str.length > 0);
             }
         }
         else
@@ -66,7 +66,7 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options)
             {
                 if(str.length > 0)
                     ffStrbufAppendC(&str, ' ');
-                ffAppendPercentNum(&str, *percent, 50, 80, false);
+                ffPercentAppendNum(&str, *percent, options->percent, false);
             }
         }
         ffStrbufPutTo(&str, stdout);
@@ -74,11 +74,11 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options)
     else
     {
         FF_STRBUF_AUTO_DESTROY avgStr = ffStrbufCreate();
-        ffAppendPercentNum(&avgStr, avgValue, 50, 80, false);
+        ffPercentAppendNum(&avgStr, avgValue, options->percent, false);
         FF_STRBUF_AUTO_DESTROY minStr = ffStrbufCreate();
-        ffAppendPercentNum(&minStr, minValue, 50, 80, false);
+        ffPercentAppendNum(&minStr, minValue, options->percent, false);
         FF_STRBUF_AUTO_DESTROY maxStr = ffStrbufCreate();
-        ffAppendPercentNum(&maxStr, maxValue, 50, 80, false);
+        ffPercentAppendNum(&maxStr, maxValue, options->percent, false);
         ffPrintFormat(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, FF_CPUUSAGE_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &avgStr},
             {FF_FORMAT_ARG_TYPE_STRBUF, &maxStr},
@@ -102,6 +102,9 @@ bool ffParseCPUUsageCommandOptions(FFCPUUsageOptions* options, const char* key,
         return true;
     }
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -124,6 +127,9 @@ void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module)
             continue;
         }
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -137,6 +143,8 @@ void ffGenerateCPUUsageJsonConfig(FFCPUUsageOptions* options, yyjson_mut_doc* do
 
     if (options->separate != defaultOptions.separate)
         yyjson_mut_obj_add_bool(doc, module, "separate", options->separate);
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateCPUUsageJsonResult(FF_MAYBE_UNUSED FFCPUUsageOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -182,6 +190,7 @@ void ffInitCPUUsageOptions(FFCPUUsageOptions* options)
     );
     ffOptionInitModuleArg(&options->moduleArgs);
     options->separate = false;
+    options->percent = (FFPercentConfig) { 50, 80 };
 }
 
 void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options)

src/modules/cpuusage/option.h

@@ -3,6 +3,7 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef struct FFCPUUsageOptions
 {
@@ -10,4 +11,5 @@ typedef struct FFCPUUsageOptions
     FFModuleArgs moduleArgs;
 
     bool separate;
+    FFPercentConfig percent;
 } FFCPUUsageOptions;

src/modules/disk/disk.c

@@ -1,7 +1,7 @@
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "common/parsing.h"
-#include "common/bar.h"
+#include "common/percent.h"
 #include "detection/disk/disk.h"
 #include "modules/disk/disk.h"
 #include "util/stringUtils.h"
@@ -59,7 +59,7 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk)
         {
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(&str, bytesPercentage, 0, 50, 80);
+                ffPercentAppendBar(&str, bytesPercentage, options->percent);
                 ffStrbufAppendC(&str, ' ');
             }
 
@@ -68,7 +68,7 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk)
 
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
             {
-                ffAppendPercentNum(&str, bytesPercentage, 50, 80, str.length > 0);
+                ffPercentAppendNum(&str, bytesPercentage, options->percent, str.length > 0);
                 ffStrbufAppendC(&str, ' ');
             }
         }
@@ -104,10 +104,10 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk)
     else
     {
         FF_STRBUF_AUTO_DESTROY bytesPercentageStr = ffStrbufCreate();
-        ffAppendPercentNum(&bytesPercentageStr, bytesPercentage, 50, 80, false);
+        ffPercentAppendNum(&bytesPercentageStr, bytesPercentage, options->percent, false);
         FF_STRBUF_AUTO_DESTROY filesPercentageStr = ffStrbufCreate();
         double filesPercentage = disk->filesTotal > 0 ? ((double) disk->filesUsed / (double) disk->filesTotal) * 100.0 : 0;
-        ffAppendPercentNum(&filesPercentageStr, filesPercentage, 50, 80, false);
+        ffPercentAppendNum(&filesPercentageStr, filesPercentage, options->percent, false);
 
         bool isExternal = !!(disk->type & FF_DISK_VOLUME_TYPE_EXTERNAL_BIT);
         bool isHidden = !!(disk->type & FF_DISK_VOLUME_TYPE_HIDDEN_BIT);
@@ -278,6 +278,9 @@ bool ffParseDiskCommandOptions(FFDiskOptions* options, const char* key, const ch
         return true;
     }
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -354,6 +357,9 @@ void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module)
             continue;
         }
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -388,6 +394,8 @@ void ffGenerateDiskJsonConfig(FFDiskOptions* options, yyjson_mut_doc* doc, yyjso
 
     if (defaultOptions.calcType != options->calcType)
         yyjson_mut_obj_add_bool(doc, module, "useAvailable", options->calcType == FF_DISK_CALC_TYPE_AVAILABLE);
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateDiskJsonResult(FFDiskOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -476,6 +484,7 @@ void ffInitDiskOptions(FFDiskOptions* options)
     ffStrbufInit(&options->folders);
     options->showTypes = FF_DISK_VOLUME_TYPE_REGULAR_BIT | FF_DISK_VOLUME_TYPE_EXTERNAL_BIT | FF_DISK_VOLUME_TYPE_READONLY_BIT;
     options->calcType = FF_DISK_CALC_TYPE_FREE;
+    options->percent = (FFPercentConfig) { 50, 80 };
 }
 
 void ffDestroyDiskOptions(FFDiskOptions* options)

src/modules/disk/option.h

@@ -3,6 +3,7 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef enum FFDiskVolumeType
 {
@@ -29,4 +30,5 @@ typedef struct FFDiskOptions
     FFstrbuf folders;
     FFDiskVolumeType showTypes;
     FFDiskCalcType calcType;
+    FFPercentConfig percent;
 } FFDiskOptions;

src/modules/gamepad/gamepad.c

@@ -1,4 +1,4 @@
-#include "common/bar.h"
+#include "common/percent.h"
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "detection/gamepad/gamepad.h"
@@ -11,21 +11,27 @@ static void printDevice(FFGamepadOptions* options, const FFGamepadDevice* device
 {
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateCopy(&device->name);
         ffPrintLogoAndKey(FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
+
+        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateCopy(&device->name);
+
         if (device->battery > 0 && device->battery <= 100)
         {
-            ffStrbufAppendC(&buffer, ' ');
-            ffAppendPercentNum(&buffer, device->battery, 51, 21, true);
+            if (buffer.length)
+                ffStrbufAppendC(&buffer, ' ');
+            ffPercentAppendNum(&buffer, device->battery, options->percent, buffer.length > 0);
         }
         ffStrbufPutTo(&buffer, stdout);
     }
     else
     {
+        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_FORMAT_ARG_TYPE_STRBUF, &device->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->serial},
-            {FF_FORMAT_ARG_TYPE_UINT8, &device->battery},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &percentageStr},
         });
     }
 }
@@ -64,6 +70,9 @@ bool ffParseGamepadCommandOptions(FFGamepadOptions* options, const char* key, co
     if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
         return true;
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -80,6 +89,9 @@ void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module)
         if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
             continue;
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -90,6 +102,8 @@ void ffGenerateGamepadJsonConfig(FFGamepadOptions* options, yyjson_mut_doc* doc,
     ffInitGamepadOptions(&defaultOptions);
 
     ffJsonConfigGenerateModuleArgsConfig(doc, module, &defaultOptions.moduleArgs, &options->moduleArgs);
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateGamepadJsonResult(FF_MAYBE_UNUSED FFGamepadOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -127,10 +141,10 @@ void ffGenerateGamepadJsonResult(FF_MAYBE_UNUSED FFGamepadOptions* options, yyjs
 
 void ffPrintGamepadHelpFormat(void)
 {
-    ffPrintModuleFormatHelp(FF_GAMEPAD_MODULE_NAME, "{1}", FF_GAMEPAD_NUM_FORMAT_ARGS, (const char* []) {
+    ffPrintModuleFormatHelp(FF_GAMEPAD_MODULE_NAME, "{1} ({3})", FF_GAMEPAD_NUM_FORMAT_ARGS, (const char* []) {
         "Name",
         "Serial number",
-        "Battery",
+        "Battery percentage",
     });
 }
 
@@ -148,6 +162,7 @@ void ffInitGamepadOptions(FFGamepadOptions* options)
         ffGenerateGamepadJsonConfig
     );
     ffOptionInitModuleArg(&options->moduleArgs);
+    options->percent = (FFPercentConfig) { 50, 20 };
 }
 
 void ffDestroyGamepadOptions(FFGamepadOptions* options)

src/modules/gamepad/option.h

@@ -8,4 +8,6 @@ typedef struct FFGamepadOptions
 {
     FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
+
+    FFPercentConfig percent;
 } FFGamepadOptions;

src/modules/gpu/gpu.c

@@ -1,4 +1,4 @@
-#include "common/bar.h"
+#include "common/percent.h"
 #include "common/parsing.h"
 #include "common/printing.h"
 #include "common/jsonconfig.h"
@@ -60,7 +60,7 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu
             if(gpu->dedicated.used != FF_GPU_VMEM_SIZE_UNSET)
             {
                 ffStrbufAppendS(&output, ", ");
-                ffAppendPercentNum(&output, (double) gpu->dedicated.used / (double) gpu->dedicated.total * 100.0, 50, 80, false);
+                ffPercentAppendNum(&output, (double) gpu->dedicated.used / (double) gpu->dedicated.total * 100.0, options->percent, false);
             }
             ffStrbufAppendC(&output, ')');
         }
@@ -162,6 +162,9 @@ bool ffParseGPUCommandOptions(FFGPUOptions* options, const char* key, const char
         });
     }
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -212,6 +215,9 @@ void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module)
             continue;
         }
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -247,6 +253,8 @@ void ffGenerateGPUJsonConfig(FFGPUOptions* options, yyjson_mut_doc* doc, yyjson_
                 break;
         }
     }
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateGPUJsonResult(FFGPUOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -363,6 +371,7 @@ void ffInitGPUOptions(FFGPUOptions* options)
     options->forceVulkan = false;
     options->temp = false;
     options->hideType = FF_GPU_TYPE_UNKNOWN;
+    options->percent = (FFPercentConfig) { 50, 80 };
 }
 
 void ffDestroyGPUOptions(FFGPUOptions* options)

src/modules/gpu/option.h

@@ -3,6 +3,7 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef enum FFGPUType
 {
@@ -20,4 +21,5 @@ typedef struct FFGPUOptions
     bool temp;
     bool driverSpecific;
     bool forceVulkan;
+    FFPercentConfig percent;
 } FFGPUOptions;

src/modules/memory/memory.c

@@ -1,7 +1,7 @@
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "common/parsing.h"
-#include "common/bar.h"
+#include "common/percent.h"
 #include "detection/memory/memory.h"
 #include "modules/memory/memory.h"
 #include "util/stringUtils.h"
@@ -40,7 +40,7 @@ void ffPrintMemory(FFMemoryOptions* options)
 
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(&str, percentage, 0, 50, 80);
+                ffPercentAppendBar(&str, percentage, options->percent);
                 ffStrbufAppendC(&str, ' ');
             }
 
@@ -48,7 +48,7 @@ void ffPrintMemory(FFMemoryOptions* options)
                 ffStrbufAppendF(&str, "%s / %s ", usedPretty.chars, totalPretty.chars);
 
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
-                ffAppendPercentNum(&str, percentage, 50, 80, str.length > 0);
+                ffPercentAppendNum(&str, percentage, options->percent, str.length > 0);
 
             ffStrbufTrimRight(&str, ' ');
             ffStrbufPutTo(&str, stdout);
@@ -57,7 +57,7 @@ void ffPrintMemory(FFMemoryOptions* options)
     else
     {
         FF_STRBUF_AUTO_DESTROY percentageStr = ffStrbufCreate();
-        ffAppendPercentNum(&percentageStr, percentage, 50, 80, false);
+        ffPercentAppendNum(&percentageStr, percentage, options->percent, false);
         ffPrintFormat(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, FF_MEMORY_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &usedPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &totalPretty},
@@ -73,6 +73,9 @@ bool ffParseMemoryCommandOptions(FFMemoryOptions* options, const char* key, cons
     if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
         return true;
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -89,6 +92,9 @@ void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module)
         if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
             continue;
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -99,6 +105,8 @@ void ffGenerateMemoryJsonConfig(FFMemoryOptions* options, yyjson_mut_doc* doc, y
     ffInitMemoryOptions(&defaultOptions);
 
     ffJsonConfigGenerateModuleArgsConfig(doc, module, &defaultOptions.moduleArgs, &options->moduleArgs);
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateMemoryJsonResult(FF_MAYBE_UNUSED FFMemoryOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -140,6 +148,7 @@ void ffInitMemoryOptions(FFMemoryOptions* options)
         ffGenerateMemoryJsonConfig
     );
     ffOptionInitModuleArg(&options->moduleArgs);
+    options->percent = (FFPercentConfig) { 50, 80 };
 }
 
 void ffDestroyMemoryOptions(FFMemoryOptions* options)

src/modules/memory/option.h

@@ -3,9 +3,12 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef struct FFMemoryOptions
 {
     FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
+
+    FFPercentConfig percent;
 } FFMemoryOptions;

src/modules/modules.h

@@ -49,6 +49,7 @@
 #include "modules/terminal/terminal.h"
 #include "modules/terminalfont/terminalfont.h"
 #include "modules/terminalsize/terminalsize.h"
+#include "modules/terminaltheme/terminaltheme.h"
 #include "modules/theme/theme.h"
 #include "modules/title/title.h"
 #include "modules/uptime/uptime.h"

src/modules/options.h

@@ -49,6 +49,7 @@
 #include "modules/terminal/option.h"
 #include "modules/terminalfont/option.h"
 #include "modules/terminalsize/option.h"
+#include "modules/terminaltheme/option.h"
 #include "modules/theme/option.h"
 #include "modules/title/option.h"
 #include "modules/uptime/option.h"

src/modules/shell/shell.c

@@ -38,6 +38,8 @@ void ffPrintShell(FFShellOptions* options)
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->version},
             {FF_FORMAT_ARG_TYPE_UINT, &result->pid},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->prettyName},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->exePath},
+            {FF_FORMAT_ARG_TYPE_INT, &result->tty},
         });
     }
 }
@@ -90,21 +92,28 @@ void ffGenerateShellJsonResult(FF_MAYBE_UNUSED FFShellOptions* options, yyjson_m
     yyjson_mut_val* obj = yyjson_mut_obj_add_obj(doc, module, "result");
     yyjson_mut_obj_add_strbuf(doc, obj, "exe", &result->exe);
     yyjson_mut_obj_add_strcpy(doc, obj, "exeName", result->exeName);
+    yyjson_mut_obj_add_strbuf(doc, obj, "exePath", &result->exePath);
     yyjson_mut_obj_add_uint(doc, obj, "pid", result->pid);
     yyjson_mut_obj_add_uint(doc, obj, "ppid", result->ppid);
     yyjson_mut_obj_add_strbuf(doc, obj, "processName", &result->processName);
+    yyjson_mut_obj_add_strbuf(doc, obj, "prettyName", &result->prettyName);
     yyjson_mut_obj_add_strbuf(doc, obj, "version", &result->version);
+    if (result->tty >= 0)
+        yyjson_mut_obj_add_int(doc, obj, "tty", result->tty);
+    else
+        yyjson_mut_obj_add_null(doc, obj, "tty");
 }
 
 void ffPrintShellHelpFormat(void)
 {
     ffPrintModuleFormatHelp(FF_SHELL_MODULE_NAME, "{3} {4}", FF_SHELL_NUM_FORMAT_ARGS, (const char* []) {
         "Shell process name",
-        "Shell path with exe name",
-        "Shell exe name",
+        "The first argument of the command line when running the shell",
+        "Shell base name of arg0",
         "Shell version",
         "Shell pid",
-        "Shell pretty name"
+        "Shell pretty name",
+        "Shell full exe path",
     });
 }
 

src/modules/sound/option.h

@@ -3,6 +3,7 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef enum FFSoundType
 {
@@ -17,4 +18,5 @@ typedef struct FFSoundOptions
     FFModuleArgs moduleArgs;
 
     FFSoundType soundType;
+    FFPercentConfig percent;
 } FFSoundOptions;

src/modules/sound/sound.c

@@ -1,3 +1,4 @@
+#include "common/percent.h"
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "detection/sound/sound.h"
@@ -11,27 +12,47 @@ static void printDevice(FFSoundOptions* options, const FFSoundDevice* device, ui
     if(options->moduleArgs.outputFormat.length == 0)
     {
         ffPrintLogoAndKey(FF_SOUND_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
-        ffStrbufWriteTo(&device->name, stdout);
+
+        FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate();
+        if (!(instance.config.display.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
+            ffStrbufAppend(&str, &device->name);
 
         if(device->volume != FF_SOUND_VOLUME_UNKNOWN)
         {
-            if(device->volume > 0)
-                printf(" (%d%%)", device->volume);
-            else
-                fputs(" (muted)", stdout);
+            if (instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
+            {
+                if (str.length)
+                    ffStrbufAppendC(&str, ' ');
+
+                ffPercentAppendBar(&str, device->volume, options->percent);
+            }
+
+            if (instance.config.display.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
+            {
+                if (str.length)
+                    ffStrbufAppendC(&str, ' ');
+
+                ffPercentAppendNum(&str, device->volume, options->percent, str.length > 0);
+            }
         }
 
-        if(device->main && index > 0)
-            fputs(" (*)", stdout);
+        if (!(instance.config.display.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
+        {
+            if (device->main && index > 0)
+                ffStrbufAppendS(&str, " (*)");
+        }
 
-        putchar('\n');
+        ffStrbufPutTo(&str, stdout);
     }
     else
     {
+        FF_STRBUF_AUTO_DESTROY percentageStr = ffStrbufCreate();
+        ffPercentAppendNum(&percentageStr, device->volume, options->percent, false);
+
         ffPrintFormat(FF_SOUND_MODULE_NAME, index, &options->moduleArgs, FF_SOUND_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_BOOL, &device->main},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->name},
-            {FF_FORMAT_ARG_TYPE_UINT8, &device->volume},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &percentageStr},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->identifier}
         });
     }
@@ -100,6 +121,9 @@ bool ffParseSoundCommandOptions(FFSoundOptions* options, const char* key, const
         return true;
     }
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -132,6 +156,9 @@ void ffParseSoundJsonObject(FFSoundOptions* options, yyjson_val* module)
             continue;
         }
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -158,6 +185,8 @@ void ffGenerateSoundJsonConfig(FFSoundOptions* options, yyjson_mut_doc* doc, yyj
                 break;
         }
     }
+
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
 
 void ffGenerateSoundJsonResult(FF_MAYBE_UNUSED FFSoundOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -226,6 +255,7 @@ void ffInitSoundOptions(FFSoundOptions* options)
     ffOptionInitModuleArg(&options->moduleArgs);
 
     options->soundType = FF_SOUND_TYPE_MAIN;
+    options->percent = (FFPercentConfig) { 80, 90 };
 }
 
 void ffDestroySoundOptions(FFSoundOptions* options)

src/modules/swap/option.h

@@ -3,9 +3,12 @@
 // This file will be included in "fastfetch.h", do NOT put unnecessary things here
 
 #include "common/option.h"
+#include "common/percent.h"
 
 typedef struct FFSwapOptions
 {
     FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
+
+    FFPercentConfig percent;
 } FFSwapOptions;

src/modules/swap/swap.c

@@ -1,7 +1,7 @@
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "common/parsing.h"
-#include "common/bar.h"
+#include "common/percent.h"
 #include "detection/swap/swap.h"
 #include "modules/swap/swap.h"
 #include "util/stringUtils.h"
@@ -37,17 +37,19 @@ void ffPrintSwap(FFSwapOptions* options)
         {
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(&str, 0, 0, 50, 80);
+                ffPercentAppendBar(&str, 0, options->percent);
                 ffStrbufAppendC(&str, ' ');
             }
             if(!(instance.config.display.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
                 ffStrbufAppendS(&str, "Disabled");
+            else
+                ffPercentAppendNum(&str, 0, options->percent, str.length > 0);
         }
         else
         {
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(&str, percentage, 0, 50, 80);
+                ffPercentAppendBar(&str, percentage, options->percent);
                 ffStrbufAppendC(&str, ' ');
             }
 
@@ -55,7 +57,7 @@ void ffPrintSwap(FFSwapOptions* options)
                 ffStrbufAppendF(&str, "%s / %s ", usedPretty.chars, totalPretty.chars);
 
             if(instance.config.display.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
-                ffAppendPercentNum(&str, percentage, 50, 80, str.length > 0);
+                ffPercentAppendNum(&str, percentage, options->percent, str.length > 0);
         }
 
         ffStrbufTrimRight(&str, ' ');
@@ -64,7 +66,7 @@ void ffPrintSwap(FFSwapOptions* options)
     else
     {
         FF_STRBUF_AUTO_DESTROY percentageStr = ffStrbufCreate();
-        ffAppendPercentNum(&percentageStr, percentage, 50, 80, false);
+        ffPercentAppendNum(&percentageStr, percentage, options->percent, false);
         ffPrintFormat(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, FF_SWAP_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &usedPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &totalPretty},
@@ -80,6 +82,9 @@ bool ffParseSwapCommandOptions(FFSwapOptions* options, const char* key, const ch
     if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
         return true;
 
+    if (ffPercentParseCommandOptions(key, subKey, value, &options->percent))
+        return true;
+
     return false;
 }
 
@@ -96,6 +101,9 @@ void ffParseSwapJsonObject(FFSwapOptions* options, yyjson_val* module)
         if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
             continue;
 
+        if (ffPercentParseJsonObject(key, val, &options->percent))
+            continue;
+
         ffPrintError(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
 }
@@ -105,6 +113,8 @@ void ffGenerateSwapJsonConfig(FFSwapOptions* options, yyjson_mut_doc* doc, yyjso
     __attribute__((__cleanup__(ffDestroySwapOptions))) FFSwapOptions defaultOptions;
     ffInitSwapOptions(&defaultOptions);
 
+    ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
+
     ffJsonConfigGenerateModuleArgsConfig(doc, module, &defaultOptions.moduleArgs, &options->moduleArgs);
 }
 
@@ -147,6 +157,7 @@ void ffInitSwapOptions(FFSwapOptions* options)
         ffGenerateSwapJsonConfig
     );
     ffOptionInitModuleArg(&options->moduleArgs);
+    options->percent = (FFPercentConfig) { 50, 80 };
 }
 
 void ffDestroySwapOptions(FFSwapOptions* options)

src/modules/terminal/terminal.c

@@ -6,7 +6,7 @@
 
 #include <string.h>
 
-#define FF_TERMINAL_NUM_FORMAT_ARGS 6
+#define FF_TERMINAL_NUM_FORMAT_ARGS 7
 
 void ffPrintTerminal(FFTerminalOptions* options)
 {
@@ -36,6 +36,7 @@ void ffPrintTerminal(FFTerminalOptions* options)
             {FF_FORMAT_ARG_TYPE_UINT, &result->pid},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->prettyName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->version},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->exePath},
         });
     }
 }
@@ -89,6 +90,7 @@ void ffGenerateTerminalJsonResult(FF_MAYBE_UNUSED FFTerminalOptions* options, yy
     yyjson_mut_obj_add_strbuf(doc, obj, "processName", &result->processName);
     yyjson_mut_obj_add_strbuf(doc, obj, "exe", &result->exe);
     yyjson_mut_obj_add_strcpy(doc, obj, "exeName", result->exeName);
+    yyjson_mut_obj_add_strbuf(doc, obj, "exePath", &result->exePath);
     yyjson_mut_obj_add_uint(doc, obj, "pid", result->pid);
     yyjson_mut_obj_add_uint(doc, obj, "ppid", result->ppid);
     yyjson_mut_obj_add_strbuf(doc, obj, "prettyName", &result->prettyName);
@@ -99,11 +101,12 @@ void ffPrintTerminalHelpFormat(void)
 {
     ffPrintModuleFormatHelp(FF_TERMINAL_MODULE_NAME, "{5} {6}", FF_TERMINAL_NUM_FORMAT_ARGS, (const char* []) {
         "Terminal process name",
-        "Terminal path with exe name",
-        "Terminal exe name",
+        "The first argument of the command line when running the terminal",
+        "Terminal base name of arg0",
         "Terminal pid",
         "Terminal pretty name",
-        "Terminal version"
+        "Terminal version",
+        "Terminal full exe path",
     });
 }
 

src/modules/terminaltheme/option.h

@@ -0,0 +1,11 @@
+#pragma once
+
+// This file will be included in "fastfetch.h", do NOT put unnecessary things here
+
+#include "common/option.h"
+
+typedef struct FFTerminalThemeOptions
+{
+    FFModuleBaseInfo moduleInfo;
+    FFModuleArgs moduleArgs;
+} FFTerminalThemeOptions;

src/modules/terminaltheme/terminaltheme.c

@@ -0,0 +1,134 @@
+#include "common/printing.h"
+#include "common/jsonconfig.h"
+#include "detection/terminaltheme/terminaltheme.h"
+#include "modules/terminaltheme/terminaltheme.h"
+#include "util/stringUtils.h"
+
+#include <inttypes.h>
+
+#define FF_TERMINALTHEME_DISPLAY_NAME "Terminal Theme"
+#define FF_TERMINALTHEME_NUM_FORMAT_ARGS 4
+
+void ffPrintTerminalTheme(FFTerminalThemeOptions* options)
+{
+    FFTerminalThemeResult result = {};
+
+    if(!ffDetectTerminalTheme(&result))
+    {
+        ffPrintError(FF_TERMINALTHEME_DISPLAY_NAME, 0, &options->moduleArgs, "Failed to detect terminal theme");
+    }
+    else
+    {
+        if(options->moduleArgs.outputFormat.length == 0)
+        {
+            ffPrintLogoAndKey(FF_TERMINALTHEME_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
+            printf("#%02" PRIX16 "%02" PRIX16 "%02" PRIX16 " (FG) - #%02" PRIX16 "%02" PRIX16 "%02" PRIX16 " (BG) [%s]\n",
+                result.fg.r, result.fg.g, result.fg.b,
+                result.bg.r, result.bg.g, result.bg.b,
+                result.bg.dark ? "Dark" : "Light");
+        }
+        else
+        {
+            char fg[32], bg[32];
+            snprintf(fg, sizeof(fg), "#%02" PRIX16 "%02" PRIX16 "%02" PRIX16, result.fg.r, result.fg.g, result.fg.b);
+            snprintf(bg, sizeof(bg), "#%02" PRIX16 "%02" PRIX16 "%02" PRIX16, result.bg.r, result.bg.g, result.bg.b);
+            ffPrintFormat(FF_TERMINALTHEME_DISPLAY_NAME, 0, &options->moduleArgs, FF_TERMINALTHEME_NUM_FORMAT_ARGS, (FFformatarg[]){
+                {FF_FORMAT_ARG_TYPE_STRING, fg},
+                {FF_FORMAT_ARG_TYPE_STRING, result.fg.dark ? "Dark" : "Light"},
+                {FF_FORMAT_ARG_TYPE_STRING, bg},
+                {FF_FORMAT_ARG_TYPE_STRING, result.bg.dark ? "Dark" : "Light"},
+            });
+        }
+    }
+}
+
+bool ffParseTerminalThemeCommandOptions(FFTerminalThemeOptions* options, const char* key, const char* value)
+{
+    const char* subKey = ffOptionTestPrefix(key, FF_TERMINALTHEME_MODULE_NAME);
+    if (!subKey) return false;
+    if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
+        return true;
+
+    return false;
+}
+
+void ffParseTerminalThemeJsonObject(FFTerminalThemeOptions* options, yyjson_val* module)
+{
+    yyjson_val *key_, *val;
+    size_t idx, max;
+    yyjson_obj_foreach(module, idx, max, key_, val)
+    {
+        const char* key = yyjson_get_str(key_);
+        if(ffStrEqualsIgnCase(key, "type"))
+            continue;
+
+        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
+            continue;
+
+        ffPrintError(FF_TERMINALTHEME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
+    }
+}
+
+void ffGenerateTerminalThemeJsonConfig(FFTerminalThemeOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
+{
+    __attribute__((__cleanup__(ffDestroyTerminalThemeOptions))) FFTerminalThemeOptions defaultOptions;
+    ffInitTerminalThemeOptions(&defaultOptions);
+
+    ffJsonConfigGenerateModuleArgsConfig(doc, module, &defaultOptions.moduleArgs, &options->moduleArgs);
+}
+
+void ffGenerateTerminalThemeJsonResult(FF_MAYBE_UNUSED FFTerminalOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
+{
+    FFTerminalThemeResult result = {};
+
+    if(!ffDetectTerminalTheme(&result))
+    {
+        yyjson_mut_obj_add_str(doc, module, "error", "Failed to detect terminal theme");
+        return;
+    }
+
+    yyjson_mut_val* obj = yyjson_mut_obj_add_obj(doc, module, "result");
+
+    yyjson_mut_val* fg = yyjson_mut_obj_add_obj(doc, obj, "fg");
+    yyjson_mut_obj_add_uint(doc, fg, "r", result.fg.r);
+    yyjson_mut_obj_add_uint(doc, fg, "g", result.fg.g);
+    yyjson_mut_obj_add_uint(doc, fg, "b", result.fg.b);
+    yyjson_mut_obj_add_bool(doc, fg, "dark", result.fg.dark);
+
+    yyjson_mut_val* bg = yyjson_mut_obj_add_obj(doc, obj, "bg");
+    yyjson_mut_obj_add_uint(doc, bg, "r", result.bg.r);
+    yyjson_mut_obj_add_uint(doc, bg, "g", result.bg.g);
+    yyjson_mut_obj_add_uint(doc, bg, "b", result.bg.b);
+    yyjson_mut_obj_add_bool(doc, bg, "dark", result.bg.dark);
+}
+
+void ffPrintTerminalThemeHelpFormat(void)
+{
+    ffPrintModuleFormatHelp(FF_TERMINALTHEME_MODULE_NAME, "{1} (FG) {3} (BG) [{4}]", FF_TERMINALTHEME_NUM_FORMAT_ARGS, (const char* []) {
+        "Terminal foreground color",
+        "Terminal foreground type (Dark / Light)",
+        "Terminal background color",
+        "Terminal background type (Dark / Light)",
+    });
+}
+
+void ffInitTerminalThemeOptions(FFTerminalThemeOptions* options)
+{
+    ffOptionInitModuleBaseInfo(
+        &options->moduleInfo,
+        FF_TERMINALTHEME_MODULE_NAME,
+        "Print current terminal theme (foreground and background colors)",
+        ffParseTerminalThemeCommandOptions,
+        ffParseTerminalThemeJsonObject,
+        ffPrintTerminalTheme,
+        ffGenerateTerminalThemeJsonResult,
+        ffPrintTerminalThemeHelpFormat,
+        ffGenerateTerminalThemeJsonConfig
+    );
+    ffOptionInitModuleArg(&options->moduleArgs);
+}
+
+void ffDestroyTerminalThemeOptions(FFTerminalThemeOptions* options)
+{
+    ffOptionDestroyModuleArg(&options->moduleArgs);
+}

src/modules/terminaltheme/terminaltheme.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "fastfetch.h"
+
+#define FF_TERMINALTHEME_MODULE_NAME "TerminalTheme"
+
+void ffPrintTerminalTheme(FFTerminalThemeOptions* options);
+void ffInitTerminalThemeOptions(FFTerminalThemeOptions* options);
+void ffDestroyTerminalThemeOptions(FFTerminalThemeOptions* options);

src/options/display.c

@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "common/color.h"
 #include "common/jsonconfig.h"
 #include "util/stringUtils.h"
 #include "options/display.h"
@@ -118,6 +119,22 @@ const char* ffOptionsParseDisplayJsonConfig(FFOptionsDisplay* options, yyjson_va
 
             yyjson_val* ndigits = yyjson_obj_get(val, "ndigits");
             if (ndigits) options->percentNdigits = (uint8_t) yyjson_get_uint(ndigits);
+
+            yyjson_val* color = yyjson_obj_get(val, "color");
+            if (color)
+            {
+                if (!yyjson_is_obj(color))
+                    return "display.percent.color must be an object";
+
+                yyjson_val* green = yyjson_obj_get(color, "green");
+                if (green) ffOptionParseColor(yyjson_get_str(green), &options->percentColorGreen);
+
+                yyjson_val* yellow = yyjson_obj_get(color, "yellow");
+                if (yellow) ffOptionParseColor(yyjson_get_str(yellow), &options->percentColorYellow);
+
+                yyjson_val* red = yyjson_obj_get(color, "red");
+                if (red) ffOptionParseColor(yyjson_get_str(red), &options->percentColorRed);
+            }
         }
         else if (ffStrEqualsIgnCase(key, "bar"))
         {
@@ -248,10 +265,22 @@ bool ffOptionsParseDisplayCommandLine(FFOptionsDisplay* options, const char* key
             {},
         });
     }
-    else if(ffStrEqualsIgnCase(key, "--percent-type"))
-        options->percentType = (uint8_t) ffOptionParseUInt32(key, value);
-    else if(ffStrEqualsIgnCase(key, "--percent-ndigits"))
-        options->percentNdigits = (uint8_t) ffOptionParseUInt32(key, value);
+    else if(ffStrStartsWithIgnCase(key, "--percent-"))
+    {
+        const char* subkey = key + strlen("--percent-");
+        if(ffStrEqualsIgnCase(subkey, "type"))
+            options->percentType = (uint8_t) ffOptionParseUInt32(key, value);
+        else if(ffStrEqualsIgnCase(subkey, "ndigits"))
+            options->percentNdigits = (uint8_t) ffOptionParseUInt32(key, value);
+        else if(ffStrEqualsIgnCase(subkey, "color-green"))
+            ffOptionParseColor(value, &options->percentColorGreen);
+        else if(ffStrEqualsIgnCase(subkey, "color-yellow"))
+            ffOptionParseColor(value, &options->percentColorYellow);
+        else if(ffStrEqualsIgnCase(subkey, "color-red"))
+            ffOptionParseColor(value, &options->percentColorRed);
+        else
+            return false;
+    }
     else if(ffStrEqualsIgnCase(key, "--no-buffer"))
         options->noBuffer = ffOptionParseBoolean(value);
     else if(ffStrStartsWithIgnCase(key, "--bar-"))
@@ -305,6 +334,9 @@ void ffOptionsInitDisplay(FFOptionsDisplay* options)
     options->barBorder = true;
     options->percentType = 9;
     options->percentNdigits = 0;
+    ffStrbufInitStatic(&options->percentColorGreen, FF_COLOR_FG_GREEN);
+    ffStrbufInitStatic(&options->percentColorYellow, FF_COLOR_FG_LIGHT_YELLOW);
+    ffStrbufInitStatic(&options->percentColorRed, FF_COLOR_FG_LIGHT_RED);
 }
 
 void ffOptionsDestroyDisplay(FFOptionsDisplay* options)

src/options/display.h

@@ -41,6 +41,9 @@ typedef struct FFOptionsDisplay
     bool barBorder;
     uint8_t percentType;
     uint8_t percentNdigits;
+    FFstrbuf percentColorGreen;
+    FFstrbuf percentColorYellow;
+    FFstrbuf percentColorRed;
     bool noBuffer;
     uint32_t keyWidth;
 } FFOptionsDisplay;

src/options/modules.c

@@ -47,9 +47,10 @@ void ffOptionsInitModules(FFOptionsModules* options)
     ffInitShellOptions(&options->shell);
     ffInitSoundOptions(&options->sound);
     ffInitSwapOptions(&options->swap);
-    ffInitTerminalFontOptions(&options->terminalFont);
     ffInitTerminalOptions(&options->terminal);
+    ffInitTerminalFontOptions(&options->terminalFont);
     ffInitTerminalSizeOptions(&options->terminalSize);
+    ffInitTerminalThemeOptions(&options->terminalTheme);
     ffInitThemeOptions(&options->theme);
     ffInitTitleOptions(&options->title);
     ffInitUptimeOptions(&options->uptime);
@@ -109,9 +110,10 @@ void ffOptionsDestroyModules(FFOptionsModules* options)
     ffDestroyShellOptions(&options->shell);
     ffDestroySoundOptions(&options->sound);
     ffDestroySwapOptions(&options->swap);
-    ffDestroyTerminalFontOptions(&options->terminalFont);
     ffDestroyTerminalOptions(&options->terminal);
+    ffDestroyTerminalFontOptions(&options->terminalFont);
     ffDestroyTerminalSizeOptions(&options->terminalSize);
+    ffDestroyTerminalThemeOptions(&options->terminalTheme);
     ffDestroyThemeOptions(&options->theme);
     ffDestroyTitleOptions(&options->title);
     ffDestroyUptimeOptions(&options->uptime);

src/options/modules.h

@@ -48,9 +48,10 @@ typedef struct FFOptionsModules
     FFShellOptions shell;
     FFSoundOptions sound;
     FFSwapOptions swap;
-    FFTerminalFontOptions terminalFont;
     FFTerminalOptions terminal;
+    FFTerminalFontOptions terminalFont;
     FFTerminalSizeOptions terminalSize;
+    FFTerminalThemeOptions terminalTheme;
     FFThemeOptions theme;
     FFTitleOptions title;
     FFUptimeOptions uptime;

src/util/mallocHelper.h

@@ -6,7 +6,7 @@
 #include <stdlib.h>
 #include <assert.h>
 
-static inline void ffWrapFree(void* pPtr)
+static inline void ffWrapFree(const void* pPtr)
 {
     assert(pPtr);
     if(*(void**)pPtr)

src/util/platform/FFPlatform_unix.c

@@ -29,8 +29,10 @@ static void getExePath(FFPlatform* platform)
             (int[]){CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, (int) getpid()}, 4,
             exePath->chars, &exePathLen,
             NULL, 0
-        ))
+        ) < 0)
             exePathLen = 0;
+        else
+            exePathLen--; // remove terminating NUL
     #endif
     if (exePathLen > 0)
         exePath->length = (uint32_t) exePathLen;