Merge pull request #740 from fastfetch-cli/dev

Release: v2.8.6

.github/workflows/ci.yml

@@ -288,7 +288,7 @@ jobs:
 
   freebsd-amd64:
     name: FreeBSD-amd64
-    runs-on: macos-12
+    runs-on: ubuntu-latest
     permissions:
       security-events: write
       contents: read
@@ -300,6 +300,9 @@ jobs:
         uses: cross-platform-actions/action@master
         with:
           operating_system: freebsd
+          architecture: x86-64
+          cpu_count: 3
+          shell: bash
           version: '13.2'
           run: |
             uname -a
@@ -320,6 +323,43 @@ jobs:
           name: fastfetch-freebsd-amd64
           path: ./fastfetch-*.*
 
+  freebsd-aarch64:
+    name: FreeBSD-aarch64
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: run VM
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: freebsd
+          architecture: arm64
+          cpu_count: 3
+          shell: bash
+          version: '13.2'
+          run: |
+            uname -a
+            sudo pkg update
+            sudo pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl xfce4-conf ImageMagick6 ImageMagick7 chafa egl libosmesa opencl ocl-icd v4l_compat
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch
+            time ./fastfetch --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-freebsd-aarch64
+          path: ./fastfetch-*.*
+
   windows-amd64:
     name: Windows-amd64
     runs-on: windows-latest
@@ -458,6 +498,7 @@ jobs:
       - linux-aarch64
       - macos-universal
       - freebsd-amd64
+      - freebsd-aarch64
       - windows-amd64
       - windows-i686
     permissions:

CHANGELOG.md

@@ -1,3 +1,18 @@
+# 2.8.6
+
+Changes:
+* Due to newly introduced configs, JSONC option `{ "temperatureUnit": "C" }` has been changed to `{ "temp": { "unit": "C" } }`
+
+Bugfixes:
+* Fix incorrect GPU name detection for Intel iGPU on Linux (#736, GPU, Linux)
+
+Features:
+* Support additional temperature formatting options (#737)
+    * `{ "temp": { "ndigits": 1 } }`
+    * `{ "temp": { "color": { "green": "green", "yellow": "yellow", "red": "red" } } }`
+* Support specifying custom `pci.ids` path for Linux (GPU, Linux)
+* Support warp-linux terminal version & terminal font detection (Terminal, Linux)
+
 # 2.8.5
 
 Bugfixes:

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.8.5
+    VERSION 2.8.6
     LANGUAGES C
     DESCRIPTION "Fast neofetch-like system information tool"
     HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -76,6 +76,10 @@ option(ENABLE_PROPRIETARY_GPU_DRIVER_API "Enable proprietary GPU driver API (NVM
 option(BUILD_TESTS "Build tests" OFF) # Also create test executables
 option(SET_TWEAK "Add tweak to project version" ON) # This is set to off by github actions for release builds
 
+if (LINUX)
+    set(CUSTOM_PCI_IDS_PATH "" CACHE STRING "Custom path to file pci.ids, defaults to `/usr/share/hwdata/pci.ids`")
+endif()
+
 ####################
 # Compiler options #
 ####################
@@ -277,6 +281,7 @@ set(LIBFASTFETCH_SRC
     src/common/printing.c
     src/common/properties.c
     src/common/settings.c
+    src/common/temps.c
     src/detection/chassis/chassis.c
     src/detection/cpu/cpu.c
     src/detection/cpuusage/cpuusage.c
@@ -724,8 +729,8 @@ if(yyjson_FOUND)
 else()
     # Used for dlopen finding dylibs installed by homebrew
     # `/opt/homebrew/lib` is not on in dlopen search path by default
-    if(APPLE AND DEFINED ENV{HOMEBREW_PREFIX})
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath,$ENV{HOMEBREW_PREFIX}/lib")
+    if(APPLE)
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath,/opt/homebrew/lib -Wl,-rpath,/usr/local/lib")
     endif()
 endif()
 
@@ -762,6 +767,11 @@ if(HAVE_WCWIDTH)
     target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WCWIDTH)
 endif()
 
+if(NOT "${CUSTOM_PCI_IDS_PATH}" STREQUAL "")
+    message(STATUS "Custom file path of pci.ids: ${CUSTOM_PCI_IDS_PATH}")
+    target_compile_definitions(libfastfetch PRIVATE FF_CUSTOM_PCI_IDS_PATH=${CUSTOM_PCI_IDS_PATH})
+endif()
+
 function(ff_lib_enable VARNAME PKGCONFIG_NAMES CMAKE_NAME)
     if(NOT ENABLE_${VARNAME})
         return()

doc/json_schema.json

@@ -1,5 +1,5 @@
 {
-    "$schema": "http://json-schema.org/schema",
+    "$schema": "https://json-schema.org/draft-07/schema",
     "$defs": {
         "colors": {
             "type": "string",
@@ -44,6 +44,32 @@
                     "description": "Value greater than green and less then yellow will be shown in yellow.\nValue greater than yellow will be shown in red"
                 }
             }
+        },
+        "temperature": {
+            "description": "Detect and display temperature if supported",
+            "oneOf": [
+                {
+                    "type": "boolean",
+                    "default": false
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "green": {
+                            "type": "integer",
+                            "minimum": 0,
+                            "maximum": 100,
+                            "description": "Value (in celsius) less then green will be shown in green"
+                        },
+                        "yellow": {
+                            "type": "integer",
+                            "minimum": 0,
+                            "maximum": 100,
+                            "description": "Value (in celsius) greater than green and less then yellow will be shown in yellow.\nValue greater than yellow will be shown in red"
+                        }
+                    }
+                }
+            ]
         }
     },
     "type": "object",
@@ -272,7 +298,7 @@
                     "description": "Force display detection to use DRM. Linux only",
                     "oneOf": [
                         {
-                            "type": "bool",
+                            "type": "boolean",
                             "const": false,
                             "description": "Try `wayland`, then `x11`, then `drm`"
                         },
@@ -282,7 +308,7 @@
                             "const": "sysfs-only"
                         },
                         {
-                            "type": "bool",
+                            "type": "boolean",
                             "const": true,
                             "description": "Try `libdrm` first, then `sysfs` if libdrm failed"
                         }
@@ -407,11 +433,42 @@
                         }
                     }
                 },
-                "temperatureUnit": {
-                    "type": "string",
-                    "description": "Set the unit of the temperature",
-                    "enum": ["CELSIUS", "C", "FAHRENHEIT", "F", "KELVIN", "K"],
-                    "default": "C"
+                "temp": {
+                    "type": "object",
+                    "description": "Set how temperature values should be displayed",
+                    "properties": {
+                        "unit": {
+                            "type": "string",
+                            "description": "Set the unit of the temperature",
+                            "enum": ["CELSIUS", "C", "FAHRENHEIT", "F", "KELVIN", "K"],
+                            "default": "C"
+                        },
+                        "ndigits": {
+                            "type": "integer",
+                            "description": "Set the number of digits to keep after the decimal point when formatting temperature values",
+                            "minimum": 0,
+                            "maximum": 9,
+                            "default": 1
+                        },
+                        "color": {
+                            "type": "object",
+                            "description": "Set color used in different states of temperature values",
+                            "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"
+                                }
+                            }
+                        }
+                    }
                 },
                 "bar": {
                     "type": "object",
@@ -839,9 +896,7 @@
                                         "default": false
                                     },
                                     "temp": {
-                                        "description": "Detect and display Battery temperature if supported",
-                                        "type": "boolean",
-                                        "default": false
+                                        "$ref": "#/$defs/temperature"
                                     },
                                     "percent": {
                                         "$ref": "#/$defs/percent"
@@ -939,9 +994,7 @@
                                         "const": "cpu"
                                     },
                                     "temp": {
-                                        "description": "Detect and display CPU temperature if supported",
-                                        "type": "boolean",
-                                        "default": false
+                                        "$ref": "#/$defs/temperature"
                                     },
                                     "freqNdigits": {
                                         "description": "Set the number of digits to keep after the decimal point when printing CPU frequency",
@@ -1286,9 +1339,7 @@
                                         "const": "gpu"
                                     },
                                     "temp": {
-                                        "description": "Detect and display GPU temperature if supported",
-                                        "type": "boolean",
-                                        "default": false
+                                        "$ref": "#/$defs/temperature"
                                     },
                                     "driverSpecific": {
                                         "description": "Use driver specific method to detect more detailed GPU information (memory usage, core count, etc)",
@@ -1511,9 +1562,7 @@
                                         "type": "string"
                                     },
                                     "temp": {
-                                        "description": "Detect and display SSD temperature if supported",
-                                        "type": "boolean",
-                                        "default": false
+                                        "$ref": "#/$defs/temperature"
                                     },
                                     "key": {
                                         "$ref": "#/$defs/key"

src/common/font.c

@@ -211,6 +211,7 @@ void ffFontInitValues(FFfont* font, const char* name, const char* size)
     ffFontInit(font);
 
     ffStrbufAppendS(&font->name, name);
+    ffStrbufTrim(&font->name, '"');
     ffStrbufAppendS(&font->size, size);
 
     fontInitPretty(font);

src/common/parsing.c

@@ -96,22 +96,6 @@ void ffParseSize(uint64_t bytes, FFstrbuf* result)
     }
 }
 
-void ffParseTemperature(double celsius, FFstrbuf* buffer)
-{
-    switch (instance.config.display.temperatureUnit)
-    {
-        case FF_TEMPERATURE_UNIT_CELSIUS:
-            ffStrbufAppendF(buffer, "%.1f°C", celsius);
-            break;
-        case FF_TEMPERATURE_UNIT_FAHRENHEIT:
-            ffStrbufAppendF(buffer, "%.1f°F", celsius * 1.8 + 32);
-            break;
-        case FF_TEMPERATURE_UNIT_KELVIN:
-            ffStrbufAppendF(buffer, "%.1f K", celsius + 273.15);
-            break;
-    }
-}
-
 void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
 {
     if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)

src/common/parsing.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "fastfetch.h"
+#include "util/FFstrbuf.h"
 
 #include <stdint.h>
 
@@ -11,6 +11,12 @@ typedef struct FFVersion
     uint32_t patch;
 } FFVersion;
 
+typedef struct FFColorRangeConfig
+{
+    uint8_t green;
+    uint8_t yellow;
+} FFColorRangeConfig;
+
 #define FF_VERSION_INIT ((FFVersion) {0})
 
 void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch);
@@ -20,4 +26,3 @@ void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty);
 int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2);
 
 void ffParseSize(uint64_t bytes, FFstrbuf* result);
-void ffParseTemperature(double celsius, FFstrbuf* buffer);

src/common/percent.c

@@ -6,7 +6,7 @@
 #include "util/textModifier.h"
 #include "util/stringUtils.h"
 
-void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFPercentConfig config)
+void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig config)
 {
     uint8_t green = config.green, yellow = config.yellow;
     assert(green <= 100 && yellow <= 100);
@@ -75,7 +75,7 @@ void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFPercentConfig config
         ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
 }
 
-void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentConfig config, bool parentheses)
+void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFColorRangeConfig config, bool parentheses)
 {
     uint8_t green = config.green, yellow = config.yellow;
     assert(green <= 100 && yellow <= 100);
@@ -89,9 +89,9 @@ void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentConfig config
 
     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;
+        const char* colorGreen = options->percentColorGreen.chars;
+        const char* colorYellow = options->percentColorYellow.chars;
+        const char* colorRed = options->percentColorRed.chars;
 
         if(percent != percent)
             ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_BLACK "m");
@@ -126,7 +126,7 @@ void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentConfig config
         ffStrbufAppendC(buffer, ')');
 }
 
-bool ffPercentParseCommandOptions(const char* key, const char* subkey, const char* value, FFPercentConfig* config)
+bool ffPercentParseCommandOptions(const char* key, const char* subkey, const char* value, FFColorRangeConfig* config)
 {
     if (!ffStrStartsWithIgnCase(subkey, "percent-"))
         return false;
@@ -160,7 +160,7 @@ bool ffPercentParseCommandOptions(const char* key, const char* subkey, const cha
     return false;
 }
 
-bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFPercentConfig* config)
+bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFColorRangeConfig* config)
 {
     if (!ffStrEqualsIgnCase(key, "percent"))
         return false;
@@ -198,7 +198,7 @@ bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFPercentConfi
     return true;
 }
 
-void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFPercentConfig defaultConfig, FFPercentConfig config)
+void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFColorRangeConfig defaultConfig, FFColorRangeConfig config)
 {
     if (config.green == defaultConfig.green && config.yellow == defaultConfig.yellow)
         return;

src/common/percent.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "util/FFstrbuf.h"
+#include "common/parsing.h"
 
 enum
 {
@@ -10,12 +11,6 @@ enum
     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
@@ -26,12 +21,12 @@ typedef struct FFPercentConfig
 // [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);
+void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig config);
+void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFColorRangeConfig 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);
+bool ffPercentParseCommandOptions(const char* key, const char* subkey, const char* value, FFColorRangeConfig* config);
+bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFColorRangeConfig* config);
+void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFColorRangeConfig defaultConfig, FFColorRangeConfig config);

src/common/temps.c

@@ -0,0 +1,171 @@
+#include "fastfetch.h"
+#include "common/temps.h"
+#include "util/textModifier.h"
+#include "util/stringUtils.h"
+
+void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig config)
+{
+    if (celsius != celsius) // ignores NaN
+        return;
+
+    const FFOptionsDisplay* options = &instance.config.display;
+    const char* colorGreen = options->tempColorGreen.chars;
+    const char* colorYellow = options->tempColorYellow.chars;
+    const char* colorRed = options->tempColorRed.chars;
+
+    uint8_t green = config.green, yellow = config.yellow;
+
+    if (!options->pipe)
+    {
+        if(green <= yellow)
+        {
+            if (celsius > yellow)
+                ffStrbufAppendF(buffer, "\e[%sm", colorRed);
+            else if (celsius > green)
+                ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
+            else
+                ffStrbufAppendF(buffer, "\e[%sm", colorGreen);
+        }
+        else
+        {
+            if (celsius < yellow)
+                ffStrbufAppendF(buffer, "\e[%sm", colorRed);
+            else if (celsius < green)
+                ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
+            else
+                ffStrbufAppendF(buffer, "\e[%sm", colorGreen);
+        }
+    }
+
+    switch (options->temperatureUnit)
+    {
+        case FF_TEMPERATURE_UNIT_CELSIUS:
+            ffStrbufAppendF(buffer, "%.*f°C", options->tempNdigits, celsius);
+            break;
+        case FF_TEMPERATURE_UNIT_FAHRENHEIT:
+            ffStrbufAppendF(buffer, "%.*f°F", options->tempNdigits, celsius * 1.8 + 32);
+            break;
+        case FF_TEMPERATURE_UNIT_KELVIN:
+            ffStrbufAppendF(buffer, "%.*f K", options->tempNdigits, celsius + 273.15);
+            break;
+    }
+
+    if (!options->pipe)
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+}
+
+bool ffTempsParseCommandOptions(const char* key, const char* subkey, const char* value, bool* useTemp, FFColorRangeConfig* config)
+{
+    if (!ffStrStartsWithIgnCase(subkey, "temp"))
+        return false;
+
+    if (subkey[strlen("temp")] == '\0')
+    {
+        *useTemp = ffOptionParseBoolean(value);
+        return true;
+    }
+
+    if (subkey[strlen("temp")] != '-')
+        return false;
+
+    subkey += strlen("temp-");
+
+    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 ffTempsParseJsonObject(const char* key, yyjson_val* value, bool* useTemp, FFColorRangeConfig* config)
+{
+    if (!ffStrEqualsIgnCase(key, "temp"))
+        return false;
+
+    if (yyjson_is_bool(value))
+    {
+        *useTemp = yyjson_get_bool(value);
+        return true;
+    }
+
+    if (yyjson_is_null(value))
+    {
+        *useTemp = false;
+        return true;
+    }
+
+    if (!yyjson_is_obj(value))
+    {
+        fprintf(stderr, "Error: usage: %s must be an object or a boolean\n", key);
+        exit(480);
+    }
+
+    *useTemp = true;
+
+    yyjson_val* greenVal = yyjson_obj_get(value, "green");
+    if (greenVal)
+    {
+        int num = yyjson_get_int(greenVal);
+        if (num < 0 || num > 100)
+        {
+            fputs("Error: usage: temp.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: temp.yellow must be between 0 and 100\n", stderr);
+            exit(480);
+        }
+        config->yellow = (uint8_t) num;
+    }
+
+    return true;
+}
+
+void ffTempsGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FF_MAYBE_UNUSED bool defaultTemp, FFColorRangeConfig defaultConfig, bool temp, FFColorRangeConfig config)
+{
+    assert(defaultTemp == false); // assume defaultTemp is always false
+
+    if (!temp)
+        return;
+
+    if (config.green != defaultConfig.green || config.yellow != defaultConfig.yellow)
+    {
+        yyjson_mut_val* temp = yyjson_mut_obj_add_obj(doc, module, "temp");
+        if (config.green != defaultConfig.green)
+            yyjson_mut_obj_add_uint(doc, temp, "green", config.green);
+        if (config.yellow != defaultConfig.yellow)
+            yyjson_mut_obj_add_uint(doc, temp, "yellow", config.yellow);
+    }
+    else
+    {
+        yyjson_mut_obj_add_bool(doc, module, "temp", true);
+    }
+}

src/common/temps.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "common/parsing.h"
+
+void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig config);
+bool ffTempsParseCommandOptions(const char* key, const char* subkey, const char* value, bool* useTemp, FFColorRangeConfig* config);
+bool ffTempsParseJsonObject(const char* key, yyjson_val* value, bool* useTemp, FFColorRangeConfig* config);
+void ffTempsGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FF_MAYBE_UNUSED bool defaultTemp, FFColorRangeConfig defaultConfig, bool temp, FFColorRangeConfig config);

src/data/help.json

@@ -656,7 +656,7 @@
             }
         },
         {
-            "long": "temperature-unit",
+            "long": "temp-unit",
             "desc": "Set the unit of the temperature",
             "arg": {
                 "type": "enum",
@@ -667,6 +667,41 @@
                 },
                 "default": "C"
             }
+        },
+        {
+            "long": "temp-ndigits",
+            "desc": "Set the number of digits to keep after the decimal point when printing temperature",
+            "arg": {
+                "type": "num",
+                "default": 2
+            }
+        },
+        {
+            "long": "temp-color-green",
+            "desc": "Set color used in green state of temperature values",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "green"
+            }
+        },
+        {
+            "long": "temp-color-yellow",
+            "desc": "Set color used in yellow state of temperature values",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "light_yellow"
+            }
+        },
+        {
+            "long": "temp-color-red",
+            "desc": "Set color used in red state of temperature values",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "light_red"
+            }
         }
     ],
     "Library path": [
@@ -1497,6 +1532,29 @@
                 "type": "num"
             },
             "pseudo": true
+        },
+        {
+            "long": "<module>-temp-green",
+            "desc": [
+                "Threshold of temperature colors",
+                "Value less then temp-green will be shown in green"
+            ],
+            "arg": {
+                "type": "num"
+            },
+            "pseudo": true
+        },
+        {
+            "long": "<module>-temp-yellow",
+            "desc": [
+                "Threshold of temperature colors",
+                "Value greater than temp-green and less then yellow will be shown in yellow",
+                "Value greater than temp-yellow will be shown in red"
+            ],
+            "arg": {
+                "type": "num"
+            },
+            "pseudo": true
         }
     ]
 }

src/detection/de/de_linux.c

@@ -12,7 +12,7 @@
 
 static void getKDE(FFstrbuf* result, FFDEOptions* options)
 {
-    ffParsePropFileValues("/usr/share/xsessions/plasmax11.desktop", 1, (FFpropquery[]) {
+    ffParsePropFileValues(FASTFETCH_TARGET_DIR_USR "/share/xsessions/plasmax11.desktop", 1, (FFpropquery[]) {
         {"X-KDE-PluginInfo-Version =", result}
     });
     if(result->length == 0)
@@ -21,7 +21,7 @@ static void getKDE(FFstrbuf* result, FFDEOptions* options)
         ffParsePropFileData("xsessions/plasma5.desktop", "X-KDE-PluginInfo-Version =", result);
     if(result->length == 0)
     {
-        ffParsePropFileValues("/usr/share/wayland-sessions/plasma.desktop", 1, (FFpropquery[]) {
+        ffParsePropFileValues(FASTFETCH_TARGET_DIR_USR "/share/wayland-sessions/plasma.desktop", 1, (FFpropquery[]) {
             {"X-KDE-PluginInfo-Version =", result}
         });
     }

src/detection/gpu/gpu.h

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

src/detection/gpu/gpu_bsd.c

@@ -17,7 +17,7 @@ static bool loadPciIds(FFstrbuf* pciids)
     ffReadFileBuffer(_PATH_LOCALBASE "/share/pciids/pci.ids", pciids);
     if (pciids->length > 0) return true;
 
-    ffReadFileBuffer("/usr/share/pciids/pci.ids", pciids);
+    ffReadFileBuffer(FASTFETCH_TARGET_DIR_USR "/share/pciids/pci.ids", pciids);
     if (pciids->length > 0) return true;
 
     return false;
@@ -74,7 +74,7 @@ const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
         {
             if (pciids.length == 0)
                 loadPciIds(&pciids);
-            ffGPUParsePciIds(&pciids, pc->pc_subclass, pc->pc_vendor, pc->pc_device, pc->pc_subvendor, pc->pc_subdevice, gpu);
+            ffGPUParsePciIds(&pciids, pc->pc_subclass, pc->pc_vendor, pc->pc_device, gpu);
         }
 
         #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API

src/detection/gpu/gpu_linux.c

@@ -9,6 +9,9 @@
     #include "detection/gpu/gpu_driver_specific.h"
 #endif
 
+#define FF_STR_INDIR(x) #x
+#define FF_STR(x) FF_STR_INDIR(x)
+
 #include <inttypes.h>
 
 FF_MAYBE_UNUSED static void pciDetectTemp(FFGPUResult* gpu, uint32_t deviceClass)
@@ -53,13 +56,18 @@ static void pciDetectDriver(FFGPUResult* gpu, FFstrbuf* pciDir, FFstrbuf* buffer
 
 static bool loadPciIds(FFstrbuf* pciids)
 {
-    ffReadFileBuffer("/usr/share/hwdata/pci.ids", pciids);
+    #ifdef FF_CUSTOM_PCI_IDS_PATH
+    ffReadFileBuffer(FF_STR(FF_CUSTOM_PCI_IDS_PATH), pciids);
+    if (pciids->length > 0) return true;
+    #endif
+
+    ffReadFileBuffer(FASTFETCH_TARGET_DIR_USR "/share/hwdata/pci.ids", pciids);
     if (pciids->length > 0) return true;
 
-    ffReadFileBuffer("/usr/share/misc/pci.ids", pciids); // debian?
+    ffReadFileBuffer(FASTFETCH_TARGET_DIR_USR "/share/misc/pci.ids", pciids); // debian?
     if (pciids->length > 0) return true;
 
-    ffReadFileBuffer("/usr/local/share/hwdata/pci.ids", pciids);
+    ffReadFileBuffer(FASTFETCH_TARGET_DIR_USR "/local/share/hwdata/pci.ids", pciids);
     if (pciids->length > 0) return true;
 
     return false;
@@ -143,7 +151,7 @@ static const char* pciDetectGPUs(const FFGPUOptions* options, FFlist* gpus)
         {
             if (!pciids.length)
                 loadPciIds(&pciids);
-            ffGPUParsePciIds(&pciids, subclassId, (uint16_t) vendorId, (uint16_t) deviceId, (uint16_t) subVendorId, (uint16_t) subDeviceId, gpu);
+            ffGPUParsePciIds(&pciids, subclassId, (uint16_t) vendorId, (uint16_t) deviceId, gpu);
         }
 
         pciDetectDriver(gpu, &pciDir, &buffer);

src/detection/gpu/gpu_pci.c

@@ -1,6 +1,6 @@
 #include "gpu.h"
 
-void ffGPUParsePciIds(FFstrbuf* content, uint8_t subclass, uint16_t vendor, uint16_t device, uint16_t subVendor, uint16_t subDevice, FFGPUResult* gpu)
+void ffGPUParsePciIds(FFstrbuf* content, uint8_t subclass, uint16_t vendor, uint16_t device, FFGPUResult* gpu)
 {
     if (content->length)
     {
@@ -40,13 +40,6 @@ void ffGPUParsePciIds(FFstrbuf* content, uint8_t subclass, uint16_t vendor, uint
             if (start)
             {
                 start += len;
-
-                // Search for subvendor and subdevice
-                len = (uint32_t) snprintf(buffer, sizeof(buffer), "\n\t\t%04x %04x  ", subVendor, subDevice);
-                char* subStart = memmem(start, (size_t) (end - start), buffer, len);
-                if (subStart)
-                    start = subStart + len;
-
                 end = memchr(start, '\n', (uint32_t) (end - start));
                 if (!end)
                     end = content->chars + content->length;

src/detection/lm/lm_linux.c

@@ -63,7 +63,7 @@ static const char* getSddmVersion(FFstrbuf* version)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(zlib, gzrewind)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(zlib, gzclose)
 
-    gzFile file = ffgzopen("/usr/share/man/man1/sddm.1.gz", "rb");
+    gzFile file = ffgzopen(FASTFETCH_TARGET_DIR_USR "/share/man/man1/sddm.1.gz", "rb");
     if (file == Z_NULL)
         return "ffgzopen(\"/usr/share/man/man1/sddm.1.gz\", \"rb\") failed";
 

src/detection/packages/packages_apple.c

@@ -45,14 +45,14 @@ static void getBrewPackages(FFPackagesResult* result)
     if(ffStrSet(prefix))
         return countBrewPackages(prefix, result);
 
-    countBrewPackages(FASTFETCH_TARGET_DIR_ROOT"/opt/homebrew", result);
-    countBrewPackages(FASTFETCH_TARGET_DIR_ROOT"/usr/local", result);
+    countBrewPackages(FASTFETCH_TARGET_DIR_ROOT "/opt/homebrew", result);
+    countBrewPackages(FASTFETCH_TARGET_DIR_USR "/local", result);
 }
 
 static uint32_t countMacPortsPackages(const char* dirname)
 {
     FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateS(dirname);
-    ffStrbufAppendS(&baseDir, "/var/macports/software");
+    ffStrbufAppendS(&baseDir, FASTFETCH_TARGET_DIR_ROOT "/var/macports/software");
 
     return getNumElements(baseDir.chars, DT_DIR);
 }
@@ -63,7 +63,7 @@ static uint32_t getMacPortsPackages()
     if(ffStrSet(prefix))
         return countMacPortsPackages(prefix);
 
-    return countMacPortsPackages(FASTFETCH_TARGET_DIR_ROOT"/opt/local");
+    return countMacPortsPackages(FASTFETCH_TARGET_DIR_ROOT "/opt/local");
 }
 
 static uint32_t getNixPackagesImpl(char* path)
@@ -81,7 +81,7 @@ static uint32_t getNixPackagesImpl(char* path)
     ffStrbufAppendS(&command, "); do if [ -d $x ]; then echo $x ; fi ; done | cut -d- -f2- | egrep '([0-9]{1,}\\.)+[0-9]{1,}' | egrep -v '\\-doc$|\\-man$|\\-info$|\\-dev$|\\-bin$|^nixos-system-nixos-' | uniq | wc -l");
 
     ffProcessAppendStdOut(&output, (char* const[]) {
-        "/bin/sh",
+        FASTFETCH_TARGET_DIR_ROOT "/bin/sh",
         "-c",
         command.chars,
         NULL

src/detection/terminalfont/terminalfont_linux.c

@@ -303,6 +303,34 @@ static void detectSt(FFTerminalFontResult* terminalFont, uint32_t pid)
     ffFontInitValues(&terminalFont->font, font.chars, size.chars);
 }
 
+static void detectWarp(FFTerminalFontResult* terminalFont)
+{
+    FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
+
+    FF_LIST_FOR_EACH(FFstrbuf, dirPrefix, instance.state.platform.configDirs)
+    {
+        //We need to copy the dir each time, because it used by multiple threads, so we can't directly write to it.
+        ffStrbufSet(&baseDir, dirPrefix);
+        ffStrbufAppendS(&baseDir, "warp-terminal/user_preferences.json");
+
+        yyjson_doc* doc = yyjson_read_file(baseDir.chars, YYJSON_READ_INSITU | YYJSON_READ_ALLOW_TRAILING_COMMAS | YYJSON_READ_ALLOW_COMMENTS, NULL, NULL);
+        if (!doc) continue;
+
+        yyjson_val* prefs = yyjson_obj_get(yyjson_doc_get_root(doc), "prefs");
+        if (yyjson_is_obj(prefs))
+        {
+            const char* fontName = yyjson_get_str(yyjson_obj_get(prefs, "FontName"));
+            if (!fontName) fontName = "Hack";
+            const char* fontSize = yyjson_get_str(yyjson_obj_get(prefs, "FontSize"));
+            if (!fontSize) fontSize = "13";
+
+            ffFontInitValues(&terminalFont->font, fontName, fontSize);
+        }
+        yyjson_doc_free(doc);
+        return;
+    }
+}
+
 void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufIgnCaseEqualS(&terminal->processName, "konsole"))
@@ -331,4 +359,6 @@ void ffDetectTerminalFontPlatform(const FFTerminalResult* terminal, FFTerminalFo
         detectXterm(terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminal->processName, "st"))
         detectSt(terminalFont, terminal->pid);
+    else if(ffStrbufIgnCaseEqualS(&terminal->processName, "warp"))
+        detectWarp(terminalFont);
 }

src/detection/terminalshell/terminalshell.c

@@ -423,6 +423,20 @@ static bool getTerminalVersionScreen(FFstrbuf* exe, FFstrbuf* version)
     return version->length > 0;
 }
 
+static bool getTerminalVersionTmux(FFstrbuf* exe, FFstrbuf* version)
+{
+    if (ffProcessAppendStdOut(version, (char* const[]) {
+        exe->chars,
+        "-V",
+        NULL
+    }) != NULL)
+        return false;
+
+    // tmux 3.4
+    ffStrbufSubstrAfterFirstC(version, ' ');
+    return version->length > 0;
+}
+
 #ifdef _WIN32
 
 static bool getTerminalVersionWindowsTerminal(FFstrbuf* exe, FFstrbuf* version)
@@ -548,7 +562,13 @@ bool fftsGetTerminalVersion(FFstrbuf* processName, FF_MAYBE_UNUSED FFstrbuf* exe
         {
             if(ffStrbufStartsWithIgnCaseS(processName, termProgram) || // processName ends with `.exe` on Windows
                 (ffStrEquals(termProgram, "vscode") && ffStrbufStartsWithIgnCaseS(processName, "code")) ||
-                (ffStrEquals(termProgram, "iTerm.app") && ffStrbufStartsWithIgnCaseS(processName, "iTermServer-"))
+
+                #ifdef __APPLE__
+                (ffStrEquals(termProgram, "iTerm.app") && ffStrbufStartsWithIgnCaseS(processName, "iTermServer-")) ||
+                #elif defined(__linux__)
+                (ffStrEquals(termProgram, "WarpTerminal") && ffStrbufEqualS(processName, "warp")) ||
+                #endif
+                false
             ) {
                 ffStrbufSetS(version, termProgramVersion);
                 return true;
@@ -572,6 +592,9 @@ bool fftsGetTerminalVersion(FFstrbuf* processName, FF_MAYBE_UNUSED FFstrbuf* exe
         }
     }
 
+    if(ffStrbufStartsWithIgnCaseS(processName, "tmux"))
+        return getTerminalVersionTmux(exe, version);
+
     #ifdef _WIN32
 
     return getFileVersion(exe->chars, version);

src/detection/terminalshell/terminalshell.h

@@ -23,6 +23,7 @@ typedef struct FFTerminalResult
     const char* exeName; //pointer to a char in exe
     FFstrbuf exePath; //Full real path to executable file
     FFstrbuf version;
+    FFstrbuf tty;
     uint32_t pid;
     uint32_t ppid;
 } FFTerminalResult;

src/detection/terminalshell/terminalshell_linux.c

@@ -148,12 +148,7 @@ static const char* getProcessNameAndPpid(pid_t pid, char* name, pid_t* ppid, int
         return "sscanf(stat) failed";
 
     if (tty)
-    {
-        if ((tty_ >> 8) == 0x88)
-            *tty = tty_ & 0xFF;
-        else
-            *tty = -1;
-    }
+        *tty = tty_ & 0xFF;
 
     #elif defined(__APPLE__)
 
@@ -571,6 +566,7 @@ const FFTerminalResult* ffDetectTerminal()
     result.exeName = result.exe.chars;
     ffStrbufInit(&result.exePath);
     ffStrbufInit(&result.version);
+    ffStrbufInitS(&result.tty, ttyname(STDOUT_FILENO));
     result.pid = 0;
     result.ppid = 0;
 

src/detection/terminalshell/terminalshell_windows.c

@@ -406,6 +406,7 @@ const FFTerminalResult* ffDetectTerminal(void)
     ffStrbufInit(&result.exePath);
     ffStrbufInit(&result.prettyName);
     ffStrbufInit(&result.version);
+    ffStrbufInit(&result.tty);
     result.pid = 0;
     result.ppid = 0;
 

src/modules/battery/battery.c

@@ -2,6 +2,7 @@
 #include "common/jsonconfig.h"
 #include "common/percent.h"
 #include "common/parsing.h"
+#include "common/temps.h"
 #include "detection/battery/battery.h"
 #include "modules/battery/battery.h"
 #include "util/stringUtils.h"
@@ -49,7 +50,7 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
             if(str.length > 0)
                 ffStrbufAppendS(&str, " - ");
 
-            ffParseTemperature(result->temperature, &str);
+            ffTempsAppendNum(result->temperature, &str, options->tempConfig);
         }
 
         ffStrbufPutTo(&str, stdout);
@@ -58,13 +59,15 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
     {
         FF_STRBUF_AUTO_DESTROY capacityStr = ffStrbufCreate();
         ffPercentAppendNum(&capacityStr, result->capacity, options->percent, false);
+        FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+        ffTempsAppendNum(result->temperature, &tempStr, options->tempConfig);
         ffPrintFormat(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->technology},
             {FF_FORMAT_ARG_TYPE_STRBUF, &capacityStr},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->status},
-            {FF_FORMAT_ARG_TYPE_DOUBLE, &result->temperature},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr},
             {FF_FORMAT_ARG_TYPE_UINT, &result->cycleCount},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->serial},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufactureDate},
@@ -108,11 +111,8 @@ bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, co
     if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
         return true;
 
-    if (ffStrEqualsIgnCase(subKey, "temp"))
-    {
-        options->temp = ffOptionParseBoolean(value);
+    if (ffTempsParseCommandOptions(key, subKey, value, &options->temp, &options->tempConfig))
         return true;
-    }
 
     #ifdef _WIN32
         if (ffStrEqualsIgnCase(subKey, "use-setup-api"))
@@ -149,11 +149,8 @@ void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module)
         }
         #endif
 
-        if (ffStrEqualsIgnCase(key, "temp"))
-        {
-            options->temp = yyjson_get_bool(val);
+        if (ffTempsParseJsonObject(key, val, &options->temp, &options->tempConfig))
             continue;
-        }
 
         if (ffPercentParseJsonObject(key, val, &options->percent))
             continue;
@@ -174,8 +171,7 @@ void ffGenerateBatteryJsonConfig(FFBatteryOptions* options, yyjson_mut_doc* doc,
         yyjson_mut_obj_add_bool(doc, module, "useSetupApi", options->useSetupApi);
     #endif
 
-    if (options->temp != defaultOptions.temp)
-        yyjson_mut_obj_add_bool(doc, module, "temp", options->temp);
+    ffTempsGenerateJsonConfig(doc, module, defaultOptions.temp, defaultOptions.tempConfig, options->temp, options->tempConfig);
 
     ffPercentGenerateJsonConfig(doc, module, defaultOptions.percent, options->percent);
 }
@@ -226,7 +222,7 @@ void ffPrintBatteryHelpFormat(void)
         "Battery technology",
         "Battery capacity (percentage)",
         "Battery status",
-        "Battery temperature",
+        "Battery temperature (formatted)",
         "Battery cycle count",
         "Battery serial number",
         "Battery manufactor date",
@@ -248,7 +244,8 @@ void ffInitBatteryOptions(FFBatteryOptions* options)
     );
     ffOptionInitModuleArg(&options->moduleArgs);
     options->temp = false;
-    options->percent = (FFPercentConfig) { 50, 20 };
+    options->tempConfig = (FFColorRangeConfig) { 60, 80 };
+    options->percent = (FFColorRangeConfig) { 50, 20 };
 
     #ifdef _WIN32
         options->useSetupApi = false;

src/modules/battery/option.h

@@ -11,7 +11,8 @@ typedef struct FFBatteryOptions
     FFModuleArgs moduleArgs;
 
     bool temp;
-    FFPercentConfig percent;
+    FFColorRangeConfig tempConfig;
+    FFColorRangeConfig percent;
 
     #ifdef _WIN32
         bool useSetupApi;

src/modules/bluetooth/bluetooth.c

@@ -198,7 +198,7 @@ void ffInitBluetoothOptions(FFBluetoothOptions* options)
     );
     ffOptionInitModuleArg(&options->moduleArgs);
     options->showDisconnected = false;
-    options->percent = (FFPercentConfig) { 50, 20 };
+    options->percent = (FFColorRangeConfig) { 50, 20 };
 }
 
 void ffDestroyBluetoothOptions(FFBluetoothOptions* options)

src/modules/bluetooth/option.h

@@ -11,5 +11,5 @@ typedef struct FFBluetoothOptions
     FFModuleArgs moduleArgs;
 
     bool showDisconnected;
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFBluetoothOptions;

src/modules/brightness/brightness.c

@@ -205,7 +205,7 @@ void ffInitBrightnessOptions(FFBrightnessOptions* options)
     ffOptionInitModuleArg(&options->moduleArgs);
 
     options->ddcciSleep = 10;
-    options->percent = (FFPercentConfig) { 100, 100 };
+    options->percent = (FFColorRangeConfig) { 100, 100 };
 }
 
 void ffDestroyBrightnessOptions(FFBrightnessOptions* options)

src/modules/brightness/option.h

@@ -11,5 +11,5 @@ typedef struct FFBrightnessOptions
     FFModuleArgs moduleArgs;
 
     uint32_t ddcciSleep; // ms
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFBrightnessOptions;

src/modules/cpu/cpu.c

@@ -1,6 +1,7 @@
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "common/parsing.h"
+#include "common/temps.h"
 #include "detection/cpu/cpu.h"
 #include "modules/cpu/cpu.h"
 #include "util/stringUtils.h"
@@ -53,13 +54,15 @@ void ffPrintCPU(FFCPUOptions* options)
             if(cpu.temperature == cpu.temperature) //FF_CPU_TEMP_UNSET
             {
                 ffStrbufAppendS(&str, " - ");
-                ffParseTemperature(cpu.temperature, &str);
+                ffTempsAppendNum(cpu.temperature, &str, options->tempConfig);
             }
 
             ffStrbufPutTo(&str, stdout);
         }
         else
         {
+            FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+            ffTempsAppendNum(cpu.temperature, &tempStr, options->tempConfig);
             ffPrintFormat(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
                 {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.name},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.vendor},
@@ -68,7 +71,7 @@ void ffPrintCPU(FFCPUOptions* options)
                 {FF_FORMAT_ARG_TYPE_UINT16, &cpu.coresOnline},
                 {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMin},
                 {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMax},
-                {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.temperature}
+                {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr}
             });
         }
     }
@@ -84,11 +87,8 @@ bool ffParseCPUCPUOptions(FFCPUOptions* options, const char* key, const char* va
     if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
         return true;
 
-    if (ffStrEqualsIgnCase(subKey, "temp"))
-    {
-        options->temp = ffOptionParseBoolean(value);
+    if (ffTempsParseCommandOptions(key, subKey, value, &options->temp, &options->tempConfig))
         return true;
-    }
 
     if (ffStrEqualsIgnCase(subKey, "freq-ndigits"))
     {
@@ -112,11 +112,8 @@ void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module)
         if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
             continue;
 
-        if (ffStrEqualsIgnCase(key, "temp"))
-        {
-            options->temp = yyjson_get_bool(val);
+        if (ffTempsParseJsonObject(key, val, &options->temp, &options->tempConfig))
             continue;
-        }
 
         if (ffStrEqualsIgnCase(key, "freqNdigits"))
         {
@@ -135,8 +132,7 @@ void ffGenerateCPUJsonConfig(FFCPUOptions* options, yyjson_mut_doc* doc, yyjson_
 
     ffJsonConfigGenerateModuleArgsConfig(doc, module, &defaultOptions.moduleArgs, &options->moduleArgs);
 
-    if (defaultOptions.temp != options->temp)
-        yyjson_mut_obj_add_bool(doc, module, "temp", options->temp);
+    ffTempsGenerateJsonConfig(doc, module, defaultOptions.temp, defaultOptions.tempConfig, options->temp, options->tempConfig);
 
     if (defaultOptions.freqNdigits != options->freqNdigits)
         yyjson_mut_obj_add_uint(doc, module, "freqNdigits", options->freqNdigits);
@@ -193,7 +189,7 @@ void ffPrintCPUHelpFormat(void)
         "Online core count",
         "Min frequency",
         "Max frequency",
-        "Temperature"
+        "Temperature (formatted)"
     });
 }
 
@@ -212,6 +208,7 @@ void ffInitCPUOptions(FFCPUOptions* options)
     );
     ffOptionInitModuleArg(&options->moduleArgs);
     options->temp = false;
+    options->tempConfig = (FFColorRangeConfig) { 60, 80 };
     options->freqNdigits = 2;
 }
 

src/modules/cpu/option.h

@@ -10,5 +10,6 @@ typedef struct FFCPUOptions
     FFModuleArgs moduleArgs;
 
     bool temp;
+    FFColorRangeConfig tempConfig;
     uint8_t freqNdigits;
 } FFCPUOptions;

src/modules/cpuusage/cpuusage.c

@@ -190,7 +190,7 @@ void ffInitCPUUsageOptions(FFCPUUsageOptions* options)
     );
     ffOptionInitModuleArg(&options->moduleArgs);
     options->separate = false;
-    options->percent = (FFPercentConfig) { 50, 80 };
+    options->percent = (FFColorRangeConfig) { 50, 80 };
 }
 
 void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options)

src/modules/cpuusage/option.h

@@ -11,5 +11,5 @@ typedef struct FFCPUUsageOptions
     FFModuleArgs moduleArgs;
 
     bool separate;
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFCPUUsageOptions;

src/modules/disk/disk.c

@@ -484,7 +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 };
+    options->percent = (FFColorRangeConfig) { 50, 80 };
 }
 
 void ffDestroyDiskOptions(FFDiskOptions* options)

src/modules/disk/option.h

@@ -30,5 +30,5 @@ typedef struct FFDiskOptions
     FFstrbuf folders;
     FFDiskVolumeType showTypes;
     FFDiskCalcType calcType;
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFDiskOptions;

src/modules/gamepad/gamepad.c

@@ -162,7 +162,7 @@ void ffInitGamepadOptions(FFGamepadOptions* options)
         ffGenerateGamepadJsonConfig
     );
     ffOptionInitModuleArg(&options->moduleArgs);
-    options->percent = (FFPercentConfig) { 50, 20 };
+    options->percent = (FFColorRangeConfig) { 50, 20 };
 }
 
 void ffDestroyGamepadOptions(FFGamepadOptions* options)

src/modules/gamepad/option.h

@@ -9,5 +9,5 @@ typedef struct FFGamepadOptions
     FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFGamepadOptions;

src/modules/gpu/gpu.c

@@ -2,6 +2,7 @@
 #include "common/parsing.h"
 #include "common/printing.h"
 #include "common/jsonconfig.h"
+#include "common/temps.h"
 #include "detection/host/host.h"
 #include "detection/gpu/gpu.h"
 #include "modules/gpu/gpu.h"
@@ -44,7 +45,7 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu
         if(gpu->temperature == gpu->temperature) //FF_GPU_TEMP_UNSET
         {
             ffStrbufAppendS(&output, " - ");
-            ffParseTemperature(gpu->temperature, &output);
+            ffTempsAppendNum(gpu->temperature, &output, options->tempConfig);
         }
 
         if(gpu->dedicated.total != FF_GPU_VMEM_SIZE_UNSET && gpu->dedicated.total != 0)
@@ -72,11 +73,13 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu
     }
     else
     {
+        FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+        ffTempsAppendNum(gpu->temperature, &tempStr, options->tempConfig);
         ffPrintFormat(FF_GPU_MODULE_NAME, index, &options->moduleArgs, FF_GPU_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->vendor},
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->driver},
-            {FF_FORMAT_ARG_TYPE_DOUBLE, &gpu->temperature},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr},
             {FF_FORMAT_ARG_TYPE_INT, &gpu->coreCount},
             {FF_FORMAT_ARG_TYPE_STRING, type},
             {FF_FORMAT_ARG_TYPE_UINT64, &gpu->dedicated.total},
@@ -146,11 +149,8 @@ bool ffParseGPUCommandOptions(FFGPUOptions* options, const char* key, const char
         return true;
     }
 
-    if (ffStrEqualsIgnCase(subKey, "temp"))
-    {
-        options->temp = ffOptionParseBoolean(value);
+    if (ffTempsParseCommandOptions(key, subKey, value, &options->temp, &options->tempConfig))
         return true;
-    }
 
     if (ffStrEqualsIgnCase(subKey, "hide-type"))
     {
@@ -181,11 +181,8 @@ void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module)
         if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
             continue;
 
-        if (ffStrEqualsIgnCase(key, "temp"))
-        {
-            options->temp = yyjson_get_bool(val);
+        if (ffTempsParseJsonObject(key, val, &options->temp, &options->tempConfig))
             continue;
-        }
 
         if (ffStrEqualsIgnCase(key, "driverSpecific"))
         {
@@ -235,8 +232,7 @@ void ffGenerateGPUJsonConfig(FFGPUOptions* options, yyjson_mut_doc* doc, yyjson_
     if (options->forceVulkan != defaultOptions.forceVulkan)
         yyjson_mut_obj_add_bool(doc, module, "forceVulkan", options->forceVulkan);
 
-    if (options->temp != defaultOptions.temp)
-        yyjson_mut_obj_add_bool(doc, module, "temp", options->temp);
+    ffTempsGenerateJsonConfig(doc, module, defaultOptions.temp, defaultOptions.tempConfig, options->temp, options->tempConfig);
 
     if (options->hideType != defaultOptions.hideType)
     {
@@ -371,7 +367,8 @@ void ffInitGPUOptions(FFGPUOptions* options)
     options->forceVulkan = false;
     options->temp = false;
     options->hideType = FF_GPU_TYPE_UNKNOWN;
-    options->percent = (FFPercentConfig) { 50, 80 };
+    options->tempConfig = (FFColorRangeConfig) { 60, 80 };
+    options->percent = (FFColorRangeConfig) { 50, 80 };
 }
 
 void ffDestroyGPUOptions(FFGPUOptions* options)

src/modules/gpu/option.h

@@ -21,5 +21,6 @@ typedef struct FFGPUOptions
     bool temp;
     bool driverSpecific;
     bool forceVulkan;
-    FFPercentConfig percent;
+    FFColorRangeConfig tempConfig;
+    FFColorRangeConfig percent;
 } FFGPUOptions;

src/modules/memory/memory.c

@@ -148,7 +148,7 @@ void ffInitMemoryOptions(FFMemoryOptions* options)
         ffGenerateMemoryJsonConfig
     );
     ffOptionInitModuleArg(&options->moduleArgs);
-    options->percent = (FFPercentConfig) { 50, 80 };
+    options->percent = (FFColorRangeConfig) { 50, 80 };
 }
 
 void ffDestroyMemoryOptions(FFMemoryOptions* options)

src/modules/memory/option.h

@@ -10,5 +10,5 @@ typedef struct FFMemoryOptions
     FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFMemoryOptions;

src/modules/physicaldisk/option.h

@@ -11,4 +11,5 @@ typedef struct FFPhysicalDiskOptions
 
     FFstrbuf namePrefix;
     bool temp;
+    FFColorRangeConfig tempConfig;
 } FFPhysicalDiskOptions;

src/modules/physicaldisk/physicaldisk.c

@@ -1,6 +1,7 @@
 #include "common/printing.h"
 #include "common/jsonconfig.h"
 #include "common/parsing.h"
+#include "common/temps.h"
 #include "detection/physicaldisk/physicaldisk.h"
 #include "modules/physicaldisk/physicaldisk.h"
 #include "util/stringUtils.h"
@@ -96,12 +97,14 @@ void ffPrintPhysicalDisk(FFPhysicalDiskOptions* options)
                 if(buffer.length > 0)
                     ffStrbufAppendS(&buffer, " - ");
 
-                ffParseTemperature(dev->temperature, &buffer);
+                ffTempsAppendNum(dev->temperature, &buffer, options->tempConfig);
             }
             ffStrbufPutTo(&buffer, stdout);
         }
         else
         {
+            FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+            ffTempsAppendNum(dev->temperature, &tempStr, options->tempConfig);
             if (dev->type & FF_PHYSICALDISK_TYPE_READWRITE)
                 readOnlyType = "Read-write";
             ffParseSize(dev->size, &buffer);
@@ -115,7 +118,7 @@ void ffPrintPhysicalDisk(FFPhysicalDiskOptions* options)
                 {FF_FORMAT_ARG_TYPE_STRING, removableType},
                 {FF_FORMAT_ARG_TYPE_STRING, readOnlyType},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &dev->revision},
-                {FF_FORMAT_ARG_TYPE_DOUBLE, &dev->temperature},
+                {FF_FORMAT_ARG_TYPE_DOUBLE, &tempStr},
             });
         }
         ++index;
@@ -143,11 +146,8 @@ bool ffParsePhysicalDiskCommandOptions(FFPhysicalDiskOptions* options, const cha
         return true;
     }
 
-    if (ffStrEqualsIgnCase(subKey, "temp"))
-    {
-        options->temp = ffOptionParseBoolean(value);
+    if (ffTempsParseCommandOptions(key, subKey, value, &options->temp, &options->tempConfig))
         return true;
-    }
 
     return false;
 }
@@ -171,11 +171,8 @@ void ffParsePhysicalDiskJsonObject(FFPhysicalDiskOptions* options, yyjson_val* m
             continue;
         }
 
-        if (ffStrEqualsIgnCase(key, "temp"))
-        {
-            options->temp = yyjson_get_bool(val);
+        if (ffTempsParseJsonObject(key, val, &options->temp, &options->tempConfig))
             continue;
-        }
 
         ffPrintError(FF_PHYSICALDISK_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
     }
@@ -191,8 +188,7 @@ void ffGeneratePhysicalDiskJsonConfig(FFPhysicalDiskOptions* options, yyjson_mut
     if (!ffStrbufEqual(&options->namePrefix, &defaultOptions.namePrefix))
         yyjson_mut_obj_add_strbuf(doc, module, "namePrefix", &options->namePrefix);
 
-    if (options->temp != defaultOptions.temp)
-        yyjson_mut_obj_add_bool(doc, module, "temp", options->temp);
+    ffTempsGenerateJsonConfig(doc, module, defaultOptions.temp, defaultOptions.tempConfig, options->temp, options->tempConfig);
 }
 
 void ffGeneratePhysicalDiskJsonResult(FFPhysicalDiskOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
@@ -263,7 +259,7 @@ void ffPrintPhysicalDiskHelpFormat(void)
         "Device kind (Removable or Fixed)",
         "Device kind (Read-only or Read-write)",
         "Product revision",
-        "Device temperature",
+        "Device temperature (formatted)",
     });
 }
 
@@ -284,6 +280,7 @@ void ffInitPhysicalDiskOptions(FFPhysicalDiskOptions* options)
 
     ffStrbufInit(&options->namePrefix);
     options->temp = false;
+    options->tempConfig = (FFColorRangeConfig) { 40, 60 };
 }
 
 void ffDestroyPhysicalDiskOptions(FFPhysicalDiskOptions* options)

src/modules/sound/option.h

@@ -18,5 +18,5 @@ typedef struct FFSoundOptions
     FFModuleArgs moduleArgs;
 
     FFSoundType soundType;
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFSoundOptions;

src/modules/sound/sound.c

@@ -255,7 +255,7 @@ void ffInitSoundOptions(FFSoundOptions* options)
     ffOptionInitModuleArg(&options->moduleArgs);
 
     options->soundType = FF_SOUND_TYPE_MAIN;
-    options->percent = (FFPercentConfig) { 80, 90 };
+    options->percent = (FFColorRangeConfig) { 80, 90 };
 }
 
 void ffDestroySoundOptions(FFSoundOptions* options)

src/modules/swap/option.h

@@ -10,5 +10,5 @@ typedef struct FFSwapOptions
     FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
-    FFPercentConfig percent;
+    FFColorRangeConfig percent;
 } FFSwapOptions;

src/modules/swap/swap.c

@@ -157,7 +157,7 @@ void ffInitSwapOptions(FFSwapOptions* options)
         ffGenerateSwapJsonConfig
     );
     ffOptionInitModuleArg(&options->moduleArgs);
-    options->percent = (FFPercentConfig) { 50, 80 };
+    options->percent = (FFColorRangeConfig) { 50, 80 };
 }
 
 void ffDestroySwapOptions(FFSwapOptions* options)

src/modules/terminal/terminal.c

@@ -6,7 +6,7 @@
 
 #include <string.h>
 
-#define FF_TERMINAL_NUM_FORMAT_ARGS 7
+#define FF_TERMINAL_NUM_FORMAT_ARGS 8
 
 void ffPrintTerminal(FFTerminalOptions* options)
 {
@@ -37,6 +37,7 @@ void ffPrintTerminal(FFTerminalOptions* options)
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->prettyName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->version},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->exePath},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->tty},
         });
     }
 }
@@ -95,6 +96,7 @@ void ffGenerateTerminalJsonResult(FF_MAYBE_UNUSED FFTerminalOptions* options, yy
     yyjson_mut_obj_add_uint(doc, obj, "ppid", result->ppid);
     yyjson_mut_obj_add_strbuf(doc, obj, "prettyName", &result->prettyName);
     yyjson_mut_obj_add_strbuf(doc, obj, "version", &result->version);
+    yyjson_mut_obj_add_strbuf(doc, obj, "tty", &result->tty);
 }
 
 void ffPrintTerminalHelpFormat(void)
@@ -107,6 +109,7 @@ void ffPrintTerminalHelpFormat(void)
         "Terminal pretty name",
         "Terminal version",
         "Terminal full exe path",
+        "Terminal tty / pts used",
     });
 }
 

src/options/display.c

@@ -94,20 +94,46 @@ 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);
         }
-        else if (ffStrEqualsIgnCase(key, "temperatureUnit"))
+        else if (ffStrEqualsIgnCase(key, "temp"))
         {
-            int value;
-            const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) {
-                { "CELSIUS", FF_TEMPERATURE_UNIT_CELSIUS },
-                { "C", FF_TEMPERATURE_UNIT_CELSIUS },
-                { "FAHRENHEIT", FF_TEMPERATURE_UNIT_FAHRENHEIT },
-                { "F", FF_TEMPERATURE_UNIT_FAHRENHEIT },
-                { "KELVIN", FF_TEMPERATURE_UNIT_KELVIN },
-                { "K", FF_TEMPERATURE_UNIT_KELVIN },
-                {},
-            });
-            if (error) return error;
-            options->temperatureUnit = (FFTemperatureUnit) value;
+            if (!yyjson_is_obj(val))
+                return "display.temp must be an object";
+
+            yyjson_val* unit = yyjson_obj_get(val, "unit");
+            if (unit)
+            {
+                int value;
+                const char* error = ffJsonConfigParseEnum(unit, &value, (FFKeyValuePair[]) {
+                    { "CELSIUS", FF_TEMPERATURE_UNIT_CELSIUS },
+                    { "C", FF_TEMPERATURE_UNIT_CELSIUS },
+                    { "FAHRENHEIT", FF_TEMPERATURE_UNIT_FAHRENHEIT },
+                    { "F", FF_TEMPERATURE_UNIT_FAHRENHEIT },
+                    { "KELVIN", FF_TEMPERATURE_UNIT_KELVIN },
+                    { "K", FF_TEMPERATURE_UNIT_KELVIN },
+                    {},
+                });
+                if (error) return error;
+                options->temperatureUnit = (FFTemperatureUnit) value;
+            }
+
+            yyjson_val* ndigits = yyjson_obj_get(val, "ndigits");
+            if (ndigits) options->tempNdigits = (uint8_t) yyjson_get_uint(ndigits);
+
+            yyjson_val* color = yyjson_obj_get(val, "color");
+            if (color)
+            {
+                if (!yyjson_is_obj(color))
+                    return "display.temperature.color must be an object";
+
+                yyjson_val* green = yyjson_obj_get(color, "green");
+                if (green) ffOptionParseColor(yyjson_get_str(green), &options->tempColorGreen);
+
+                yyjson_val* yellow = yyjson_obj_get(color, "yellow");
+                if (yellow) ffOptionParseColor(yyjson_get_str(yellow), &options->tempColorYellow);
+
+                yyjson_val* red = yyjson_obj_get(color, "red");
+                if (red) ffOptionParseColor(yyjson_get_str(red), &options->tempColorRed);
+            }
         }
         else if (ffStrEqualsIgnCase(key, "percent"))
         {
@@ -253,17 +279,31 @@ bool ffOptionsParseDisplayCommandLine(FFOptionsDisplay* options, const char* key
             {}
         });
     }
-    else if(ffStrEqualsIgnCase(key, "--temperature-unit"))
+    else if(ffStrStartsWithIgnCase(key, "--temperature-"))
     {
-        options->temperatureUnit = (FFTemperatureUnit) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
-            { "CELSIUS", FF_TEMPERATURE_UNIT_CELSIUS },
-            { "C", FF_TEMPERATURE_UNIT_CELSIUS },
-            { "FAHRENHEIT", FF_TEMPERATURE_UNIT_FAHRENHEIT },
-            { "F", FF_TEMPERATURE_UNIT_FAHRENHEIT },
-            { "KELVIN", FF_TEMPERATURE_UNIT_KELVIN },
-            { "K", FF_TEMPERATURE_UNIT_KELVIN },
-            {},
-        });
+        const char* subkey = key + strlen("--temperature-");
+        if(ffStrEqualsIgnCase(subkey, "unit"))
+        {
+            options->temperatureUnit = (FFTemperatureUnit) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
+                { "CELSIUS", FF_TEMPERATURE_UNIT_CELSIUS },
+                { "C", FF_TEMPERATURE_UNIT_CELSIUS },
+                { "FAHRENHEIT", FF_TEMPERATURE_UNIT_FAHRENHEIT },
+                { "F", FF_TEMPERATURE_UNIT_FAHRENHEIT },
+                { "KELVIN", FF_TEMPERATURE_UNIT_KELVIN },
+                { "K", FF_TEMPERATURE_UNIT_KELVIN },
+                {},
+            });
+        }
+        else if (ffStrEqualsIgnCase(subkey, "ndigits"))
+            options->tempNdigits = (uint8_t) ffOptionParseUInt32(key, value);
+        else if(ffStrEqualsIgnCase(subkey, "color-green"))
+            ffOptionParseColor(value, &options->tempColorGreen);
+        else if(ffStrEqualsIgnCase(subkey, "color-yellow"))
+            ffOptionParseColor(value, &options->tempColorYellow);
+        else if(ffStrEqualsIgnCase(subkey, "color-red"))
+            ffOptionParseColor(value, &options->tempColorRed);
+        else
+            return false;
     }
     else if(ffStrStartsWithIgnCase(key, "--percent-"))
     {
@@ -323,11 +363,16 @@ void ffOptionsInitDisplay(FFOptionsDisplay* options)
     options->binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
     options->sizeNdigits = 2;
     options->sizeMaxPrefix = UINT8_MAX;
-    options->temperatureUnit = FF_TEMPERATURE_UNIT_CELSIUS;
     options->stat = false;
     options->noBuffer = false;
     options->keyWidth = 0;
 
+    options->temperatureUnit = FF_TEMPERATURE_UNIT_CELSIUS;
+    options->tempNdigits = 1;
+    ffStrbufInitStatic(&options->tempColorGreen, FF_COLOR_FG_GREEN);
+    ffStrbufInitStatic(&options->tempColorYellow, FF_COLOR_FG_LIGHT_YELLOW);
+    ffStrbufInitStatic(&options->tempColorRed, FF_COLOR_FG_LIGHT_RED);
+
     ffStrbufInitStatic(&options->barCharElapsed, "■");
     ffStrbufInitStatic(&options->barCharTotal, "-");
     options->barWidth = 10;
@@ -430,20 +475,38 @@ void ffOptionsGenerateDisplayJsonConfig(FFOptionsDisplay* options, yyjson_mut_do
             yyjson_mut_obj_add_val(doc, obj, "size", size);
     }
 
-    if (options->temperatureUnit != defaultOptions.temperatureUnit)
     {
-        switch (options->temperatureUnit)
+        yyjson_mut_val* temperature = yyjson_mut_obj(doc);
+        if (options->temperatureUnit != defaultOptions.temperatureUnit)
         {
-            case FF_TEMPERATURE_UNIT_CELSIUS:
-                yyjson_mut_obj_add_str(doc, obj, "temperatureUnit", "C");
-                break;
-            case FF_TEMPERATURE_UNIT_FAHRENHEIT:
-                yyjson_mut_obj_add_str(doc, obj, "temperatureUnit", "F");
-                break;
-            case FF_TEMPERATURE_UNIT_KELVIN:
-                yyjson_mut_obj_add_str(doc, obj, "temperatureUnit", "K");
-                break;
+            switch (options->temperatureUnit)
+            {
+                case FF_TEMPERATURE_UNIT_CELSIUS:
+                    yyjson_mut_obj_add_str(doc, obj, "unit", "C");
+                    break;
+                case FF_TEMPERATURE_UNIT_FAHRENHEIT:
+                    yyjson_mut_obj_add_str(doc, obj, "unit", "F");
+                    break;
+                case FF_TEMPERATURE_UNIT_KELVIN:
+                    yyjson_mut_obj_add_str(doc, obj, "unit", "K");
+                    break;
+            }
         }
+        if (options->tempNdigits != defaultOptions.tempNdigits)
+            yyjson_mut_obj_add_uint(doc, temperature, "ndigits", options->tempNdigits);
+        {
+            yyjson_mut_val* color = yyjson_mut_obj(doc);
+            if (!ffStrbufEqual(&options->tempColorGreen, &defaultOptions.tempColorGreen))
+                yyjson_mut_obj_add_strbuf(doc, color, "green", &options->tempColorGreen);
+            if (!ffStrbufEqual(&options->tempColorYellow, &defaultOptions.tempColorYellow))
+                yyjson_mut_obj_add_strbuf(doc, color, "yellow", &options->tempColorYellow);
+            if (!ffStrbufEqual(&options->tempColorRed, &defaultOptions.tempColorRed))
+                yyjson_mut_obj_add_strbuf(doc, color, "red", &options->tempColorRed);
+            if (yyjson_mut_obj_size(color) > 0)
+                yyjson_mut_obj_add_val(doc, temperature, "color", color);
+        }
+        if (yyjson_mut_obj_size(temperature) > 0)
+            yyjson_mut_obj_add_val(doc, obj, "temp", temperature);
     }
 
     {
@@ -452,6 +515,17 @@ void ffOptionsGenerateDisplayJsonConfig(FFOptionsDisplay* options, yyjson_mut_do
             yyjson_mut_obj_add_uint(doc, percent, "type", options->percentType);
         if (options->percentNdigits != defaultOptions.percentNdigits)
             yyjson_mut_obj_add_uint(doc, percent, "ndigits", options->percentNdigits);
+        {
+            yyjson_mut_val* color = yyjson_mut_obj(doc);
+            if (!ffStrbufEqual(&options->percentColorGreen, &defaultOptions.percentColorGreen))
+                yyjson_mut_obj_add_strbuf(doc, color, "green", &options->percentColorGreen);
+            if (!ffStrbufEqual(&options->percentColorYellow, &defaultOptions.percentColorYellow))
+                yyjson_mut_obj_add_strbuf(doc, color, "yellow", &options->percentColorYellow);
+            if (!ffStrbufEqual(&options->percentColorRed, &defaultOptions.percentColorRed))
+                yyjson_mut_obj_add_strbuf(doc, color, "red", &options->percentColorRed);
+            if (yyjson_mut_obj_size(color) > 0)
+                yyjson_mut_obj_add_val(doc, percent, "color", color);
+        }
         if (yyjson_mut_obj_size(percent) > 0)
             yyjson_mut_obj_add_val(doc, obj, "percent", percent);
     }

src/options/display.h

@@ -35,6 +35,10 @@ typedef struct FFOptionsDisplay
     uint8_t sizeNdigits;
     uint8_t sizeMaxPrefix;
     FFTemperatureUnit temperatureUnit;
+    uint8_t tempNdigits;
+    FFstrbuf tempColorGreen;
+    FFstrbuf tempColorYellow;
+    FFstrbuf tempColorRed;
     FFstrbuf barCharElapsed;
     FFstrbuf barCharTotal;
     uint8_t barWidth;