Address some feedbacks

TerminalFont: add conhost detection
TerminalShell: detect cmd ( Windows )
2026-09-12 18:32:10 +02:00 · 2022-10-09 23:23:46 +08:00 · 2022-10-09 22:29:00 +08:00 · 2022-10-09 22:29:00 +08:00 · 2022-10-09 21:12:27 +08:00 · 2022-10-09 21:10:43 +08:00
209 changed files with 8540 additions and 2885 deletions
@@ -1 +1 @@
-custom: paypal.me/linusdierheimer
+github: LinusDierheimer
@@ -10,6 +10,7 @@ jobs:
    runs-on: ubuntu-latest
    permissions:
      security-events: write
+      contents: read
    outputs:
      ffversion: ${{ steps.ffversion.outputs.ffversion }}
    steps:
@@ -17,7 +18,7 @@ jobs:
        uses: actions/checkout@v3

      - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev
+        run: sudo apt-get update && sudo apt-get install -y libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev rpm librpm-dev libzstd-dev libegl-dev libglx-dev libosmesa6-dev ocl-icd-opencl-dev libcjson-dev

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v2
@@ -28,7 +29,7 @@ jobs:
        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .

      - name: build project
-        run: cmake --build . -j$(nproc) --target package
+        run: cmake --build . --target package

      - name: perform CodeQL analysis
        uses: github/codeql-action/analyze@v2
@@ -57,12 +58,13 @@ jobs:
    runs-on: macos-latest
    permissions:
      security-events: write
+      contents: read
    steps:
      - name: checkout repository
        uses: actions/checkout@v3

      - name: install required packages
-        run: brew install vulkan-loader
+        run: brew install vulkan-loader molten-vk

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v2
@@ -73,7 +75,7 @@ jobs:
        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .

      - name: build project
-        run: cmake --build . -j$(sysctl -n hw.logicalcpu) --target package
+        run: cmake --build . --target package

      - name: perform CodeQL analysis
        uses: github/codeql-action/analyze@v2
@@ -93,13 +95,42 @@ jobs:
          name: fastfetch-macos
          path: ./fastfetch-*.*

+  bsd:
+    name: BSD
+    runs-on: macos-12
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v3
+
+      - name: run VM
+        uses: vmactions/freebsd-vm@v0
+        with:
+          prepare: |
+            pkg install -y cmake git pkgconf pciutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 glib dconf dbus sqlite3-tcl xfce4-conf ImageMagick6 ImageMagick7 chafa egl libosmesa opencl ocl-icd
+          run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+            cmake --build . --target package
+            ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
+            ./flashfetch
+            ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-bsd
+          path: ./fastfetch-*.*
+
  release:
-    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master' && github.repository == 'LinusDierheimer/fastfetch'
    name: Release
    runs-on: ubuntu-latest
    needs:
      - linux
      - macos
+      - bsd
    permissions:
      contents: write
    steps:
@@ -119,4 +150,4 @@ jobs:
          tag: ${{ needs.linux.outputs.ffversion }}
          commit: ${{ github.sha }}
          artifactErrorsFailBuild: true
-          artifacts: fastfetch-linux/*,fastfetch-macos/*
+          artifacts: fastfetch-linux/*,fastfetch-macos/*,fastfetch-bsd/*
@@ -11,12 +11,16 @@ project(fastfetch
 # Target Platform #
 ###################

-if(APPLE OR ANDROID)
-    set(LINUX FALSE CACHE BOOL "..." FORCE) # Linux true means we have full linux userland, not just the kernel
-elseif(UNIX)
-    set(LINUX TRUE CACHE BOOL "..." FORCE)
-else()
-    message(FATAL_ERROR "Unsupported platform")
+if("${CMAKE_SYSTEM_NAME}" MATCHES ".*[Ll]inux.*")
+    set(LINUX TRUE CACHE BOOL "..." FORCE) # LINUX means GNU/Linux, not just the kernel
+elseif("${CMAKE_SYSTEM_NAME}" MATCHES ".*[Bb][Ss][Dd].*")
+    set(BSD TRUE CACHE BOOL "..." FORCE)
+elseif(NOT APPLE AND NOT ANDROID AND NOT MSYS)
+    message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}")
+endif()
+
+if(MSYS)
+    enable_language(CXX)
 endif()

 #####################
@@ -25,27 +29,29 @@ endif()

 include(CMakeDependentOption)

-cmake_dependent_option(ENABLE_LIBPCI "Enable libpci" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE" OFF)
-cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_XCB "Enable xcb" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_X11 "Enable x11" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_LIBPCI "Enable libpci" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE OR BSD OR MSYS" OFF)
+cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_XCB "Enable xcb" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_X11 "Enable x11" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR BSD" OFF)
 cmake_dependent_option(ENABLE_RPM "Enable rpm" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR BSD" OFF)
 cmake_dependent_option(ENABLE_CHAFA "Enable chafa" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
 cmake_dependent_option(ENABLE_ZLIB "Enable zlib" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
-cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX OR BSD" OFF)
+cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR BSD OR MSYS" OFF)
+cmake_dependent_option(ENABLE_LIBCJSON "Enable libcjson" ON "LINUX OR MSYS" OFF)
+cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)

 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
@@ -69,14 +75,29 @@ if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release)
 endif()

+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wconversion")
-if(APPLE AND DEFINED ENV{HOMEBREW_PREFIX})
-    # Used for dlopen finding dylibs installed by homebrew, reversed for future usage
-    # `/opt/homebrew/lib` is not on dlopen search path by default
-    set(CMAKE_EXE_LINKER_FLAGS "-Wl,-rpath,$ENV{HOMEBREW_PREFIX}/lib")
+
+if(MSYS)
+    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wconversion -fno-exceptions -fno-rtti")
 endif()

+# 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")
+endif()
+
+set(FASTFETCH_FLAGS_DEBUG "-fno-omit-frame-pointer")
+if(NOT MSYS)
+    set(FASTFETCH_FLAGS_DEBUG "${FASTFETCH_FLAGS_DEBUG} -fsanitize=address -fsanitize=undefined")
+endif()
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${FASTFETCH_FLAGS_DEBUG}")
+set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} ${FASTFETCH_FLAGS_DEBUG} -rdynamic")
+
 include(CheckIPOSupported)
 check_ipo_supported(RESULT IPO_SUPPORTED)
 if(IPO_SUPPORTED)
@@ -113,6 +134,19 @@ if(NOT TARGET_DIR_HOME)
    endif()
 endif()

+if(NOT TARGET_DIR_ETC)
+    set(TARGET_DIR_ETC "${TARGET_DIR_ROOT}/etc")
+endif()
+
+#https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.html
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set(CMAKE_INSTALL_PREFIX "${TARGET_DIR_USR}" CACHE PATH "..." FORCE)
+endif()
+
+if(NOT CMAKE_INSTALL_SYSCONFDIR)
+    set(CMAKE_INSTALL_SYSCONFDIR "${TARGET_DIR_ETC}" CACHE PATH "..." FORCE)
+endif()
+
 #################
 # Tweak version #
 #################
@@ -168,7 +202,6 @@ set(LIBFASTFETCH_SRC
    src/common/caching.c
    src/common/properties.c
    src/common/font.c
-    src/common/processing.c
    src/common/format.c
    src/common/parsing.c
    src/common/settings.c
@@ -179,26 +212,27 @@ set(LIBFASTFETCH_SRC
    src/logo/image/image.c
    src/logo/image/im7.c
    src/logo/image/im6.c
-    src/detection/qt.c
-    src/detection/gtk.c
-    src/detection/terminalShell.c
    src/detection/vulkan.c
-    src/detection/media.c
    src/detection/datetime.c
-    src/detection/temps.c
    src/detection/title.c
    src/detection/host/host.c
    src/detection/os/os.c
    src/detection/cpu/cpu.c
+    src/detection/cpuUsage/cpuUsage.c
    src/detection/gpu/gpu.c
    src/detection/memory/memory.c
+    src/detection/font/font.c
    src/detection/displayserver/displayserver.c
+    src/detection/terminalfont/terminalfont.c
+    src/detection/media/media.c
    src/modules/break.c
    src/modules/custom.c
    src/modules/title.c
    src/modules/separator.c
    src/modules/os.c
    src/modules/host.c
+    src/modules/bios.c
+    src/modules/board.c
    src/modules/kernel.c
    src/modules/uptime.c
    src/modules/processes.c
@@ -220,10 +254,12 @@ set(LIBFASTFETCH_SRC
    src/modules/memory.c
    src/modules/disk.c
    src/modules/battery.c
+    src/modules/poweradapter.c
    src/modules/locale.c
    src/modules/vulkan.c
    src/modules/localip.c
    src/modules/publicip.c
+    src/modules/weather.c
    src/modules/player.c
    src/modules/song.c
    src/modules/datetime.c
@@ -232,38 +268,150 @@ set(LIBFASTFETCH_SRC
    src/modules/colors.c
    src/modules/opengl.c
    src/modules/opencl.c
+    src/modules/users.c
 )

-if(APPLE)
+if(LINUX OR APPLE OR ANDROID OR BSD)
    list(APPEND LIBFASTFETCH_SRC
-        src/detection/host/host_apple.c
-        src/detection/os/os_apple.c
-        src/detection/cpu/cpu_apple.c
-        src/detection/gpu/gpu_apple.c
-        src/detection/memory/memory_apple.c
-        src/detection/displayserver/displayserver_apple.c
+        src/detection/users/users_linux.c
+        src/common/processing_linux.c
+        src/detection/disk/disk.c
+        src/detection/terminalshell/terminalshell_linux.c
+        src/detection/packages/packages_linux.c
+        src/detection/kernel/kernel_linux.c
+        src/detection/localip/localip_linux.c
    )
-elseif(ANDROID)
+endif()
+
+if(BSD OR APPLE)
+    list(APPEND LIBFASTFETCH_SRC
+        src/common/sysctl.c
+    )
+endif()
+
+if(LINUX OR ANDROID)
    list(APPEND LIBFASTFETCH_SRC
-        src/detection/host/host_android.c
-        src/detection/os/os_android.c
        src/detection/cpu/cpu_linux.c
-        src/detection/gpu/gpu_android.c
        src/detection/memory/memory_linux.c
-        src/detection/displayserver/displayserver_android.c
    )
-else()
+endif()
+
+if(LINUX OR ANDROID OR BSD)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/cpuUsage/cpuUsage_linux.c
+        src/detection/disk/disk_linux.c
+        src/detection/temps/temps_linux.c
+        src/detection/opengl/opengl_linux.c
+        src/detection/processes/processes_linux.c
+
+        src/detection/poweradapter/poweradapter_nosupport.c
+    )
+endif()
+
+if(LINUX OR BSD)
    list(APPEND LIBFASTFETCH_SRC
        src/detection/host/host_linux.c
+        src/detection/bios/bios_linux.c
+        src/detection/board/board_linux.c
        src/detection/os/os_linux.c
-        src/detection/cpu/cpu_linux.c
        src/detection/gpu/gpu_linux.c
-        src/detection/memory/memory_linux.c
+        src/detection/battery/battery_linux.c
        src/detection/displayserver/linux/displayserver_linux.c
        src/detection/displayserver/linux/wayland.c
        src/detection/displayserver/linux/xcb.c
        src/detection/displayserver/linux/xlib.c
        src/detection/displayserver/linux/wmde.c
+        src/detection/terminalfont/terminalfont_linux.c
+        src/detection/media/media_linux.c
+        src/detection/wmtheme/wmtheme_linux.c
+        src/detection/font/font_linux.c
+        src/detection/qt.c
+        src/detection/gtk.c
+    )
+endif()
+
+if(MSYS)
+    list(APPEND LIBFASTFETCH_SRC
+        src/common/processing_linux.c
+        src/detection/host/host_windows.cpp
+        src/detection/bios/bios_windows.cpp
+        src/detection/board/board_windows.cpp
+        src/detection/cpu/cpu_windows.cpp
+        src/detection/gpu/gpu_windows.cpp
+        src/detection/battery/battery_windows.cpp
+        src/detection/displayserver/displayserver_windows.c
+        src/detection/wmtheme/wmtheme_windows.c
+        src/detection/opengl/opengl_windows.c
+        src/detection/users/users_windows.cpp
+        src/detection/os/os_windows.cpp
+        src/detection/processes/processes_windows.cpp
+        src/detection/disk/disk_windows.c
+        src/detection/cpuUsage/cpuUsage_windows.c
+        src/detection/cpuUsage/cpuUsage_nowait_windows.cpp
+        src/detection/memory/memory_windows.cpp
+        src/detection/font/font_windows.cpp
+        src/detection/terminalshell/terminalshell_linux.c
+        src/detection/terminalshell/terminalshell_windows.cpp
+        src/detection/terminalfont/terminalfont_linux.c
+        src/detection/packages/packages_linux.c
+        src/detection/packages/packages_windows.c
+        src/detection/kernel/kernel_windows.cpp
+        src/detection/localip/localip_windows.c
+        src/util/windows/wmi.cpp
+
+        src/detection/poweradapter/poweradapter_nosupport.c
+        src/detection/media/media_nosupport.c
+    )
+endif()
+
+if(APPLE)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/cpuUsage/cpuUsage_apple.c
+        src/util/apple/cf_helpers.c
+        src/util/apple/osascript.m
+        src/detection/host/host_apple.c
+        src/detection/os/os_apple.m
+        src/detection/cpu/cpu_apple.c
+        src/detection/gpu/gpu_apple.c
+        src/detection/battery/battery_apple.c
+        src/detection/poweradapter/poweradapter_apple.c
+        src/detection/memory/memory_apple.c
+        src/detection/displayserver/displayserver_apple.c
+        src/detection/terminalfont/terminalfont_apple.m
+        src/detection/media/media_apple.m
+        src/detection/disk/disk_apple.m
+        src/detection/wmtheme/wmtheme_apple.m
+        src/detection/temps/temps_apple.c
+        src/detection/font/font_apple.m
+        src/detection/opengl/opengl_apple.c
+        src/detection/processes/processes_apple.c
+
+        src/detection/bios/bios_nosupport.c
+        src/detection/board/board_nosupport.c
+    )
+endif()
+
+if(BSD)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/cpu/cpu_bsd.c
+        src/detection/memory/memory_bsd.c
+    )
+endif()
+
+if(ANDROID)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/host/host_android.c
+        src/detection/os/os_android.c
+        src/detection/terminalfont/terminalfont_android.c
+
+        src/detection/bios/bios_nosupport.c
+        src/detection/board/board_nosupport.c
+        src/detection/displayserver/displayserver_nosupport.c
+        src/detection/battery/battery_nosupport.c
+        src/detection/gpu/gpu_nosupport.c
+        src/detection/font/font_nosupport.c
+        src/detection/media/media_nosupport.c
+        src/detection/wmtheme/wmtheme_nosupport.c
    )
 endif()

@@ -271,28 +419,40 @@ add_library(libfastfetch OBJECT
    ${LIBFASTFETCH_SRC}
 )

+target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE)
+
 CHECK_INCLUDE_FILE("sys/sysinfo.h" HAVE_SYSINFO_H)
 if(HAVE_SYSINFO_H)
    # needs to be public, because changes fastfech.h ABI
    target_compile_definitions(libfastfetch PUBLIC FF_HAVE_SYSINFO_H)
 endif()

+CHECK_INCLUDE_FILE("utmpx.h" HAVE_UTMPX_H)
+if(HAVE_UTMPX_H)
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_UTMPX_H)
+endif()
+
 function(ff_lib_enable VARNAME)
    if(NOT ENABLE_${VARNAME})
        return()
    endif()

-    foreach(LIBNAME ${ARGN})
-        pkg_check_modules(${VARNAME} ${LIBNAME})
-        if(${VARNAME}_FOUND)
-            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_${VARNAME}=1)
-            target_include_directories(libfastfetch PRIVATE ${${VARNAME}_INCLUDE_DIRS})
-            target_link_directories(libfastfetch PRIVATE ${${VARNAME}_LIBRARY_DIRS})
-            return()
+    pkg_search_module(${VARNAME} ${ARGN})
+    if(NOT ${VARNAME}_FOUND)
+        message(WARNING "Package ${ARGV1} not found, building without support.")
+        return()
+    endif()
+
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_${VARNAME}=1)
+    target_include_directories(libfastfetch PRIVATE ${${VARNAME}_INCLUDE_DIRS})
+    target_link_directories(libfastfetch PRIVATE ${${VARNAME}_LIBRARY_DIRS})
+
+    foreach(FLAG ${${VARNAME}_CFLAGS_OTHER})
+        if(FLAG MATCHES "-D.*")
+            string(SUBSTRING ${FLAG} 2 -1 FLAG)
+            target_compile_definitions(libfastfetch PRIVATE ${FLAG})
        endif()
    endforeach()
-
-    message(WARNING "Package ${ARGV1} not found, building without support.")
 endfunction()

 ff_lib_enable(LIBPCI libpci)
@@ -308,14 +468,16 @@ ff_lib_enable(DBUS dbus-1)
 ff_lib_enable(XFCONF libxfconf-0)
 ff_lib_enable(SQLITE3 sqlite3)
 ff_lib_enable(RPM rpm)
-ff_lib_enable(IMAGEMAGICK7 MagickCore-7.Q16HDRI MagickCore-7.Q16 /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16HDRI.pc /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16.pc)
-ff_lib_enable(IMAGEMAGICK6 MagickCore-6.Q16HDRI MagickCore-6.Q16 /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16HDRI.pc /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16.pc)
+ff_lib_enable(IMAGEMAGICK7 MagickCore-7.Q16HDRI MagickCore-7.Q16 MagickCore-7 /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16HDRI.pc /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16.pc /usr/lib/imagemagick7/pkgconfig/MagickCore-7.pc)
+ff_lib_enable(IMAGEMAGICK6 MagickCore-6.Q16HDRI MagickCore-6.Q16 MagickCore-6 /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16HDRI.pc /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16.pc /usr/lib/imagemagick6/pkgconfig/MagickCore-6.pc)
 ff_lib_enable(ZLIB zlib)
 ff_lib_enable(CHAFA chafa>=1.10)
 ff_lib_enable(EGL egl)
 ff_lib_enable(GLX glx)
 ff_lib_enable(OSMESA osmesa)
 ff_lib_enable(OPENCL OpenCL)
+ff_lib_enable(LIBCJSON libcjson)
+ff_lib_enable(FREETYPE freetype2)

 if(APPLE)
    target_link_libraries(libfastfetch
@@ -324,6 +486,18 @@ if(APPLE)
        PRIVATE "-framework CoreGraphics"
        PRIVATE "-framework OpenGL"
        PRIVATE "-framework OpenCL"
+        PRIVATE "-framework Cocoa"
+        PRIVATE "-weak_framework MediaRemote -F /System/Library/PrivateFrameworks"
+    )
+elseif(MSYS)
+    target_link_libraries(libfastfetch
+        PRIVATE "wbemuuid"
+        PRIVATE "ole32"
+        PRIVATE "oleaut32"
+        PRIVATE "dwmapi"
+        PRIVATE "opengl32"
+        PRIVATE "gdi32"
+        PRIVATE "iphlpapi"
    )
 endif()

@@ -367,23 +541,22 @@ if (BUILD_TESTS)
        PRIVATE libfastfetch
    )

+    add_executable(fastfetch-test-list
+        tests/list.c
+    )
+    target_link_libraries(fastfetch-test-list
+        PRIVATE libfastfetch
+    )
+
    enable_testing()
    add_test(NAME test-strbuf COMMAND fastfetch-test-strbuf)
+    add_test(NAME test-list COMMAND fastfetch-test-list)
 endif()

 ##################
 # install target #
 ##################

-#https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.html
-if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
-    set(CMAKE_INSTALL_PREFIX "${TARGET_DIR_USR}" CACHE PATH "..." FORCE)
-endif()
-
-if(NOT CMAKE_INSTALL_SYSCONFDIR)
-    set(CMAKE_INSTALL_SYSCONFDIR "${TARGET_DIR_ROOT}/etc" CACHE PATH "..." FORCE)
-endif()
-
 include(GNUInstallDirs)

 install(
@@ -431,6 +604,8 @@ elseif(APPLE)
    set(CPACK_GENERATOR "${CPACK_GENERATOR};DragNDrop")

    set(CPACK_DMG_DISABLE_APPLICATIONS_SYMLINK TRUE)
+elseif(BSD)
+    set(CPACK_GENERATOR "${CPACK_GENERATOR};FreeBSD")
 endif()

 set(CPACK_SET_DESTDIR ON)
@@ -11,8 +11,6 @@ Here i just add things that are easy to forget.
  - `libffdetect`: contains all the detection stuff. To be used by anything that needs system information
  - `libffprint`: contains the printing functions, logos, format etc
  - `fastfetch` and `flashfetch`: Executables, that initialize the config of libffprint. Fist one at runtime, second one at compile time
- [ ] Better OS output for all possible combinations of /etc/os-release variables.
- [ ] Find wayland compositor by looking at \${XDG_RUNTIME_DIR}/${WAYLAND_DISPLAY:-wayland-0}
 - [ ] Make LocalIP module more configurable
 - [ ] Automatic migrate old config files to newer versions
 - [ ] ZSH completions
@@ -1,6 +1,6 @@
-# <center> Fastfetch </center>
+# Fastfetch

-Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying them in a pretty way. It is written in pure c, with performance and customizability in mind. Currently Linux, Android and MacOS are supported.
+Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying them in a pretty way. It is written in pure c, with performance and customizability in mind. Currently Linux, Android, BSD, MacOS and Windows on [MSYS2](https://www.msys2.org/) are supported.

 <img src="screenshots/example1.png" width="49%" align="left" />
 <img src="https://upload.wikimedia.org/wikipedia/commons/2/24/Transparent_Square_Tiles_Texture.png" width="49%" height="16px" align="left" />
@@ -42,35 +42,37 @@ The following libraries are used if present at runtime:
    [`libOSMesa`](https://docs.mesa3d.org/osmesa.html): At least one of them is needed by the OpenGL module for gl context creation.
 * [`libOpenCL`](https://www.khronos.org/opencl/): OpenCL module
 * [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
-* [`libsqlite3`](https://www.sqlite.org/index.html): Needed for rpm package count.
+* [`libsqlite3`](https://www.sqlite.org/index.html): Needed for pkg & rpm package count.
 * [`librpm`](http://rpm.org/): Slower fallback for rpm package count. Needed on openSUSE.
+* [`libcJSON`](https://github.com/DaveGamble/cJSON): Needed for Windows Terminal font ( Windows, WSL ).
+* [`freetype`](https://www.freetype.org/): Needed for Termux font detection ( Android ).

 ## Support status
 All categories not listed here should work without needing a specific implementation.

 ##### Available Modules
 ```
-Title, Separator, OS, Host, Kernel, Uptime, Processes, Packages, Shell, Resolution, DE, WM, WMTheme, Theme, Icons, Font, Cursor, Terminal, Terminal Font, CPU, CPUUsage, GPU, Memory, Swap, Disk, Battery, Player, Media, Vulkan, OpenGL, OpenCL, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
+Title, Separator, OS, Host, Bios, Board, Kernel, Uptime, Processes, Packages, Shell, Resolution, DE, WM, WMTheme, Theme, Icons, Font, Cursor, Terminal, Terminal Font, CPU, CPUUsage, GPU, Memory, Swap, Disk, Battery, Power Adapter, Player, Media, Vulkan, OpenGL, OpenCL, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
 ```

 ##### Logos
 ```
-AlmaLinux, Alpine, Android, Arch, Arco, Artix, Bedrock, CachyOS, CentOS, Debian, Devuan, Deepin, Endeavour, Fedora, Garuda, Gentoo, KDE Neon, KISS, Kubuntu, LangitKetujuh, Linux, MacOS, Manjaro, Mint, MSYS2, NixOS, OpenSUSE, OpenSUSE Tumbleweed, OpenSUSE LEAP, Pop!_OS, RebornOS, RedstarOS, Rocky, Rosa, Slackware, Ubuntu, Void, Zorin
+AlmaLinux, Alpine, Android, Arch, Arco, Artix, Bedrock, CachyOS, CentOS, Crystal, Debian, Devuan, Deepin, Endeavour, Fedora, FreeBSD, Garuda, Gentoo, KDE Neon, KISS, Kubuntu, LangitKetujuh, Linux, MacOS, Manjaro, Mint, MSYS2, NixOS, OpenSUSE, OpenSUSE Tumbleweed, OpenSUSE LEAP, Pop!_OS, RebornOS, RedstarOS, Rocky, Rosa, Slackware, Ubuntu, Void, Windows 11, Windows 8, Windows, Zorin
 ```
 * Most of the logos have a small variant. Access it by appending _small to the logo name.
 * Some logos have an old variant. Access it by appending _old to the logo name.
-* Unknown/unsupported logos will be replaced with a generic linux logo when running fastfetch.
+* To disable the logo, use `--logo none`.
 * Get a list of all available logos with `fastfetch --print-logos`.
-* Printing images as logo is supported using Sixel or Kitty graphics protocol.
+* Printing images as logo is supported using Sixel / Kitty graphics protocol or chafas image to text conversion.

 ##### Package managers
 ```
-Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap, apk, brew
+Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap, apk, pkg, brew, MacPorts, scoop
 ```

 ##### WM themes
 ```
-KWin, Mutter, Muffin, Marco, XFWM, Openbox (LXDE, LXQT & without DE)
+KWin, Mutter, Muffin, Marco, XFWM, Openbox (LXDE, LXQT & without DE), Quartz Compositor (macOS), DWM (Windows)
 ```

 ##### DE versions
@@ -80,7 +82,7 @@ KDE Plasma, Gnome, Cinnamon, Mate, XFCE4, LXQt

 ##### Terminal fonts
 ```
-konsole, gnome-terminal-server, tilix, xfce4-terminal, alacritty, lxterminal, TTY
+Konsole, Gnome Terminal, Tilix, XFCE4 Terminal, Alacritty, LXTerminal, iTerm2, Apple Terminal, TTY, Windows Terminal, Termux, mintty
 ```

 ## Building
@@ -95,6 +97,12 @@ cmake --build . --target fastfetch --target flashfetch

 If pkg-config fails to find the headers for a library listed in [dependencies](#dependencies), fastfetch will simply build without support for that specific feature. This means, it won't look for it at runtime and just act like it isn't available.

+### Building on Windows
+
+Currently [MSYS2](https://www.msys2.org/) is required to build fastfetch. Running fastfetch requires msys2 runtime library (`msys-2.0.dll`) but not full MSYS2 environment.
+
+Full native Windows executable is planned.
+
 ## Packaging

 ### Repositories
@@ -30,6 +30,7 @@ __fastfetch_complete_help()
        "swap-format"
        "disk-format"
        "battery-format"
+        "poweradapter-format"
        "locale-format"
        "local-ip-format"
        "public-ip-format"
@@ -176,9 +177,13 @@ __fastfetch_completion()
        "--allow-slow-operations"
        "--disable-linewrap"
        "--hide-cursor"
+        "--cpu-temp"
+        "--gpu-temp"
+        "--battery-temp"
        "--localip-show-ipv4"
        "--localip-show-ipv6"
        "--localip-show-loop"
+        "--localip-name-prefix"
        "--escape-bedrock"
        "--pipe"
        "--title-fqdn"
@@ -211,7 +216,10 @@ __fastfetch_completion()
        "--set"
        "--set-keyless"
        "--player-name"
+        "--public-ip-url"
        "--public-ip-timeout"
+        "--weather-output-format"
+        "--weather-timeout"
        "--os-key"
        "--os-format"
        "--os-error"
@@ -284,6 +292,9 @@ __fastfetch_completion()
        "--battery-key"
        "--battery-format"
        "--battery-error"
+        "--poweradapter-key"
+        "--poweradapter-format"
+        "--poweradapter-error"
        "--locale-key"
        "--locale-format"
        "--locale-error"
@@ -293,6 +304,9 @@ __fastfetch_completion()
        "--public-ip-key"
        "--public-ip-format"
        "--public-ip-error"
+        "--weather-key"
+        "--weather-format"
+        "--weather-error"
        "--player-key"
        "--player-format"
        "--player-error"
@@ -317,6 +331,9 @@ __fastfetch_completion()
        "--opencl-key"
        "--opencl-format"
        "--opencl-error"
+        "--users-key"
+        "--users-format"
+        "--users-error"
    )

    local FF_OPTIONS_PATH=(
@@ -1 +1 @@
--structure Title:Separator:OS:Host:Kernel:Uptime:Processes:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Swap:Disk:Battery:Player:Song:PublicIP:LocalIP:DateTime:Locale:Vulkan:OpenGL:OpenCL:Break:Colors
+--structure Title:Separator:OS:Host:Kernel:Uptime:Processes:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Swap:Disk:Battery:PowerAdapter:Player:Song:PublicIP:LocalIP:DateTime:Locale:Vulkan:OpenGL:OpenCL:Users:Weather:Break:Colors
@@ -8,5 +8,4 @@
 --icons-key I
 --icons-format {5}
 --font-key F
--font-format {21}
 --cursor-key C
@@ -1,4 +1,4 @@
 --structure Host:Resolution:CPU:GPU:Memory:Disk:Battery
--memory-format "{?2}{2}MiB{?}"
--disk-format "{?2}{2}GB{?}"
+--memory-format "{?2}{2}{?}"
+--disk-format "{?2}{2}{?}"
 --battery-format "{?1}{1} {?}{?2}{2} {?}{?3}({3}){?}"
@@ -5,6 +5,6 @@
 --de-format "{2} {3}"
 --theme-format "{?1}{1}{?3} {3}{?} [Plasma], {?}{7}"
 --terminal-font-format "{/2}{-}{/}{2}{?3} {3}{?}"
--memory-format "{/1}{-}{/}{/2}{-}{/}{}MiB / {}MiB"
+--memory-format "{/1}{-}{/}{/2}{-}{/}{} / {}"
 --gpu-key "GPU"
 --resolution-key "Resolution"
@@ -11,16 +11,17 @@
 --wm-theme-format Name: {}
 --theme-format Plasma: {}; Plasma colors: {}; Plasma colors pretty: {}; GTK2: {}; GTK3: {}; GTK4: {}; GTK: {}
 --icons-format Plasma: {}; GTK2: {}; GTK3: {}; GTK4: {}; GTK: {}
--font-format Plasma raw: {}; Plasma name: {}; Plasma size: {}; Plasma styles: {}; Plasma pretty: {}; GTK2 raw: {}; GTK2 name: {}; GTK2 size: {}; GTK2 styles: {}; GTK2 pretty: {}; GTK3 raw: {}; GTK3 name: {}; GTK3 size: {}; GTK3 styles: {}; GTK3 pretty: {}; GTK4 raw: {}; GTK4 name: {}; GTK4 size: {}; GTK4 styles: {}; GTK4 pretty: {}; GTK: {}
+--font-format Font1: {}; Font2: {}; Font3: {}; Font4: {}
 --cursor-format Theme: {}; Size: {}
 --terminal-format Process: {}; Path: {}; Exe: {}
--terminal-font-format Raw: {}; Name: {}; Size: {}; Styles: {}; Pretty: {}
+--terminal-font-format Pretty: {}; Name: {}; Size: {}; Styles: {}
 --cpu-format Name: {}, Vendor: {}, CoresPhysical: {}, CoresLogical: {}, CoresOnline: {}, FrequencyMin: {}, FrequencyMax: {}, Temperature: {}
 --cpu-usage-format Percentage: {}
--gpu-format Vendor: {}; Name: {}; Driver: {}; Temperature: {}
+--gpu-format Vendor: {}; Name: {}; Driver: {}; Temperature: {}; CoreCount: {}
 --memory-format Used: {}; Total: {}; Percentage: {}
 --disk-format Used: {}; Total: {}; Files: {}; Percentage: {}
 --battery-format Manufactor: {}; Model: {}; Technology: {}; Capacity: {}; Status: {}
+--poweradapter-format Watts: {}; Name: {}; Manufactor: {}; Model: {}; Description: {}
 --player-format Pretty: {}; Name: {}; Bus: {}; Url: {}
 --media-format Pretty: {}; Name: {};  Artist: {}; Album: {}
 --datetime-format year: {}; yearShort: {}; month: {}; monthPretty: {}; monthName: {}; monthNameShort: {}; weekNumber: {}; weekday: {}; weekdayShort: {}; dayInYear: {}; dayInMonth: {}; dayInWeek: {}; hour: {}; hourPretty: {}; hour12: {}; hour12Pretty: {}; minute: {}; minutePretty: {}; second: {}; secondPretty: {}
@@ -1,11 +1,22 @@
 #!/usr/bin/env sh

-# make the script exit if any of the commands fail,
-# making fastfetch not run if the build failed.
 set -e

 mkdir -p build/
 cd build/
-cmake ..
-cmake --build . --target fastfetch -j$(nproc)
+
+if [ -z "${CMAKE_BUILD_TYPE}" ]; then
+    CMAKE_BUILD_TYPE=Release
+fi
+cmake "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}" ..
+
+if [ -z "$OSTYPE" ] || [ "$OSTYPE" = "linux-gnu" ]; then
+    cmake_build_args="-j$(nproc)"
+elif [ "$OSTYPE" = "darwin" ]; then
+    cmake_build_args="-j$(sysctl -n hw.ncpu)"
+else
+    cmake_build_args=""
+fi
+cmake --build . --target fastfetch ${cmake_build_args}
+
 ./fastfetch "$@"
@@ -4,6 +4,7 @@
 #include "common/printing.h"

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

 #define FF_CACHE_VERSION_NAME "cacheversion"
 #define FF_CACHE_VERSION_EXTENSION "ffv"
@@ -11,7 +12,7 @@
 #define FF_CACHE_VALUE_EXTENSION "ffcv"
 #define FF_CACHE_SPLIT_EXTENSION "ffcs"

-#define FF_CACHE_EXTENSION_DATA "ffcd"
+#define FF_CACHE_EXTENSION_V1 "ffc1"

 static void getCacheFilePath(const FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
 {
@@ -98,7 +99,10 @@ static bool printCachedValue(FFinstance* instance, const char* moduleName, const
    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length

    if(content.length == 0)
+    {
+        ffStrbufDestroy(&content);
        return false;
+    }

    uint8_t moduleCounter = 1;

@@ -211,24 +215,113 @@ void ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const
    ffCacheClose(&cache);
 }

-void ffCachingWriteData(const FFinstance* instance, const char* moduleName, size_t dataSize, const void* data)
+typedef struct FFCacheRead
 {
-    FFstrbuf path;
-    ffStrbufInitA(&path, 128);
-    getCacheFilePath(instance, moduleName, FF_CACHE_EXTENSION_DATA, &path);
-    ffWriteFileData(path.chars, dataSize, data);
-    ffStrbufDestroy(&path);
+    FFstrbuf data;
+    uint32_t position;
+} FFCacheRead;
+
+static bool cacheReadStrbuf(FFCacheRead* cacheRead, FFstrbuf* strbuf)
+{
+    if(cacheRead->position >= cacheRead->data.length)
+        return false;
+
+    ffStrbufAppendS(strbuf, cacheRead->data.chars + cacheRead->position);
+    cacheRead->position += strbuf->length + 1; // skip the null byte too
+    return true;
 }

-bool ffCachingReadData(const FFinstance* instance, const char* moduleName, size_t dataSize, void* data)
+static bool cacheReadData(FFCacheRead* cacheRead, size_t dataSize, void* data)
+{
+    if(cacheRead->position + dataSize > cacheRead->data.length)
+        return false;
+
+    memcpy(data, cacheRead->data.chars + cacheRead->position, dataSize);
+    cacheRead->position += (uint32_t) dataSize;
+    return true;
+}
+
+static bool cacheResetStrbuf(FFCache* cache, FFstrbuf* strbuf)
+{
+    FF_UNUSED(cache);
+    ffStrbufClear(strbuf);
+    return true;
+}
+
+static bool cacheResetData(FFCache* cacheRead, size_t dataSize, void* data)
+{
+    FF_UNUSED(cacheRead, dataSize, data);
+    return true;
+}
+
+bool ffCacheRead(const FFinstance* instance, void* obj, const char* cacheName, FFCacheMethodCallback callback)
 {
    if(instance->config.recache)
        return false;

+    FFCacheRead cache;
+    bool result;
+
    FFstrbuf path;
    ffStrbufInitA(&path, 128);
-    getCacheFilePath(instance, moduleName, FF_CACHE_EXTENSION_DATA, &path);
-    ssize_t result = ffReadFileData(path.chars, dataSize, data);
+    getCacheFilePath(instance, cacheName, FF_CACHE_EXTENSION_V1, &path);
+
+    cache.position = 0;
+
+    ffStrbufInitA(&cache.data, 256);
+    result = ffAppendFileBuffer(path.chars, &cache.data);
+
+    if(result)
+        result = callback(obj, &cache, (FFCacheMethodStrbuf) cacheReadStrbuf, (FFCacheMethodData) cacheReadData);
+
+    if(result)
+        result = cache.position == cache.data.length;
+
+    if(!result)
+        callback(obj, NULL, (FFCacheMethodStrbuf) cacheResetStrbuf, (FFCacheMethodData) cacheResetData);
+
+    ffStrbufDestroy(&cache.data);
+    ffStrbufDestroy(&path);
+
+    return result;
+}
+
+typedef struct FFCacheWrite
+{
+    FFstrbuf data;
+} FFCacheWrite;
+
+static bool cacheWriteStrbuf(FFCacheWrite* cacheWrite, FFstrbuf* strbuf)
+{
+    ffStrbufEnsureFree(&cacheWrite->data, strbuf->length);
+    memcpy(cacheWrite->data.chars + cacheWrite->data.length, strbuf->chars, strbuf->length +1); //Copy the nullbyte too
+    cacheWrite->data.length += strbuf->length + 1;
+    return true;
+}
+
+static bool cacheWriteData(FFCacheWrite* cacheWrite, size_t dataSize, const void* data)
+{
+    ffStrbufEnsureFree(&cacheWrite->data, (uint32_t) dataSize);
+    memcpy(cacheWrite->data.chars + cacheWrite->data.length, data, dataSize);
+    cacheWrite->data.length += (uint32_t) dataSize;
+    return true;
+}
+
+void ffCacheWrite(const FFinstance* instance, void* obj, const char* cacheName, FFCacheMethodCallback callback)
+{
+    if(!instance->config.cacheSave)
+        return;
+
+    FFCacheWrite cache;
+
+    FFstrbuf path;
+    ffStrbufInitA(&path, 128);
+    getCacheFilePath(instance, cacheName, FF_CACHE_EXTENSION_V1, &path);
+
+    ffStrbufInitA(&cache.data, 256);
+    callback(obj, &cache, (FFCacheMethodStrbuf) cacheWriteStrbuf, (FFCacheMethodData) cacheWriteData);
+    ffWriteFileBuffer(path.chars, &cache.data);
+
+    ffStrbufDestroy(&cache.data);
    ffStrbufDestroy(&path);
-    return result > 0 && (size_t) result == dataSize;
 }
@@ -21,7 +21,13 @@ bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFModu
 void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFcache* cache, const FFstrbuf* value, uint32_t numArgs, const FFformatarg* arguments);
 void ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, const FFstrbuf* value, uint32_t numArgs, const FFformatarg* arguments);

-void ffCachingWriteData(const FFinstance* instance, const char* moduleName, size_t dataSize, const void* data);
-bool ffCachingReadData(const FFinstance* instance, const char* moduleName, size_t dataSize, void* data);
+typedef void FFCache;
+
+typedef bool(*FFCacheMethodStrbuf)(FFCache* cache, FFstrbuf* strbuf);
+typedef bool(*FFCacheMethodData)(FFCache* cache, size_t dataSize, void* data);
+typedef bool(*FFCacheMethodCallback)(void* data, FFCache* cache, FFCacheMethodStrbuf strbufMethod, FFCacheMethodData dataMethod);
+
+bool ffCacheRead(const FFinstance* instance, void* obj, const char* cacheName, FFCacheMethodCallback callback);
+void ffCacheWrite(const FFinstance* instance, void* obj, const char* cacheName, FFCacheMethodCallback callback);

 #endif
@@ -204,6 +204,23 @@ void ffFontInitCopy(FFfont* font, const char* name)
    ffFontInitValues(font, name, NULL);
 }

+void ffFontInitWithSpace(FFfont* font, const char* rawName)
+{
+    const char* pspace = strrchr(rawName, ' ');
+    if(pspace == NULL)
+    {
+        ffFontInitCopy(font, rawName);
+        return;
+    }
+
+    fontInit(font);
+
+    ffStrbufAppendNS(&font->name, (uint32_t)(pspace - rawName), rawName);
+    ffStrbufAppendS(&font->size, pspace + 1);
+
+    fontInitPretty(font);
+}
+
 void ffFontDestroy(FFfont* font)
 {
    ffStrbufDestroy(&font->pretty);
@@ -18,6 +18,7 @@ void ffFontInitQt(FFfont* font, const char* data);
 void ffFontInitPango(FFfont* font, const char* data);
 void ffFontInitCopy(FFfont* font, const char* name);
 void ffFontInitValues(FFfont* font, const char* name, const char* size);
+void ffFontInitWithSpace(FFfont* font, const char* rawName);
 void ffFontDestroy(FFfont* font);

 #endif
@@ -55,10 +55,12 @@ static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start,

 static inline void appendEmptyPlaceholder(FFstrbuf* buffer, const char* placeholder, uint32_t* argCounter, uint32_t numArgs, const FFformatarg* arguments)
 {
-    if(*argCounter > numArgs)
+    if(*argCounter >= numArgs)
        ffStrbufAppendS(buffer, placeholder);
    else
-        ffFormatAppendFormatArg(buffer, &arguments[(*argCounter)++]);
+        ffFormatAppendFormatArg(buffer, arguments + *argCounter);
+
+    (*argCounter)++;
 }

 static inline bool formatArgSet(const FFformatarg* arg)
@@ -31,7 +31,10 @@ static void initConfigDirs(FFstate* state)

    #define FF_ENSURE_ONLY_ONCE_IN_LIST(element) \
        if(ffListFirstIndexComp(&state->configDirs, element, strbufEqualsAdapter) < state->configDirs.length - 1) \
-            --state->configDirs.length;
+        { \
+            ffStrbufDestroy(ffListGet(&state->configDirs, state->configDirs.length - 1)); \
+            --state->configDirs.length; \
+        }

    FFstrbuf* userConfigHome = ffListAdd(&state->configDirs);
    ffStrbufInitA(userConfigHome, 64);
@@ -69,15 +72,16 @@ static void initConfigDirs(FFstate* state)

        startIndex = colonIndex + 1;
    }
+    ffStrbufDestroy(&xdgConfigDirs);

    FFstrbuf* systemConfigHome = ffListAdd(&state->configDirs);
    ffStrbufInitA(systemConfigHome, 64);
-    ffStrbufAppendS(systemConfigHome, FASTFETCH_TARGET_DIR_ROOT"/etc/xdg/");
+    ffStrbufAppendS(systemConfigHome, FASTFETCH_TARGET_DIR_ETC"/xdg/");
    FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfigHome)

    FFstrbuf* systemConfig = ffListAdd(&state->configDirs);
    ffStrbufInitA(systemConfig, 64);
-    ffStrbufAppendS(systemConfig, FASTFETCH_TARGET_DIR_ROOT"/etc/");
+    ffStrbufAppendS(systemConfig, FASTFETCH_TARGET_DIR_ETC"/");
    FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfig)

    #undef FF_ENSURE_ONLY_ONCE_IN_LIST
@@ -128,7 +132,7 @@ static void initModuleArg(FFModuleArgs* args)

 static void defaultConfig(FFinstance* instance)
 {
-    ffStrbufInit(&instance->config.logo.source);
+    ffStrbufInitA(&instance->config.logo.source, 0);
    instance->config.logo.type = FF_LOGO_TYPE_AUTO;
    for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
        ffStrbufInit(&instance->config.logo.colors[i]);
@@ -158,6 +162,8 @@ static void defaultConfig(FFinstance* instance)

    initModuleArg(&instance->config.os);
    initModuleArg(&instance->config.host);
+    initModuleArg(&instance->config.bios);
+    initModuleArg(&instance->config.board);
    initModuleArg(&instance->config.kernel);
    initModuleArg(&instance->config.uptime);
    initModuleArg(&instance->config.processes);
@@ -180,9 +186,11 @@ static void defaultConfig(FFinstance* instance)
    initModuleArg(&instance->config.swap);
    initModuleArg(&instance->config.disk);
    initModuleArg(&instance->config.battery);
+    initModuleArg(&instance->config.powerAdapter);
    initModuleArg(&instance->config.locale);
    initModuleArg(&instance->config.localIP);
    initModuleArg(&instance->config.publicIP);
+    initModuleArg(&instance->config.weather);
    initModuleArg(&instance->config.player);
    initModuleArg(&instance->config.song);
    initModuleArg(&instance->config.dateTime);
@@ -191,6 +199,7 @@ static void defaultConfig(FFinstance* instance)
    initModuleArg(&instance->config.vulkan);
    initModuleArg(&instance->config.openGL);
    initModuleArg(&instance->config.openCL);
+    initModuleArg(&instance->config.users);

    ffStrbufInitA(&instance->config.libPCI, 0);
    ffStrbufInitA(&instance->config.libVulkan, 0);
@@ -212,10 +221,17 @@ static void defaultConfig(FFinstance* instance)
    ffStrbufInitA(&instance->config.libGLX, 0);
    ffStrbufInitA(&instance->config.libOSMesa, 0);
    ffStrbufInitA(&instance->config.libOpenCL, 0);
+    ffStrbufInitA(&instance->config.libcJSON, 0);
+    ffStrbufInitA(&instance->config.libfreetype, 0);
+
+    instance->config.cpuTemp = false;
+    instance->config.gpuTemp = false;
+    instance->config.batteryTemp = false;

    instance->config.titleFQDN = false;

    ffStrbufInitA(&instance->config.diskFolders, 0);
+    instance->config.diskRemovable = false;

    ffStrbufInitA(&instance->config.batteryDir, 0);

@@ -224,8 +240,13 @@ static void defaultConfig(FFinstance* instance)
    instance->config.localIpShowIpV4 = true;
    instance->config.localIpShowIpV6 = false;
    instance->config.localIpShowLoop = false;
+    ffStrbufInit(&instance->config.localIpNamePrefix);

    instance->config.publicIpTimeout = 0;
+    ffStrbufInit(&instance->config.publicIpUrl);
+
+    instance->config.weatherTimeout = 0;
+    ffStrbufInitS(&instance->config.weatherOutputFormat, "%t+-+%C+(%l)");

    ffStrbufInitA(&instance->config.osFile, 0);

@@ -238,7 +259,7 @@ void ffInitInstance(FFinstance* instance)
    defaultConfig(instance);
 }

-#if !defined(__ANDROID__)
+#if !defined(__ANDROID__) && !defined(_WIN32) && !defined(__MSYS__)

 static void* connectDisplayServerThreadMain(void* instance)
 {
@@ -379,6 +400,111 @@ void ffFinish(FFinstance* instance)
    resetConsole();
 }

+static void destroyModuleArg(FFModuleArgs* args)
+{
+    ffStrbufDestroy(&args->key);
+    ffStrbufDestroy(&args->outputFormat);
+    ffStrbufDestroy(&args->errorFormat);
+}
+
+static void destroyConfig(FFinstance* instance)
+{
+    ffStrbufDestroy(&instance->config.logo.source);
+    for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
+        ffStrbufDestroy(&instance->config.logo.colors[i]);
+    ffStrbufDestroy(&instance->config.colorKeys);
+    ffStrbufDestroy(&instance->config.colorTitle);
+    ffStrbufDestroy(&instance->config.separator);
+
+    destroyModuleArg(&instance->config.os);
+    destroyModuleArg(&instance->config.host);
+    destroyModuleArg(&instance->config.bios);
+    destroyModuleArg(&instance->config.board);
+    destroyModuleArg(&instance->config.kernel);
+    destroyModuleArg(&instance->config.uptime);
+    destroyModuleArg(&instance->config.processes);
+    destroyModuleArg(&instance->config.packages);
+    destroyModuleArg(&instance->config.shell);
+    destroyModuleArg(&instance->config.resolution);
+    destroyModuleArg(&instance->config.de);
+    destroyModuleArg(&instance->config.wm);
+    destroyModuleArg(&instance->config.wmTheme);
+    destroyModuleArg(&instance->config.theme);
+    destroyModuleArg(&instance->config.icons);
+    destroyModuleArg(&instance->config.font);
+    destroyModuleArg(&instance->config.cursor);
+    destroyModuleArg(&instance->config.terminal);
+    destroyModuleArg(&instance->config.terminalFont);
+    destroyModuleArg(&instance->config.cpu);
+    destroyModuleArg(&instance->config.cpuUsage);
+    destroyModuleArg(&instance->config.gpu);
+    destroyModuleArg(&instance->config.memory);
+    destroyModuleArg(&instance->config.swap);
+    destroyModuleArg(&instance->config.disk);
+    destroyModuleArg(&instance->config.battery);
+    destroyModuleArg(&instance->config.powerAdapter);
+    destroyModuleArg(&instance->config.locale);
+    destroyModuleArg(&instance->config.localIP);
+    destroyModuleArg(&instance->config.publicIP);
+    destroyModuleArg(&instance->config.weather);
+    destroyModuleArg(&instance->config.player);
+    destroyModuleArg(&instance->config.song);
+    destroyModuleArg(&instance->config.dateTime);
+    destroyModuleArg(&instance->config.date);
+    destroyModuleArg(&instance->config.time);
+    destroyModuleArg(&instance->config.vulkan);
+    destroyModuleArg(&instance->config.openGL);
+    destroyModuleArg(&instance->config.openCL);
+    destroyModuleArg(&instance->config.users);
+
+    ffStrbufDestroy(&instance->config.libPCI);
+    ffStrbufDestroy(&instance->config.libVulkan);
+    ffStrbufDestroy(&instance->config.libWayland);
+    ffStrbufDestroy(&instance->config.libXcbRandr);
+    ffStrbufDestroy(&instance->config.libXcb);
+    ffStrbufDestroy(&instance->config.libXrandr);
+    ffStrbufDestroy(&instance->config.libX11);
+    ffStrbufDestroy(&instance->config.libGIO);
+    ffStrbufDestroy(&instance->config.libDConf);
+    ffStrbufDestroy(&instance->config.libDBus);
+    ffStrbufDestroy(&instance->config.libXFConf);
+    ffStrbufDestroy(&instance->config.libSQLite3);
+    ffStrbufDestroy(&instance->config.librpm);
+    ffStrbufDestroy(&instance->config.libImageMagick);
+    ffStrbufDestroy(&instance->config.libZ);
+    ffStrbufDestroy(&instance->config.libChafa);
+    ffStrbufDestroy(&instance->config.libEGL);
+    ffStrbufDestroy(&instance->config.libGLX);
+    ffStrbufDestroy(&instance->config.libOSMesa);
+    ffStrbufDestroy(&instance->config.libOpenCL);
+    ffStrbufDestroy(&instance->config.libcJSON);
+    ffStrbufDestroy(&instance->config.libfreetype);
+
+    ffStrbufDestroy(&instance->config.diskFolders);
+    ffStrbufDestroy(&instance->config.batteryDir);
+    ffStrbufDestroy(&instance->config.separatorString);
+    ffStrbufDestroy(&instance->config.localIpNamePrefix);
+    ffStrbufDestroy(&instance->config.publicIpUrl);
+    ffStrbufDestroy(&instance->config.weatherOutputFormat);
+    ffStrbufDestroy(&instance->config.osFile);
+    ffStrbufDestroy(&instance->config.playerName);
+}
+
+static void destroyState(FFinstance* instance)
+{
+    for(uint32_t i = 0; i < instance->state.configDirs.length; ++i)
+        ffStrbufDestroy((FFstrbuf*)ffListGet(&instance->state.configDirs, i));
+    ffListDestroy(&instance->state.configDirs);
+
+    ffStrbufDestroy(&instance->state.cacheDir);
+}
+
+void ffDestroyInstance(FFinstance* instance)
+{
+    destroyConfig(instance);
+    destroyState(instance);
+}
+
 //Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
 void ffListFeatures()
 {
@@ -446,6 +572,12 @@ void ffListFeatures()
        #ifdef FF_HAVE_OPENCL
            "opencl\n"
        #endif
+        #ifdef FF_HAVE_LIBCJSON
+            "libcjson\n"
+        #endif
+        #ifdef FF_HAVE_FREETYPE
+            "freetype"
+        #endif
        ""
    , stdout);
 }
@@ -3,6 +3,8 @@
 #ifndef FF_INCLUDED_common_io
 #define FF_INCLUDED_common_io

+#include "fastfetch.h"
+
 #include <sys/types.h> //mode_t

 bool ffWriteFDBuffer(int fd, const FFstrbuf* content);
@@ -19,6 +21,6 @@ bool ffFileExists(const char* fileName, mode_t mode);
 // Not thread safe!
 void ffSuppressIO(bool suppress);

-void ffGetTerminalResponse(const char* request, const char* format, ...);
+FF_C_SCANF(2, 3) void ffGetTerminalResponse(const char* request, const char* format, ...);

 #endif
@@ -3,9 +3,30 @@

 #include <stdarg.h>

+//Clang doesn't define __SANITIZE_ADDRESS__ but defines __has_feature(address_sanitizer)
+#if defined(__has_feature)
+    #if __has_feature(address_sanitizer)
+        #define __SANITIZE_ADDRESS__
+    #endif
+#endif
+
+#ifdef __SANITIZE_ADDRESS__
+    #define FF_DLOPEN_FLAGS RTLD_LAZY | RTLD_NODELETE
+#else
+    #define FF_DLOPEN_FLAGS RTLD_LAZY
+#endif
+
 static void* libraryLoad(const char* path, int maxVersion)
 {
-    void* result = dlopen(path, RTLD_LAZY);
+    void* result = dlopen(path, FF_DLOPEN_FLAGS);
+
+    #if defined(_WIN32) || defined(__MSYS__)
+
+    // libX.dll.1 never exists on Windows, while libX-1.dll may exist
+    FF_UNUSED(maxVersion)
+
+    #else
+
    if(result != NULL || maxVersion < 0)
        return result;

@@ -19,7 +40,7 @@ static void* libraryLoad(const char* path, int maxVersion)
        uint32_t originalLength = pathbuf.length;
        ffStrbufAppendF(&pathbuf, "%i", i);

-        result = dlopen(pathbuf.chars, RTLD_LAZY);
+        result = dlopen(pathbuf.chars, FF_DLOPEN_FLAGS);
        if(result != NULL)
            break;

@@ -27,13 +48,16 @@ static void* libraryLoad(const char* path, int maxVersion)
    }

    ffStrbufDestroy(&pathbuf);
+
+    #endif
+
    return result;
 }

 void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)
 {
-    if(userProvidedName->length > 0)
-        return dlopen(userProvidedName->chars, RTLD_LAZY);
+    if(userProvidedName != NULL && userProvidedName->length > 0)
+        return dlopen(userProvidedName->chars, FF_DLOPEN_FLAGS);

    va_list defaultNames;
    va_start(defaultNames, userProvidedName);
@@ -5,7 +5,9 @@

 #include <dlfcn.h>

-#ifdef __APPLE__
+#if defined(_WIN32) || defined(__MSYS__)
+    #define FF_LIBRARY_EXTENSION ".dll"
+#elif defined(__APPLE__)
    #define FF_LIBRARY_EXTENSION ".dylib"
 #else
    #define FF_LIBRARY_EXTENSION ".so"
@@ -15,7 +17,7 @@
    __typeof__(&symbolName) ff ## symbolName;

 #define FF_LIBRARY_LOAD(libraryObjectName, userLibraryName, returnValue, ...) \
-    void* libraryObjectName = ffLibraryLoad(&userLibraryName, __VA_ARGS__, NULL);\
+    void* libraryObjectName = ffLibraryLoad(userLibraryName, __VA_ARGS__, NULL);\
    if(libraryObjectName == NULL) \
        return returnValue;

@@ -6,22 +6,23 @@
 #include <sys/socket.h>
 #include <netdb.h>

-void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, FFstrbuf* buffer)
+int ffNetworkingSendHttpRequest(const char* host, const char* path, const char* headers, uint32_t timeout)
 {
-    struct addrinfo hints = {0};
-    hints.ai_family = AF_INET;
-    hints.ai_socktype = SOCK_STREAM;
+    struct addrinfo hints = {
+        .ai_family = AF_INET,
+        .ai_socktype = SOCK_STREAM,
+    };

    struct addrinfo* addr;

    if(getaddrinfo(host, "80", &hints, &addr) != 0)
-        return;
+        return -1;

-    int sock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
-    if(sock == -1)
+    int sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+    if(sockfd == -1)
    {
        freeaddrinfo(addr);
-        return;
+        return -1;
    }

    if(timeout > 0)
@@ -29,14 +30,14 @@ void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, F
        struct timeval timev;
        timev.tv_sec = 0;
        timev.tv_usec = (__typeof__(timev.tv_usec)) (timeout * 1000); //milliseconds to microseconds
-        setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
+        setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
    }

-    if(connect(sock, addr->ai_addr, addr->ai_addrlen) == -1)
+    if(connect(sockfd, addr->ai_addr, addr->ai_addrlen) == -1)
    {
-        close(sock);
+        close(sockfd);
        freeaddrinfo(addr);
-        return;
+        return -1;
    }

    freeaddrinfo(addr);
@@ -47,16 +48,23 @@ void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, F
    ffStrbufAppendS(&command, path);
    ffStrbufAppendS(&command, " HTTP/1.1\nHost: ");
    ffStrbufAppendS(&command, host);
-    ffStrbufAppendS(&command, "\r\n\r\n");
+    ffStrbufAppendS(&command, "\r\n");
+    ffStrbufAppendS(&command, headers);
+    ffStrbufAppendS(&command, "\r\n");

-    if(send(sock, command.chars, command.length, 0) == -1)
+    if(send(sockfd, command.chars, command.length, 0) == -1)
    {
        ffStrbufDestroy(&command);
-        close(sock);
-        return;
+        close(sockfd);
+        return -1;
    }
+    ffStrbufDestroy(&command);
+    return sockfd;
+}

-    ssize_t received = recv(sock, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);
+bool ffNetworkingRecvHttpResponse(int sockfd, FFstrbuf* buffer)
+{
+    ssize_t received = recv(sockfd, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);

    if(received > 0)
    {
@@ -64,6 +72,14 @@ void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, F
        buffer->chars[buffer->length] = '\0';
    }

-    ffStrbufDestroy(&command);
-    close(sock);
+    close(sockfd);
+    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n");
+}
+
+bool ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, const char* headers, FFstrbuf* buffer)
+{
+    int sockfd = ffNetworkingSendHttpRequest(host, path, headers, timeout);
+    if(sockfd > 0)
+        return ffNetworkingRecvHttpResponse(sockfd, buffer);
+    return false;
 }
@@ -5,6 +5,8 @@

 #include "util/FFstrbuf.h"

-void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, FFstrbuf* buffer);
+int ffNetworkingSendHttpRequest(const char* host, const char* path, const char* headers, uint32_t timeout);
+bool ffNetworkingRecvHttpResponse(int sock, FFstrbuf* buffer);
+bool ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, const char* headers, FFstrbuf* buffer);

 #endif
@@ -9,8 +9,8 @@
 void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat);
 void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments);
 void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments);
-void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...);
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
+FF_C_PRINTF(6, 7) void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...);
+FF_C_PRINTF(5, 6) void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
 void ffPrintColor(const FFstrbuf* colorValue);
 void ffPrintCharTimes(char c, uint32_t times);
 void ffPrintUserString(const char* str);
@@ -5,6 +5,6 @@

 #include "util/FFstrbuf.h"

-void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
+const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);

 #endif
@@ -6,16 +6,16 @@
 #include <unistd.h>
 #include <sys/wait.h>

-void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
+const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
 {
    int pipes[2];

    if(pipe(pipes) == -1)
-        return;
+        return "pipe() failed";

    pid_t childPid = fork();
    if(childPid == -1)
-        return;
+        return "fork() failed";

    //Child
    if(childPid == 0)
@@ -33,4 +33,6 @@ void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
    waitpid(childPid, NULL, 0);
    ffAppendFDBuffer(pipes[0], buffer);
    close(pipes[0]);
+
+    return NULL;
 }
@@ -0,0 +1,69 @@
+#include "fastfetch.h"
+#include "common/processing.h"
+
+#define WIN32_LEAN_AND_MEAN 1
+#include <Windows.h>
+
+//We can't use this native version yet because we still use POSIX path ( eg /usr/bin/fish ) at a lot of places.
+const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
+{
+    SECURITY_ATTRIBUTES saAttr = {
+        .nLength = sizeof(SECURITY_ATTRIBUTES),
+        .lpSecurityDescriptor = NULL,
+        .bInheritHandle = TRUE,
+    };
+
+    HANDLE hChildStdoutRead, hChildStdoutWrite;
+    if (!CreatePipe(&hChildStdoutRead, &hChildStdoutWrite, &saAttr, 0))
+        return "CreatePipe() failed";
+
+    if (!SetHandleInformation(hChildStdoutRead, HANDLE_FLAG_INHERIT, 0))
+        return "SetHandleInformation(hChildStdoutRead) failed";
+
+    PROCESS_INFORMATION piProcInfo = {0};
+    STARTUPINFOA siStartInfo = {
+        .cb = sizeof(siStartInfo),
+        .dwFlags = STARTF_USESTDHANDLES,
+        .hStdOutput = hChildStdoutWrite,
+    };
+
+    FFstrbuf cmdline;
+    ffStrbufInit(&cmdline);
+    for(char* const* parg = argv; *parg; ++parg)
+    {
+        if(cmdline.length > 0)
+            ffStrbufAppendC(&cmdline, ' ');
+        ffStrbufAppendF(&cmdline, "\"%s\"", * parg);
+    }
+
+    BOOL success = CreateProcessA(
+        NULL,          // application name
+        cmdline.chars, // command line
+        NULL,          // process security attributes
+        NULL,          // primary thread security attributes
+        TRUE,          // handles are inherited
+        0,             // creation flags
+        NULL,          // use parent's environment
+        NULL,          // use parent's current directory
+        &siStartInfo,  // STARTUPINFO pointer
+        &piProcInfo);  // receives PROCESS_INFORMATION
+
+    CloseHandle(hChildStdoutWrite);
+    if(!success)
+    {
+        CloseHandle(hChildStdoutRead);
+        return "CreateProcessA() failed";
+    }
+
+    char str[128];
+    DWORD nRead;
+    while(ReadFile(hChildStdoutRead, str, sizeof(str), &nRead, NULL) && nRead > 0)
+    {
+        ffStrbufAppendNS(buffer, nRead, str);
+        if(nRead < sizeof(str))
+            break;
+    }
+
+    CloseHandle(hChildStdoutRead);
+    return NULL;
+}
@@ -89,7 +89,7 @@ typedef struct GSettingsData
    GVariantGetters variantGetters;
 } GSettingsData;

-static const GSettingsData* getGSettingsData(FFinstance* instance)
+static const GSettingsData* getGSettingsData(const FFinstance* instance)
 {
    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0.so", 1);

@@ -114,7 +114,7 @@ static const GSettingsData* getGSettingsData(FFinstance* instance)
    FF_LIBRARY_DATA_LOAD_RETURN
 }

-FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
    const GSettingsData* data = getGSettingsData(instance);
    if(data == NULL)
@@ -143,7 +143,7 @@ FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, c
    return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_GIO
-FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
    FF_UNUSED(instance, schemaName, path, key, type)
    return FF_VARIANT_NULL;
@@ -161,7 +161,7 @@ typedef struct DConfData
    DConfClient* client;
 } DConfData;

-static const DConfData* getDConfData(FFinstance* instance)
+static const DConfData* getDConfData(const FFinstance* instance)
 {
    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf.so", 2);

@@ -181,7 +181,7 @@ static const DConfData* getDConfData(FFinstance* instance)
    FF_LIBRARY_DATA_LOAD_RETURN
 }

-FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
 {
    const DConfData* data = getDConfData(instance);
    if(data == NULL)
@@ -199,14 +199,14 @@ FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttyp
    return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_DCONF
-FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
 {
    FF_UNUSED(instance, key, type)
    return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_DCONF

-FFvariant ffSettingsGet(FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
+FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
 {
    FFvariant gsettings = ffSettingsGetGSettings(instance, gsettingsSchemaName, gsettingsPath, gsettingsKey, type);

@@ -231,7 +231,7 @@ typedef struct XFConfData
    FF_LIBRARY_SYMBOL(xfconf_init)
 } XFConfData;

-static const XFConfData* getXFConfData(FFinstance* instance)
+static const XFConfData* getXFConfData(const FFinstance* instance)
 {
    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0.so", 4);

@@ -248,7 +248,7 @@ static const XFConfData* getXFConfData(FFinstance* instance)
    FF_LIBRARY_DATA_LOAD_RETURN
 }

-FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
 {
    const XFConfData* data = getXFConfData(instance);
    if(data == NULL)
@@ -271,7 +271,7 @@ FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, con
    return FF_VARIANT_NULL;
 }
 #else //FF_HAVE_XFCONF
-FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
 {
    FF_UNUSED(instance, channelName, propertyName, type)
    return FF_VARIANT_NULL;
@@ -358,38 +358,3 @@ void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
    result->chars[result->length] = '\0';
 }
 #endif //__ANDROID__
-
-#ifdef __APPLE__
-#include <sys/sysctl.h>
-void ffSettingsGetAppleProperty(const char* propName, FFstrbuf* result)
-{
-    size_t neededLength;
-    if(sysctlbyname(propName, NULL, &neededLength, NULL, 0) != 0 || neededLength == 0)
-        return;
-
-    ffStrbufEnsureFree(result, (uint32_t) neededLength);
-
-    if(sysctlbyname(propName, result->chars + result->length, &neededLength, NULL, 0) == 0)
-        result->length += (uint32_t) neededLength;
-
-    result->chars[result->length] = '\0';
-}
-
-int ffSettingsGetAppleInt(const char* propName, int defaultValue)
-{
-    int result;
-    size_t neededLength = sizeof(result);
-    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
-        return defaultValue;
-    return result;
-}
-
-int64_t ffSettingsGetAppleInt64(const char* propName, int64_t defaultValue)
-{
-    int64_t result;
-    size_t neededLength = sizeof(result);
-    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
-        return defaultValue;
-    return result;
-}
-#endif //__APPLE__
@@ -25,10 +25,10 @@ typedef union FFvariant

 #define FF_VARIANT_NULL ((FFvariant){.strValue = NULL})

-FFvariant ffSettingsGetDConf(FFinstance* instance, const char* key, FFvarianttype type);
-FFvariant ffSettingsGetGSettings(FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type);
-FFvariant ffSettingsGet(FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
-FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type);
+FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type);
+FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type);
+FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
+FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type);

 int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query);

@@ -36,10 +36,4 @@ int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, cons
 void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
 #endif

-#ifdef __APPLE__
-void ffSettingsGetAppleProperty(const char* propName, FFstrbuf* result);
-int ffSettingsGetAppleInt(const char* propName, int defaultValue);
-int64_t ffSettingsGetAppleInt64(const char* propName, int64_t defaultValue);
-#endif
-
 #endif
@@ -0,0 +1,53 @@
+#include "sysctl.h"
+
+#include <stdlib.h>
+
+void ffSysctlGetString(const char* propName, FFstrbuf* result)
+{
+    size_t neededLength;
+    if(sysctlbyname(propName, NULL, &neededLength, NULL, 0) != 0 || neededLength == 1) //neededLength is 1 for empty strings, because of the null terminator
+        return;
+
+    ffStrbufEnsureFree(result, (uint32_t) neededLength - 1);
+
+    if(sysctlbyname(propName, result->chars + result->length, &neededLength, NULL, 0) == 0)
+        result->length += (uint32_t) neededLength - 1;
+
+    result->chars[result->length] = '\0';
+}
+
+int ffSysctlGetInt(const char* propName, int defaultValue)
+{
+    int result;
+    size_t neededLength = sizeof(result);
+    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
+        return defaultValue;
+    return result;
+}
+
+int64_t ffSysctlGetInt64(const char* propName, int64_t defaultValue)
+{
+    int64_t result;
+    size_t neededLength = sizeof(result);
+    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
+        return defaultValue;
+    return result;
+}
+
+void* ffSysctlGetData(int* request, u_int requestLength, size_t* resultLength)
+{
+    if(sysctl(request, requestLength, NULL, resultLength, NULL, 0) != 0)
+        return NULL;
+
+    void* data = malloc(*resultLength);
+    if(data == NULL)
+        return NULL;
+
+    if(sysctl(request, requestLength, data, resultLength, NULL, 0) != 0)
+    {
+        free(data);
+        return NULL;
+    }
+
+    return data;
+}
@@ -0,0 +1,15 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_sysctl
+#define FF_INCLUDED_common_sysctl
+
+#include "fastfetch.h"
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+void ffSysctlGetString(const char* propName, FFstrbuf* result);
+int ffSysctlGetInt(const char* propName, int defaultValue);
+int64_t ffSysctlGetInt64(const char* propName, int64_t defaultValue);
+void* ffSysctlGetData(int* request, u_int requestLength, size_t* resultLength);
+
+#endif
@@ -0,0 +1,35 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_time
+#define FF_INCLUDED_common_time
+
+#include <stdint.h>
+#if defined(_WIN32) || defined(__MSYS__)
+    #include <synchapi.h>
+    #include <sysinfoapi.h>
+#else
+    #include <sys/time.h>
+    #include <time.h>
+#endif
+
+static inline uint64_t ffTimeGetTick() //In msec
+{
+    #if defined(_WIN32) || defined(__MSYS__)
+        return GetTickCount64();
+    #else
+        struct timeval timeNow;
+        gettimeofday(&timeNow, NULL);
+        return (uint64_t)((timeNow.tv_sec * 1000) + (timeNow.tv_usec / 1000));
+    #endif
+}
+
+static inline void ffTimeSleep(uint32_t msec)
+{
+    #if defined(_WIN32) || defined(__MSYS__)
+        SleepEx(msec, TRUE);
+    #else
+        nanosleep(&(struct timespec){ msec / 1000, (msec % 1000) * 1000000 }, NULL);
+    #endif
+}
+
+#endif
@@ -5,7 +5,7 @@
 # Whitespaces are trimmed at the beginning and the end.
 # Empty lines or lines starting with # are ignored.

-# This file was shipped with $"FASTFETCH_PROJECT_VERSION$".
+# This file was shipped with $" FASTFETCH_PROJECT_VERSION $".
 # Use fastfetch --print-config-user > ~/.config/fastfetch/config.conf to overwrite this file with the current defaults

 # Below some often usefull options are listed. Uncomment and modify them so they take affect.
@@ -25,7 +25,7 @@
 # Must be a list of module names, separated by colons.
 # List available modules with "fastfetch --list-modules".
 # Get the default structure with "fastfetch --print-structure".
-#--structure $"FASTFETCH_DATATEXT_STRUCTURE$"
+#--structure $" FASTFETCH_DATATEXT_STRUCTURE $"

 # Multithreading option:
 # Sets if fastfetch should use multiple threads to detect the values.
@@ -151,12 +151,30 @@
 # Default is "-"
 #--separator-string -

+# Public IP URL option:
+# Sets the URL of public IP detection server to be used.
+# Only HTTP protocol is supported, and the value should not contain "http://" prefix.
+# Default is "ipinfo.io/ip".
+#--public-ip-url "ipinfo.io/ip"
+
 # Public IP timeout option:
 # Sets the time to wait for the public ip server to respond.
 # Must be a positive integer.
 # Default is 0 (disabled).
 #--public-ip-timeout 0

+# Weather output format option:
+# Sets the weather format to be used. It must be URI encoded.
+# See: https://github.com/chubin/wttr.in#one-line-output
+# Default is "%t+-+%C+(%l)".
+#--weather-output-format "%t+-+%C+(%l)"
+
+# Weather timeout option:
+# Sets the time to wait for the weather server (wttr.in) to respond.
+# Must be a positive integer.
+# Default is 0 (disabled).
+#--weather-timeout 0
+
 # OS file option
 # Sets the path to the file containing the operating system information.
 # Should be a valid path to an existing file.
@@ -209,15 +227,18 @@
 #--swap-key Swap
 #--disk-key Disk ({1})
 #--battery-key Battery {1}
+#--poweradapter-key Power Adapter {1}
 #--locale-key Locale
 #--local-ip-key Local IP ({1})
 #--public-ip-key Public IP
+#--weather-key Weather
 #--player-key Media Player
 #--song-key Song
 #--datetime-key Date Time
 #--vulkan-key Vulkan
 #--opengl-key OpenGL
 #--opencl-key OpenCL
+#--users-key Users

 # Format options:
 # Sets the format string for module values.
@@ -248,15 +269,18 @@
 #--swap-format
 #--disk-format
 #--battery-format
+#--poweradapter-format
 #--locale-format
 #--local-ip-format
 #--public-ip-format
+#--weather-format
 #--player-format
 #--song-format
 #--datetime-format
 #--vulkan-format
 #--opengl-format
 #--opencl-format
+#--users-format

 # Error options:
 # Sets the format string to use if an error occured
@@ -287,15 +311,18 @@
 #--swap-error
 #--disk-error
 #--battery-error
+#--poweradapter-error
 #--locale-error
 #--local-ip-error
 #--public-ip-error
+#--weather-error
 #--player-error
 #--song-error
 #--datetime-error
 #--vulkan-error
 #--opengl-error
 #--opencl-error
+#--users-error

 # Library options:
 # Sets an user specific path to a library to load.
@@ -320,3 +347,5 @@
 #--lib-glx /usr/lib/libGLX.so
 #--lib-osmesa /usr/lib/libOSMesa.so
 #--lib-opencl /usr/lib/libOpenCL.so
+#--lib-cjson /usr/lib/libcjson.so
+#--lib-freetype /data/data/com.termux/files/usr/lib
@@ -84,17 +84,26 @@ Library options: Set the path of a library to load
    --lib-glx <path>
    --lib-osmesa <path>
    --lib-opencl <path>
+    --lib-cjson <path>

 Module specific options:
-    --title-fqdn <?value>:        sets if the title should use fully qualified domain name. Default is false.
+    --title-fqdn <?value>:        Sets if the title should use fully qualified domain name. Default is false.
    --separator-string <str>:     Set the string printed by the separator module
    --os-file <path>:             Set the path to the file containing OS informations
-    --disk-folders <folders>:     A colon separated list of folder paths for the disk output. Default is "/:/home"
+    --disk-folders <folders>:     A colon (semicolon on Windows) separated list of folder paths for the disk output. Default is "/:/home" ("C:\\;D:\\ ..." on Windows)
+    --disk-removable <?value>:    Sets if removable volume should be printed. Default is false
    --battery-dir <folder>:       The directory where the battery folders are. Standard: /sys/class/power_supply/
+    --cpu-temp  <?value>:         Detect and display CPU temperature if supported. Default is false
+    --gpu-temp  <?value>:         Detect and display GPU temperature if supported. Default is false
+    --battery-temp  <?value>:     Detect and display Battery temperature if supported. Default is false
    --localip-show-ipv4 <?value>: Show ipv4 addresses in local ip module. Default is true
    --localip-show-ipv6 <?value>: Show ipv6 addresses in local ip module. Default is false
    --localip-show-loop <?value>: Show loop back addresses (127.0.0.1) in local ip module. Default is false
+    --localip-name-prefix <str>:  Show ips with given name prefix only. Default is empty
    --public-ip-timeout:          Time in milliseconds to wait for the public ip server to respond. Default is disabled (0)
+    --public-ip-url:              The URL of public IP detection server to be used.
+    --weather-timeout:            Time in milliseconds to wait for the weather server to respond. Default is disabled (0)
+    --weather-output-format:      The output weather format to be used. It must be URI encoded.
    --player-name:                The name of the player to use
    --gl <value>:                 Sets the opengl context creation library to use. Must be auto, egl, glx or osmesa. Default is auto

@@ -24,6 +24,7 @@ Packages
 Player
 Processes
 PublicIP
+PowerAdapter
 Resolution
 Separator
 Shell
@@ -1 +1 @@
-Title:Separator:OS:Host:Kernel:Uptime:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Disk:Battery:Locale:Break:Colors
+Title:Separator:OS:Host:Kernel:Uptime:Packages:Shell:Resolution:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Terminal:TerminalFont:CPU:GPU:Memory:Disk:Battery:PowerAdapter:Locale:Break:Colors
@@ -0,0 +1,22 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_battery_battery
+#define FF_INCLUDED_detection_battery_battery
+
+#include "fastfetch.h"
+
+#define FF_BATTERY_TEMP_UNSET (0/0.0)
+
+typedef struct BatteryResult
+{
+    FFstrbuf manufacturer;
+    FFstrbuf modelName;
+    FFstrbuf technology;
+    FFstrbuf capacity;
+    FFstrbuf status;
+    double temperature;
+} BatteryResult;
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results);
+
+#endif
@@ -0,0 +1,109 @@
+#include "fastfetch.h"
+#include "battery.h"
+#include "util/apple/cf_helpers.h"
+#include "detection/temps/temps_apple.h"
+
+#include <IOKit/IOKitLib.h>
+
+static double detectBatteryTemp()
+{
+    FFlist temps;
+    ffListInit(&temps, sizeof(FFTempValue));
+
+    ffDetectCoreTemps(FF_TEMP_BATTERY, &temps);
+
+    if(temps.length == 0)
+        return FF_BATTERY_TEMP_UNSET;
+
+    double result = 0;
+    for(uint32_t i = 0; i < temps.length; ++i)
+    {
+        FFTempValue* tempValue = (FFTempValue*)ffListGet(&temps, i);
+        result += tempValue->value;
+        //TODO: do we really need this?
+        ffStrbufDestroy(&tempValue->name);
+        ffStrbufDestroy(&tempValue->deviceClass);
+    }
+    result /= temps.length;
+    ffListDestroy(&temps);
+    return result;
+}
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
+{
+    FF_UNUSED(instance);
+
+    CFMutableDictionaryRef matchDict = IOServiceMatching("AppleSmartBattery");
+    if (matchDict == NULL)
+        return "IOServiceMatching(\"AppleSmartBattery\") failed";
+
+    io_iterator_t iterator;
+    if(IOServiceGetMatchingServices(MACH_PORT_NULL, matchDict, &iterator) != kIOReturnSuccess)
+        return "IOServiceGetMatchingServices() failed";
+
+    io_registry_entry_t registryEntry;
+    while((registryEntry = IOIteratorNext(iterator)) != 0)
+    {
+        CFMutableDictionaryRef properties;
+        if(IORegistryEntryCreateCFProperties(registryEntry, &properties, kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
+        {
+            IOObjectRelease(registryEntry);
+            continue;
+        }
+
+        bool boolValue;
+        const char* error;
+
+        BatteryResult* battery = ffListAdd(results);
+        ffStrbufInit(&battery->capacity);
+        int currentCapacity, maxCapacity;
+
+        if ((error = ffCfDictGetInt(properties, CFSTR("MaxCapacity"), &maxCapacity)))
+            return error;
+        if (maxCapacity <= 0)
+            return "Querying MaxCapacity failed";
+
+        if ((error = ffCfDictGetInt(properties, CFSTR("CurrentCapacity"), &currentCapacity)))
+            return error;
+        if(currentCapacity <= 0)
+            return "Querying CurrentCapacity failed";
+
+        ffStrbufAppendF(&battery->capacity, "%.0f", currentCapacity * 100.0 / maxCapacity);
+
+        ffStrbufInit(&battery->manufacturer);
+        ffStrbufInit(&battery->modelName);
+        ffStrbufInit(&battery->technology);
+        if (!ffCfDictGetBool(properties, CFSTR("built-in"), &boolValue) && boolValue)
+        {
+            ffStrbufAppendS(&battery->manufacturer, "Apple Inc.");
+            ffStrbufAppendS(&battery->modelName, "Builtin");
+            ffStrbufAppendS(&battery->technology, "Lithium");
+        }
+        else
+        {
+            ffStrbufAppendS(&battery->manufacturer, "Unknown");
+            ffStrbufAppendS(&battery->modelName, "Unknown");
+            ffStrbufAppendS(&battery->technology, "Unknown");
+        }
+
+        ffStrbufInit(&battery->status);
+        if (!ffCfDictGetBool(properties, CFSTR("FullyCharged"), &boolValue) && boolValue)
+            ffStrbufAppendS(&battery->status, "Fully charged");
+        else if (!ffCfDictGetBool(properties, CFSTR("IsCharging"), &boolValue) && boolValue)
+            ffStrbufAppendS(&battery->status, "Charging");
+        else
+            ffStrbufAppendS(&battery->status, "");
+
+        if(instance->config.batteryTemp)
+            battery->temperature = detectBatteryTemp();
+        else
+            battery->temperature = FF_BATTERY_TEMP_UNSET;
+
+        CFRelease(properties);
+        IOObjectRelease(registryEntry);
+    }
+
+    IOObjectRelease(iterator);
+
+    return NULL;
+}
@@ -0,0 +1,116 @@
+#include "fastfetch.h"
+#include "common/io.h"
+#include "battery.h"
+
+#include <dirent.h>
+
+static void parseBattery(FFstrbuf* dir, FFlist* results)
+{
+    uint32_t dirLength = dir->length;
+
+    FFstrbuf testBatteryBuffer;
+    ffStrbufInit(&testBatteryBuffer);
+
+    //type must exist and be "Battery"
+    ffStrbufAppendS(dir, "/type");
+    ffReadFileBuffer(dir->chars, &testBatteryBuffer);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Battery") != 0)
+    {
+        ffStrbufDestroy(&testBatteryBuffer);
+        return;
+    }
+
+    //scope may not exist or must not be "Device"
+    ffStrbufAppendS(dir, "/scope");
+    ffReadFileBuffer(dir->chars, &testBatteryBuffer);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    if(ffStrbufIgnCaseCompS(&testBatteryBuffer, "Device") == 0)
+    {
+        ffStrbufDestroy(&testBatteryBuffer);
+        return;
+    }
+
+    ffStrbufDestroy(&testBatteryBuffer);
+    BatteryResult* result = ffListAdd(results);
+
+    //capacity must exist and be not empty
+    ffStrbufInit(&result->capacity);
+    ffStrbufAppendS(dir, "/capacity");
+    ffReadFileBuffer(dir->chars, &result->capacity);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    if(result->capacity.length == 0)
+    {
+        ffStrbufDestroy(&result->capacity);
+        --results->length;
+        return;
+    }
+
+    //At this point, we have a battery. Try to get as much values as possible.
+
+    ffStrbufInit(&result->manufacturer);
+    ffStrbufAppendS(dir, "/manufacturer");
+    ffReadFileBuffer(dir->chars, &result->manufacturer);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    ffStrbufInit(&result->modelName);
+    ffStrbufAppendS(dir, "/model_name");
+    ffReadFileBuffer(dir->chars, &result->modelName);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    ffStrbufInit(&result->technology);
+    ffStrbufAppendS(dir, "/technology");
+    ffReadFileBuffer(dir->chars, &result->technology);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    ffStrbufInit(&result->status);
+    ffStrbufAppendS(dir, "/status");
+    ffReadFileBuffer(dir->chars, &result->status);
+    ffStrbufSubstrBefore(dir, dirLength);
+
+    result->temperature = FF_BATTERY_TEMP_UNSET;
+}
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
+    if(instance->config.batteryDir.length > 0)
+    {
+        ffStrbufAppend(&baseDir, &instance->config.batteryDir);
+        ffStrbufEnsureEndsWithC(&baseDir, '/');
+    }
+    else
+    {
+        ffStrbufAppendS(&baseDir, "/sys/class/power_supply/");
+    }
+
+    uint32_t baseDirLength = baseDir.length;
+
+    DIR* dirp = opendir(baseDir.chars);
+    if(dirp == NULL)
+    {
+        ffStrbufDestroy(&baseDir);
+        return "opendir(batteryDir) == NULL";
+    }
+
+    struct dirent* entry;
+    while((entry = readdir(dirp)) != NULL)
+    {
+        ffStrbufAppendS(&baseDir, entry->d_name);
+        parseBattery(&baseDir, results);
+        ffStrbufSubstrBefore(&baseDir, baseDirLength);
+    }
+
+    closedir(dirp);
+
+    if(results->length == 0) {
+        ffStrbufDestroy(&baseDir);
+        return "batteryDir doesn't contain any battery folder";
+    }
+
+    ffStrbufDestroy(&baseDir);
+    return NULL;
+}
@@ -0,0 +1,8 @@
+#include "fastfetch.h"
+#include "battery.h"
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
+{
+    FF_UNUSED(instance, results)
+    return "Not supported on this platform";
+}
@@ -0,0 +1,70 @@
+extern "C" {
+#include "battery.h"
+}
+#include "util/windows/wmi.hpp"
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results)
+{
+    FF_UNUSED(instance);
+
+    //https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/win32-battery
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT SystemName, Name, Chemistry, EstimatedChargeRemaining, BatteryStatus FROM Win32_Battery", nullptr);
+
+    if(!pEnumerator)
+        return "Query WMI service failed";
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    while(SUCCEEDED(pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn)) && uReturn != 0)
+    {
+        BatteryResult* battery = (BatteryResult*)ffListAdd(results);
+
+        ffStrbufInit(&battery->manufacturer);
+        ffGetWmiObjString(pclsObj, L"SystemName", &battery->manufacturer);
+
+        ffStrbufInit(&battery->modelName);
+        ffGetWmiObjString(pclsObj, L"Name", &battery->modelName);
+
+        uint64_t chemistry;
+        ffGetWmiObjUnsigned(pclsObj, L"Chemistry", &chemistry);
+        switch(chemistry)
+        {
+            case 1: ffStrbufInitS(&battery->technology, "Other"); break;
+            case 2: ffStrbufInitS(&battery->technology, "Unknown"); break;
+            case 3: ffStrbufInitS(&battery->technology, "Lead Acid"); break;
+            case 4: ffStrbufInitS(&battery->technology, "Nickel Cadmium"); break;
+            case 5: ffStrbufInitS(&battery->technology, "Nickel Metal Hydride"); break;
+            case 6: ffStrbufInitS(&battery->technology, "Lithium-ion"); break;
+            case 7: ffStrbufInitS(&battery->technology, "Zinc air"); break;
+            case 8: ffStrbufInitS(&battery->technology, "Lithium Polymer"); break;
+        }
+
+        uint64_t capacity;
+        ffGetWmiObjUnsigned(pclsObj, L"EstimatedChargeRemaining", &capacity);
+        ffStrbufInitF(&battery->capacity, "%d", (int)capacity);
+
+        uint64_t batteryStatus;
+        ffGetWmiObjUnsigned(pclsObj, L"BatteryStatus", &batteryStatus);
+        switch(batteryStatus)
+        {
+            case 1: ffStrbufInitS(&battery->status, "Discharging"); break;
+            case 2: ffStrbufInitS(&battery->status, "AC Connected"); break;
+            case 3: ffStrbufInitS(&battery->status, "Fully Charged"); break;
+            case 4: ffStrbufInitS(&battery->status, "Low"); break;
+            case 5: ffStrbufInitS(&battery->status, "Critical"); break;
+            case 6: ffStrbufInitS(&battery->status, "Charging"); break;
+            case 7: ffStrbufInitS(&battery->status, "Charging and High"); break;
+            case 8: ffStrbufInitS(&battery->status, "Charging and Low"); break;
+            case 9: ffStrbufInitS(&battery->status, "Charging and Critical"); break;
+            case 10: ffStrbufInitS(&battery->status, "Undefined"); break;
+            case 11: ffStrbufInitS(&battery->status, "Partially Charged"); break;
+        }
+
+        battery->temperature = FF_BATTERY_TEMP_UNSET;
+    }
+
+    pclsObj->Release();
+    pEnumerator->Release();
+    return nullptr;
+}
@@ -0,0 +1,19 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_bios_bios
+#define FF_INCLUDED_detection_bios_bios
+
+#include "fastfetch.h"
+
+typedef struct FFBiosResult
+{
+    FFstrbuf biosDate;
+    FFstrbuf biosRelease;
+    FFstrbuf biosVendor;
+    FFstrbuf biosVersion;
+    FFstrbuf error;
+} FFBiosResult;
+
+void ffDetectBios(FFBiosResult* bios);
+
+#endif
@@ -0,0 +1,58 @@
+#include "bios.h"
+#include "common/io.h"
+
+#include <stdlib.h>
+
+static bool hostValueSet(FFstrbuf* value)
+{
+    return
+        value->length > 0 &&
+        ffStrbufStartsWithIgnCaseS(value, "To be filled") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "To be set") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "OEM") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "O.E.M.") != true &&
+        ffStrbufIgnCaseCompS(value, "None") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Default string") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Undefined") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Specified") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Applicable") != 0 &&
+        ffStrbufIgnCaseCompS(value, "INVALID") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Type1ProductConfigId") != 0 &&
+        ffStrbufIgnCaseCompS(value, "All Series") != 0
+    ;
+}
+
+static void getHostValue(const char* devicesPath, const char* classPath, FFstrbuf* buffer)
+{
+    ffReadFileBuffer(devicesPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffReadFileBuffer(classPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffStrbufClear(buffer);
+}
+
+void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInit(&bios->error);
+
+    ffStrbufInit(&bios->biosDate);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_date", "/sys/class/dmi/id/bios_date", &bios->biosDate);
+
+    ffStrbufInit(&bios->biosRelease);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_release", "/sys/class/dmi/id/bios_release", &bios->biosRelease);
+
+    ffStrbufInit(&bios->biosVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_vendor", "/sys/class/dmi/id/bios_vendor", &bios->biosVendor);
+
+    ffStrbufInit(&bios->biosVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_version", "/sys/class/dmi/id/bios_version", &bios->biosVersion);
+}
@@ -0,0 +1,11 @@
+#include "bios.h"
+
+void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInitS(&bios->error, "Not supported on this platform");
+
+    ffStrbufInit(&bios->biosDate);
+    ffStrbufInit(&bios->biosRelease);
+    ffStrbufInit(&bios->biosVendor);
+    ffStrbufInit(&bios->biosVersion);
+}
@@ -0,0 +1,38 @@
+extern "C" {
+#include "bios.h"
+}
+#include "util/windows/wmi.hpp"
+
+extern "C" void ffDetectBios(FFBiosResult* bios)
+{
+    ffStrbufInit(&bios->error);
+
+    ffStrbufInit(&bios->biosDate);
+    ffStrbufInit(&bios->biosRelease);
+    ffStrbufInit(&bios->biosVendor);
+    ffStrbufInit(&bios->biosVersion);
+
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT Name, ReleaseDate, Version, Manufacturer FROM Win32_BIOS", &bios->error);
+    if(!pEnumerator)
+        return;
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
+
+    if(uReturn == 0)
+    {
+        ffStrbufInitS(&bios->error, "No Wmi result returned");
+        pEnumerator->Release();
+        return;
+    }
+
+    ffGetWmiObjString(pclsObj, L"Name", &bios->biosRelease);
+    ffGetWmiObjString(pclsObj, L"ReleaseDate", &bios->biosDate);
+    ffGetWmiObjString(pclsObj, L"Version", &bios->biosVersion);
+    ffGetWmiObjString(pclsObj, L"Manufacturer", &bios->biosVendor);
+
+    pclsObj->Release();
+    pEnumerator->Release();
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_board_board
+#define FF_INCLUDED_detection_board_board
+
+#include "fastfetch.h"
+
+typedef struct FFBoardResult
+{
+    FFstrbuf boardName;
+    FFstrbuf boardVendor;
+    FFstrbuf boardVersion;
+    FFstrbuf error;
+} FFBoardResult;
+
+void ffDetectBoard(FFBoardResult* result);
+
+#endif
@@ -0,0 +1,55 @@
+#include "board.h"
+#include "common/io.h"
+
+#include <stdlib.h>
+
+static bool hostValueSet(FFstrbuf* value)
+{
+    return
+        value->length > 0 &&
+        ffStrbufStartsWithIgnCaseS(value, "To be filled") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "To be set") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "OEM") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "O.E.M.") != true &&
+        ffStrbufIgnCaseCompS(value, "None") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Default string") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Undefined") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Specified") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Applicable") != 0 &&
+        ffStrbufIgnCaseCompS(value, "INVALID") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Type1ProductConfigId") != 0 &&
+        ffStrbufIgnCaseCompS(value, "All Series") != 0
+    ;
+}
+
+static void getHostValue(const char* devicesPath, const char* classPath, FFstrbuf* buffer)
+{
+    ffReadFileBuffer(devicesPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffReadFileBuffer(classPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffStrbufClear(buffer);
+}
+
+void ffDetectBoard(FFBoardResult* board)
+{
+    ffStrbufInit(&board->error);
+
+    ffStrbufInit(&board->boardName);
+    getHostValue("/sys/devices/virtual/dmi/id/board_name", "/sys/class/dmi/id/board_name", &board->boardName);
+
+    ffStrbufInit(&board->boardVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/board_vendor", "/sys/class/dmi/id/board_vendor", &board->boardVendor);
+
+    ffStrbufInit(&board->boardVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/board_version", "/sys/class/dmi/id/board_version", &board->boardVersion);
+}
@@ -0,0 +1,10 @@
+#include "board.h"
+
+void ffDetectBoard(FFBoardResult* board)
+{
+    ffStrbufInitS(&board->error, "Not supported on this platform");
+
+    ffStrbufInit(&board->boardName);
+    ffStrbufInit(&board->boardVendor);
+    ffStrbufInit(&board->boardVersion);
+}
@@ -0,0 +1,36 @@
+extern "C" {
+#include "board.h"
+}
+#include "util/windows/wmi.hpp"
+
+extern "C" void ffDetectBoard(FFBoardResult* board)
+{
+    ffStrbufInit(&board->error);
+
+    ffStrbufInit(&board->boardName);
+    ffStrbufInit(&board->boardVendor);
+    ffStrbufInit(&board->boardVersion);
+
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT Product, Version, Manufacturer FROM Win32_BaseBoard", &board->error);
+    if(!pEnumerator)
+        return;
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
+
+    if(uReturn == 0)
+    {
+        ffStrbufInitS(&board->error, "No Wmi result returned");
+        pEnumerator->Release();
+        return;
+    }
+
+    ffGetWmiObjString(pclsObj, L"Product", &board->boardName);
+    ffGetWmiObjString(pclsObj, L"Manufacturer", &board->boardVendor);
+    ffGetWmiObjString(pclsObj, L"Version", &board->boardVersion);
+
+    pclsObj->Release();
+    pEnumerator->Release();
+}
@@ -1,22 +1,52 @@
 #include "cpu.h"
+#include "common/caching.h"
 #include "detection/internal.h"

-void ffDetectCPUImpl(FFCPUResult* cpu);
+#define FF_CPU_CACHE_NAME "cpu"

-const FFCPUResult* ffDetectCPU()
+void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu, bool cached);
+
+static bool cacheCallback(FFCPUResult* cpu, FFCache* cache, FFCacheMethodStrbuf strbufMethod, FFCacheMethodData dataMethod)
+{
+    return
+        strbufMethod(cache, &cpu->vendor) &&
+        strbufMethod(cache, &cpu->name) &&
+        dataMethod(cache, sizeof(cpu->coresPhysical), &cpu->coresPhysical) &&
+        dataMethod(cache, sizeof(cpu->coresLogical), &cpu->coresLogical) &&
+        dataMethod(cache, sizeof(cpu->coresOnline), &cpu->coresOnline) &&
+        dataMethod(cache, sizeof(cpu->frequencyMin), &cpu->frequencyMin) &&
+        dataMethod(cache, sizeof(cpu->frequencyMax), &cpu->frequencyMax);
+}
+
+static void detectCPU(const FFinstance* instance, FFCPUResult* cpu)
+{
+    ffStrbufInit(&cpu->name);
+    ffStrbufInit(&cpu->vendor);
+
+    bool cached = ffCacheRead(instance, cpu, FF_CPU_CACHE_NAME, (FFCacheMethodCallback) cacheCallback);
+
+    ffDetectCPUImpl(instance, cpu, cached);
+
+    if(cached)
+        return;
+
+    const char* removeStrings[] = {
+        "(R)", "(r)", "(TM)", "(tm)",
+        " CPU", " FPU", " APU", " Processor",
+        " Dual-Core", " Quad-Core", " Six-Core", " Eight-Core", " Ten-Core",
+        " 2-Core", " 4-Core", " 6-Core", " 8-Core", " 10-Core", " 12-Core", " 14-Core", " 16-Core",
+        " with Radeon Graphics"
+    };
+    ffStrbufRemoveStringsA(&cpu->name, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
+    ffStrbufSubstrBeforeFirstC(&cpu->name, '@'); //Cut the speed output in the name as we append our own
+    ffStrbufTrimRight(&cpu->name, ' '); //If we removed the @ in previous step there was most likely a space before it
+
+    ffCacheWrite(instance, cpu, FF_CPU_CACHE_NAME, (FFCacheMethodCallback) cacheCallback);
+}
+
+const FFCPUResult* ffDetectCPU(const FFinstance* instance)
 {
    FF_DETECTION_INTERNAL_GUARD(FFCPUResult,
-        ffDetectCPUImpl(&result);
-
-        const char* removeStrings[] = {
-            "(R)", "(r)", "(TM)", "(tm)",
-            " CPU", " FPU", " APU", " Processor",
-            " Dual-Core", " Quad-Core", " Six-Core", " Eight-Core", " Ten-Core",
-            " 2-Core", " 4-Core", " 6-Core", " 8-Core", " 10-Core", " 12-Core", " 14-Core", " 16-Core",
-            " with Radeon Graphics"
-        };
-        ffStrbufRemoveStringsA(&result.name, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
-        ffStrbufSubstrBeforeFirstC(&result.name, '@'); //Cut the speed output in the name as we append our own
-        ffStrbufTrimRight(&result.name, ' '); //If we removed the @ in previous step there was most likely a space before it
+        detectCPU(instance, &result);
    );
 }
@@ -22,6 +22,6 @@ typedef struct FFCPUResult
    double temperature;
 } FFCPUResult;

-const FFCPUResult* ffDetectCPU();
+const FFCPUResult* ffDetectCPU(const FFinstance* instance);

 #endif
@@ -1,9 +1,10 @@
 #include "cpu.h"
-#include "common/settings.h"
+#include "common/sysctl.h"
+#include "detection/temps/temps_apple.h"

 static double getFrequency(const char* propName)
 {
-    double herz = (double) ffSettingsGetAppleInt64(propName, 0);
+    double herz = (double) ffSysctlGetInt64(propName, 0);
    if(herz <= 0.0)
        return herz;

@@ -12,31 +13,64 @@ static double getFrequency(const char* propName)
    return herz / 1000.0; //to GHz
 }

-void ffDetectCPUImpl(FFCPUResult* cpu)
+static double detectCpuTemp(const FFstrbuf* cpuName)
 {
-    ffStrbufInit(&cpu->name);
-    ffSettingsGetAppleProperty("machdep.cpu.brand_string", &cpu->name);
+    FFlist temps;
+    ffListInit(&temps, sizeof(FFTempValue));

-    ffStrbufInit(&cpu->vendor);
-    ffSettingsGetAppleProperty("machdep.cpu.vendor", &cpu->vendor);
+    if(ffStrbufStartsWithS(cpuName, "Apple M1"))
+        ffDetectCoreTemps(FF_TEMP_CPU_M1X, &temps);
+    else if(ffStrbufStartsWithS(cpuName, "Apple M2"))
+        ffDetectCoreTemps(FF_TEMP_CPU_M2X, &temps);
+    else //TODO: PPC?
+        ffDetectCoreTemps(FF_TEMP_CPU_X64, &temps);

-    cpu->coresPhysical = (uint16_t) ffSettingsGetAppleInt("hw.physicalcpu_max", 1);
-    if(cpu->coresPhysical == 1)
-        cpu->coresPhysical = (uint16_t) ffSettingsGetAppleInt("hw.physicalcpu", 1);
+    if(temps.length == 0)
+        return FF_CPU_TEMP_UNSET;

-    cpu->coresLogical = (uint16_t) ffSettingsGetAppleInt("hw.logicalcpu_max", 1);
-    if(cpu->coresLogical == 1)
-        cpu->coresLogical = (uint16_t) ffSettingsGetAppleInt("hw.ncpu", 1);
-
-    cpu->coresOnline = (uint16_t) ffSettingsGetAppleInt("hw.logicalcpu", 1);
-    if(cpu->coresOnline == 1)
-        cpu->coresOnline = (uint16_t) ffSettingsGetAppleInt("hw.activecpu", 1);
-
-    cpu->frequencyMin = getFrequency("hw.cpufrequency_min");
-    cpu->frequencyMax = getFrequency("hw.cpufrequency_max");
-    if(cpu->frequencyMax == 0.0)
-        cpu->frequencyMax = getFrequency("hw.cpufrequency");
-
-    //TODO find a way to detect this
-    cpu->temperature = FF_CPU_TEMP_UNSET;
+    double result = 0;
+    for(uint32_t i = 0; i < temps.length; ++i)
+    {
+        FFTempValue* tempValue = (FFTempValue*)ffListGet(&temps, i);
+        result += tempValue->value;
+        //TODO: do we really need this?
+        ffStrbufDestroy(&tempValue->name);
+        ffStrbufDestroy(&tempValue->deviceClass);
+    }
+    result /= temps.length;
+    ffListDestroy(&temps);
+    return result;
+}
+
+void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu, bool cached)
+{
+    FF_UNUSED(instance);
+
+    if(!cached)
+    {
+        ffSysctlGetString("machdep.cpu.brand_string", &cpu->name);
+        ffSysctlGetString("machdep.cpu.vendor", &cpu->vendor);
+
+        cpu->coresPhysical = (uint16_t) ffSysctlGetInt("hw.physicalcpu_max", 1);
+        if(cpu->coresPhysical == 1)
+            cpu->coresPhysical = (uint16_t) ffSysctlGetInt("hw.physicalcpu", 1);
+
+        cpu->coresLogical = (uint16_t) ffSysctlGetInt("hw.logicalcpu_max", 1);
+        if(cpu->coresLogical == 1)
+            cpu->coresLogical = (uint16_t) ffSysctlGetInt("hw.ncpu", 1);
+
+        cpu->coresOnline = (uint16_t) ffSysctlGetInt("hw.logicalcpu", 1);
+        if(cpu->coresOnline == 1)
+            cpu->coresOnline = (uint16_t) ffSysctlGetInt("hw.activecpu", 1);
+
+        cpu->frequencyMin = getFrequency("hw.cpufrequency_min");
+        cpu->frequencyMax = getFrequency("hw.cpufrequency_max");
+        if(cpu->frequencyMax == 0.0)
+            cpu->frequencyMax = getFrequency("hw.cpufrequency");
+    }
+
+    if (instance->config.cpuTemp)
+        cpu->temperature = detectCpuTemp(&cpu->name);
+    else
+        cpu->temperature = FF_CPU_TEMP_UNSET;
 }
@@ -0,0 +1,21 @@
+#include "cpu.h"
+#include "common/sysctl.h"
+
+void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu, bool cached)
+{
+    FF_UNUSED(instance);
+
+    cpu->temperature = FF_CPU_TEMP_UNSET;
+
+    if(cached)
+        return;
+
+    ffSysctlGetString("hw.model", &cpu->name);
+
+    cpu->coresPhysical = (uint16_t) ffSysctlGetInt("hw.ncpu", 1);
+    cpu->coresLogical = cpu->coresPhysical;
+    cpu->coresOnline = cpu->coresPhysical;
+
+    cpu->frequencyMin = ffSysctlGetInt("hw.clockrate", 0) / 1000.0;
+    cpu->frequencyMax = cpu->frequencyMin;
+}
@@ -1,7 +1,7 @@
 #include "cpu.h"
 #include "common/io.h"
 #include "common/properties.h"
-#include "detection/temps.h"
+#include "detection/temps/temps_linux.h"

 #include <stdlib.h>
 #include <unistd.h>
@@ -60,9 +60,9 @@ static double getFrequency(const char* info, const char* scaling)
    return getGHz(scaling);
 }

-static double detectCPUTemp()
+static double detectCPUTemp(const FFinstance* instance)
 {
-    const FFTempsResult *temps = ffDetectTemps();
+    const FFTempsResult* temps = ffDetectTemps(instance);

    for(uint32_t i = 0; i < temps->values.length; i++)
    {
@@ -78,10 +78,15 @@ static double detectCPUTemp()
    return FF_CPU_TEMP_UNSET;
 }

-void ffDetectCPUImpl(FFCPUResult* cpu)
+void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu, bool cached)
 {
-    ffStrbufInit(&cpu->name);
-    ffStrbufInit(&cpu->vendor);
+    if(instance->config.cpuTemp)
+        cpu->temperature = detectCPUTemp(instance);
+    else
+        cpu->temperature = FF_CPU_TEMP_UNSET;
+
+    if(cached)
+        return;

    FFstrbuf physicalCoresBuffer;
    ffStrbufInit(&physicalCoresBuffer);
@@ -89,14 +94,18 @@ void ffDetectCPUImpl(FFCPUResult* cpu)
    parseCpuInfo(cpu, &physicalCoresBuffer);

    cpu->coresPhysical = ffStrbufToUInt16(&physicalCoresBuffer, 1);
-    cpu->coresLogical = (uint16_t) get_nprocs_conf();
-    cpu->coresOnline = (uint16_t) get_nprocs();
+
+    #ifdef FF_HAVE_SYSINFO_H
+        cpu->coresLogical = (uint16_t) get_nprocs_conf();
+        cpu->coresOnline = (uint16_t) get_nprocs();
+    #else
+        cpu->coresLogical = 1;
+        cpu->coresOnline = 1;
+    #endif

    #define BP "/sys/devices/system/cpu/cpufreq/policy0/"
    cpu->frequencyMin = getFrequency(BP"cpuinfo_min_freq", BP"scaling_min_freq");
    cpu->frequencyMax = getFrequency(BP"cpuinfo_max_freq", BP"scaling_max_freq");

-    cpu->temperature = detectCPUTemp();
-
    ffStrbufDestroy(&physicalCoresBuffer);
 }
@@ -0,0 +1,51 @@
+extern "C" {
+#include "cpu.h"
+}
+#include "util/windows/wmi.hpp"
+
+extern "C"
+void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu, bool cached)
+{
+    FF_UNUSED(instance);
+
+    cpu->temperature = FF_CPU_TEMP_UNSET;
+
+    if(cached)
+        return;
+
+    cpu->coresPhysical = cpu->coresLogical = cpu->coresOnline = 0;
+    ffStrbufInit(&cpu->name);
+    ffStrbufInit(&cpu->vendor);
+
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT Name, Manufacturer, NumberOfCores, NumberOfLogicalProcessors, ThreadCount, CurrentClockSpeed, MaxClockSpeed FROM Win32_Processor WHERE ProcessorType = 3", nullptr);
+    if(!pEnumerator)
+        return;
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    if(FAILED(pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn)) || uReturn == 0)
+    {
+        pEnumerator->Release();
+        return;
+    }
+
+    ffGetWmiObjString(pclsObj, L"Name", &cpu->name);
+    ffGetWmiObjString(pclsObj, L"Manufacturer", &cpu->vendor);
+
+    uint64_t value;
+
+    ffGetWmiObjUnsigned(pclsObj, L"NumberOfCores", &value);
+    cpu->coresPhysical = (uint16_t)value;
+    ffGetWmiObjUnsigned(pclsObj, L"NumberOfLogicalProcessors", &value);
+    cpu->coresLogical = (uint16_t)value;
+    ffGetWmiObjUnsigned(pclsObj, L"ThreadCount", &value);
+    cpu->coresOnline = (uint16_t)value;
+    ffGetWmiObjUnsigned(pclsObj, L"CurrentClockSpeed", &value); //There's no MinClockSpeed in Win32_Processor
+    cpu->frequencyMin = (double)value / 1000.0;
+    ffGetWmiObjUnsigned(pclsObj, L"MaxClockSpeed", &value);
+    cpu->frequencyMax = (double)value / 1000.0;
+
+    pclsObj->Release();
+    pEnumerator->Release();
+}
@@ -0,0 +1,58 @@
+#include "fastfetch.h"
+#include "cpuUsage.h"
+
+#if FF_DETECTION_CPUUSAGE_NOWAIT
+
+const char* ffGetCpuUsageResultNoWait(double* result);
+
+void ffPrepareCPUUsage() {}
+
+const char* ffGetCpuUsageResult(double* result) {
+    return ffGetCpuUsageResultNoWait(result);
+}
+
+#else //FF_DETECTION_CPUUSAGE_NOWAIT
+
+#include "common/time.h"
+
+#include <stdint.h>
+
+// We need to use uint64_t because sizeof(long) == 4 on Windows
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll);
+
+static uint64_t inUseAll1, totalAll1, startTime;
+
+void ffPrepareCPUUsage()
+{
+    startTime = ffTimeGetTick();
+    ffGetCpuUsageInfo(&inUseAll1, &totalAll1);
+}
+
+const char* ffGetCpuUsageResult(double* result)
+{
+    const char* error = NULL;
+    if(startTime == 0)
+    {
+        error = ffGetCpuUsageInfo(&inUseAll1, &totalAll1);
+        if(error)
+            return error;
+        ffTimeSleep(1000);
+    }
+    else
+    {
+        uint64_t duration = ffTimeGetTick() - startTime;
+        if(duration < 1000)
+            ffTimeSleep(1000 - (uint32_t) duration);
+    }
+
+    uint64_t inUseAll2, totalAll2;
+    error = ffGetCpuUsageInfo(&inUseAll2, &totalAll2);
+    if(error)
+        return error;
+
+    *result = (double)(inUseAll2 - inUseAll1) / (double)(totalAll2 - totalAll1) * 100;
+
+    return NULL;
+}
+
+#endif //FF_DETECTION_CPUUSAGE_NOWAIT
@@ -0,0 +1,13 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_cpu_cpuUsage
+#define FF_INCLUDED_detection_cpu_cpuUsage
+
+#if defined(_WIN32) || defined(__MSYS__)
+    // Disabled by default because the result does need some time to generate
+    #define FF_DETECTION_CPUUSAGE_NOWAIT 0
+#endif
+
+const char* ffGetCpuUsageResult(double* result);
+
+#endif
@@ -0,0 +1,28 @@
+#include "fastfetch.h"
+#include "cpuUsage.h"
+
+#include <mach/processor_info.h>
+#include <mach/mach_host.h>
+
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll)
+{
+    natural_t numCPUs = 0U;
+    processor_info_array_t cpuInfo;
+    mach_msg_type_number_t numCpuInfo;
+    *inUseAll = *totalAll = 0;
+
+    if (host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numCPUs, &cpuInfo, &numCpuInfo) != KERN_SUCCESS)
+        return "host_processor_info() failed";
+    if (numCPUs * CPU_STATE_MAX != numCpuInfo)
+        return "Unexpected host_processor_info() result";
+
+    for (natural_t i = 0U; i < numCPUs; ++i) {
+        integer_t inUse = cpuInfo[CPU_STATE_MAX * i + CPU_STATE_USER]
+            + cpuInfo[CPU_STATE_MAX * i + CPU_STATE_SYSTEM]
+            + cpuInfo[CPU_STATE_MAX * i + CPU_STATE_NICE];
+        integer_t total = inUse + cpuInfo[CPU_STATE_MAX * i + CPU_STATE_IDLE];
+        *inUseAll += (uint64_t)inUse;
+        *totalAll += (uint64_t)total;
+    }
+    return NULL;
+}
@@ -0,0 +1,26 @@
+#include "fastfetch.h"
+#include "cpuUsage.h"
+
+#include <stdio.h>
+#include <inttypes.h>
+
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll)
+{
+    uint64_t user = 0, nice = 0, system = 0, idle = 0, iowait = 0, irq = 0, softirq = 0;
+
+    FILE* procStat = fopen("/proc/stat", "r");
+    if(procStat == NULL)
+        return "fopen(\"""/proc/stat\", \"r\") == NULL";
+
+    if (fscanf(procStat, "cpu%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64, &user, &nice, &system, &idle, &iowait, &irq, &softirq) < 0)
+    {
+        fclose(procStat);
+        return "fscanf() failed";
+    }
+    *inUseAll = user + nice + system;
+    *totalAll = *inUseAll + idle + iowait + irq + softirq;
+
+    fclose(procStat);
+
+    return NULL;
+}
@@ -0,0 +1,26 @@
+extern "C" {
+#include "cpuUsage.h"
+}
+#include "util/windows/wmi.hpp"
+
+extern "C" const char* ffGetCpuUsageResultNoWait(double* result)
+{
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT LoadPercentage FROM Win32_Processor", nullptr);
+    if(!pEnumerator)
+        return "Query WMI service failed";
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    if(FAILED(pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn)) || uReturn == 0)
+    {
+        pEnumerator->Release();
+        return "No WMI result returned";
+    }
+
+    ffGetWmiObjReal(pclsObj, L"LoadPercentage", result);
+
+    pclsObj->Release();
+    pEnumerator->Release();
+    return NULL;
+}
@@ -0,0 +1,20 @@
+#include "fastfetch.h"
+#include "cpuUsage.h"
+
+#define WIN32_LEAN_AND_MEAN 1
+#include <Windows.h>
+
+static inline uint64_t fileTimeToUint64(const FILETIME* ft) {
+    return (((uint64_t)ft->dwHighDateTime) << 32) | ((uint64_t)ft->dwLowDateTime);
+}
+
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll)
+{
+    FILETIME idleTime, kernelTime, userTime;
+    if(GetSystemTimes(&idleTime, &kernelTime, &userTime) == 0)
+        return "GetSystemTimes() failed";
+
+    *inUseAll = fileTimeToUint64(&userTime) + fileTimeToUint64(&kernelTime);
+    *totalAll = *inUseAll + fileTimeToUint64(&idleTime);
+    return NULL;
+}
@@ -27,21 +27,21 @@ const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance)
    result.yearShort = (uint8_t) (result.year % 100);
    result.month = (uint8_t) (tm->tm_mon + 1);

-    ffStrbufInit(&result.monthPretty);
+    ffStrbufInitA(&result.monthPretty, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.monthPretty.length = (uint32_t) strftime(result.monthPretty.chars, ffStrbufGetFree(&result.monthPretty), "%m", tm);

-    ffStrbufInit(&result.monthName);
+    ffStrbufInitA(&result.monthName, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.monthName.length = (uint32_t) strftime(result.monthName.chars, ffStrbufGetFree(&result.monthName), "%B", tm);

-    ffStrbufInit(&result.monthNameShort);
+    ffStrbufInitA(&result.monthNameShort, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.monthNameShort.length = (uint32_t) strftime(result.monthNameShort.chars, ffStrbufGetFree(&result.monthNameShort), "%b", tm);

    result.week = (uint8_t) (tm->tm_yday / 7 + 1);

-    ffStrbufInit(&result.weekday);
+    ffStrbufInitA(&result.weekday, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.weekday.length = (uint32_t) strftime(result.weekday.chars, ffStrbufGetFree(&result.weekday), "%A", tm);

-    ffStrbufInit(&result.weekdayShort);
+    ffStrbufInitA(&result.weekdayShort, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.weekdayShort.length = (uint32_t) strftime(result.weekdayShort.chars, ffStrbufGetFree(&result.weekdayShort), "%a", tm);

    result.dayInYear = (uint8_t) (tm->tm_yday + 1);
@@ -50,22 +50,22 @@ const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance)

    result.hour = (uint8_t) tm->tm_hour;

-    ffStrbufInit(&result.hourPretty);
+    ffStrbufInitA(&result.hourPretty, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.hourPretty.length = (uint32_t) strftime(result.hourPretty.chars, ffStrbufGetFree(&result.hourPretty), "%H", tm);

    result.hour12 = (uint8_t) (result.hour % 12);

-    ffStrbufInit(&result.hour12Pretty);
+    ffStrbufInitA(&result.hour12Pretty, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.hour12Pretty.length = (uint32_t) strftime(result.hour12Pretty.chars, ffStrbufGetFree(&result.hour12Pretty), "%I", tm);

    result.minute = (uint8_t) tm->tm_min;

-    ffStrbufInit(&result.minutePretty);
+    ffStrbufInitA(&result.minutePretty, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.minutePretty.length = (uint32_t) strftime(result.minutePretty.chars, ffStrbufGetFree(&result.minutePretty), "%M", tm);

    result.second = (uint8_t) tm->tm_sec;

-    ffStrbufInit(&result.secondPretty);
+    ffStrbufInitA(&result.secondPretty, FASTFETCH_STRBUF_DEFAULT_ALLOC);
    result.secondPretty.length = (uint32_t) strftime(result.secondPretty.chars, ffStrbufGetFree(&result.secondPretty), "%S", tm);

    pthread_mutex_unlock(&mutex);
@@ -0,0 +1,56 @@
+#include "fastfetch.h"
+#include "disk.h"
+
+#include <sys/statvfs.h>
+
+void ffDetectDiskWithStatvfs(const char* folderPath, struct statvfs* fs, FFDiskResult* result)
+{
+    ffStrbufInitS(&result->path, folderPath);
+    result->used = result->total = 0;
+    ffStrbufInit(&result->error);
+
+    struct statvfs newFs;
+
+    if(fs == NULL)
+    {
+        fs = &newFs;
+        int ret = statvfs(folderPath, fs);
+        if(ret != 0)
+        {
+            ffStrbufAppendF(&result->error, "statvfs(\"%s\", &fs) != 0 (%i)", folderPath, ret);
+            return;
+        }
+    }
+
+    result->total = fs->f_blocks * fs->f_frsize;
+
+    if(result->total == 0)
+    {
+        ffStrbufAppendF(&result->error, "statvfs for %s returned size 0", folderPath);
+        return;
+    }
+
+    result->used = result->total - (fs->f_bavail * fs->f_frsize);
+    result->files = (uint32_t) (fs->f_files - fs->f_ffree);
+    result->removable = false; //To be set at other place
+}
+
+bool ffDiskDetectDiskFolders(FFinstance* instance, FFlist* folders)
+{
+    ffStrbufTrim(&instance->config.diskFolders, ':');
+    if(instance->config.diskFolders.length == 0)
+        return false;
+
+    uint32_t startIndex = 0;
+    while(startIndex < instance->config.diskFolders.length)
+    {
+        uint32_t colonIndex = ffStrbufNextIndexC(&instance->config.diskFolders, startIndex, ':');
+        instance->config.diskFolders.chars[colonIndex] = '\0';
+
+        ffDetectDiskWithStatvfs(instance->config.diskFolders.chars + startIndex, NULL, (FFDiskResult*)ffListAdd(folders));
+
+        startIndex = colonIndex + 1;
+    }
+
+    return true;
+}
@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_disk_disk
+#define FF_INCLUDED_detection_disk_disk
+
+#include "fastfetch.h"
+
+typedef struct FFDiskResult
+{
+    FFstrbuf path;
+    uint64_t used;
+    uint64_t total;
+    uint32_t files;
+    bool removable;
+    FFstrbuf error;
+} FFDiskResult;
+
+const char* ffDiskAutodetectFolders(FFinstance* instance, FFlist* folders);
+bool ffDiskDetectDiskFolders(FFinstance* instance, FFlist* folders);
+
+#endif
@@ -0,0 +1,29 @@
+#include "disk.h"
+
+#import <Foundation/Foundation.h>
+
+void ffDetectDiskWithStatvfs(const char* folderPath, struct statvfs* fs, FFDiskResult* result);
+
+const char* ffDiskAutodetectFolders(FFinstance* instance, FFlist* folders)
+{
+    NSArray *keys = [NSArray arrayWithObjects:NSURLVolumeNameKey, nil];
+    NSArray *urls = [NSFileManager.defaultManager mountedVolumeURLsIncludingResourceValuesForKeys:keys
+                                                  options:NSVolumeEnumerationSkipHiddenVolumes];
+    if(urls == nil)
+        return "[NSFileManager.defaultManager mountedVolumeURLsIncludingResourceValuesForKeys] failed";
+
+    for (NSURL *url in urls) {
+        NSError *error;
+        NSNumber* removable;
+        if([url getResourceValue:&removable forKey:NSURLVolumeIsRemovableKey error:&error] == NO)
+            continue;
+        if(removable.boolValue && !instance->config.diskRemovable)
+            continue;
+
+        FFDiskResult* folder = (FFDiskResult*)ffListAdd(folders);
+        ffDetectDiskWithStatvfs([url.relativePath cStringUsingEncoding:NSUTF8StringEncoding], NULL, folder);
+        folder->removable = removable.boolValue;
+    }
+
+    return NULL;
+}
@@ -0,0 +1,24 @@
+#include "disk.h"
+
+#include <sys/statvfs.h>
+
+void ffDetectDiskWithStatvfs(const char* folderPath, struct statvfs* fs, FFDiskResult* result);
+
+const char* ffDiskAutodetectFolders(FFinstance* instance, FFlist* folders)
+{
+    FF_UNUSED(instance);
+
+    struct statvfs fsRoot;
+    int rootRet = statvfs(FASTFETCH_TARGET_DIR_ROOT"/", &fsRoot);
+    if(rootRet != 0)
+        return "statvfs(\"/\") failed";
+
+    ffDetectDiskWithStatvfs(FASTFETCH_TARGET_DIR_ROOT"/", &fsRoot, (FFDiskResult*)ffListAdd(folders));
+
+    struct statvfs fsHome;
+    int homeRet = statvfs(FASTFETCH_TARGET_DIR_HOME, &fsHome);
+    if(homeRet == 0 && (fsRoot.f_fsid != fsHome.f_fsid))
+        ffDetectDiskWithStatvfs(FASTFETCH_TARGET_DIR_HOME, &fsHome, (FFDiskResult*)ffListAdd(folders));
+
+    return NULL;
+}
@@ -0,0 +1,66 @@
+#include "disk.h"
+
+#define WIN32_LEAN_AND_MEAN 1
+#include <Windows.h>
+
+static void detectDrive(const char* folderPath, uint32_t pathLen, FFDiskResult* result)
+{
+    ffStrbufInitNS(&result->path, pathLen, folderPath);
+    result->removable = false; //To be set at other place
+    result->files = 0; //Unsupported
+
+    //According to https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getdiskfreespaceexa
+    //GetDiskFreeSpaceExA does not have to specify the root directory on a disk. The function accepts any directory on a disk.
+    uint64_t freeBytes;
+    if(GetDiskFreeSpaceExA(folderPath, NULL, (PULARGE_INTEGER)&result->total, (PULARGE_INTEGER)&freeBytes)) {
+        result->used = result->total - freeBytes;
+        ffStrbufInit(&result->error);
+    }
+    else
+        ffStrbufInitS(&result->error, "GetDiskFreeSpaceExA() failed");
+}
+
+const char* ffDiskAutodetectFolders(FFinstance* instance, FFlist* folders)
+{
+    FF_UNUSED(instance);
+
+    char buf[128]; // "C:\\\0D:\\\0"
+    uint32_t length = GetLogicalDriveStringsA(sizeof(buf) / sizeof(*buf), buf);
+
+    for(size_t i = 0; i < length;)
+    {
+        const char* drive = buf + i;
+        uint32_t driveLen = (uint32_t) strlen(drive);
+        i += driveLen + 1;
+
+        bool removable = GetDriveTypeA(drive) == DRIVE_REMOVABLE;
+        if(removable && !instance->config.diskRemovable)
+            continue;
+
+        FFDiskResult* folder = (FFDiskResult*)ffListAdd(folders);
+        detectDrive(drive, driveLen, folder);
+        folder->removable = removable;
+    }
+
+    return NULL;
+}
+
+bool ffDiskDetectDiskFolders(FFinstance* instance, FFlist* folders)
+{
+    ffStrbufTrim(&instance->config.diskFolders, ';');
+    if(instance->config.diskFolders.length == 0)
+        return false;
+
+    uint32_t startIndex = 0;
+    while(startIndex < instance->config.diskFolders.length)
+    {
+        uint32_t colonIndex = ffStrbufNextIndexC(&instance->config.diskFolders, startIndex, ';');
+        instance->config.diskFolders.chars[colonIndex] = '\0';
+
+        detectDrive(instance->config.diskFolders.chars + startIndex, colonIndex - startIndex, (FFDiskResult*)ffListAdd(folders));
+
+        startIndex = colonIndex + 1;
+    }
+
+    return true;
+}
@@ -1,10 +1,9 @@
 #include "displayserver.h"
-#include "common/library.h"
+#include "common/sysctl.h"

 #include <stdlib.h>
 #include <ctype.h>
 #include <string.h>
-#include <sys/sysctl.h>
 #include <ApplicationServices/ApplicationServices.h>

 //Resolution code heavily inspired by displayplacer <3
@@ -60,19 +59,10 @@ static void detectWM(FFDisplayServerResult* ds)
    u_int requestLength = sizeof(request) / sizeof(*request);

    size_t length = 0;
-    if(sysctl(request, requestLength, NULL, &length, NULL, 0) != 0)
-        return;
-
-    struct kinfo_proc* processes = malloc(length);
+    struct kinfo_proc* processes = ffSysctlGetData(request, requestLength, &length);
    if(processes == NULL)
        return;

-    if(sysctl(request, requestLength, processes, &length, NULL, 0) != 0)
-    {
-        free(processes);
-        return;
-    }
-
    for(size_t i = 0; i < length / sizeof(struct kinfo_proc); i++)
    {
        const char* comm = processes[i].kp_proc.p_comm;
@@ -0,0 +1,48 @@
+#include "displayserver.h"
+#include "detection/os/os.h"
+
+#include <dwmapi.h>
+#include <WinUser.h>
+
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+{
+    FF_UNUSED(instance);
+
+    BOOL enabled;
+    if(SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled == TRUE)
+    {
+        ffStrbufInitS(&ds->wmProcessName, "dwm.exe");
+        ffStrbufInitS(&ds->wmPrettyName, "Desktop Window Manager");
+    }
+    else
+    {
+        ffStrbufInitS(&ds->wmProcessName, "internal");
+        ffStrbufInitS(&ds->wmPrettyName, "internal");
+    }
+    ffStrbufInit(&ds->wmProtocolName);
+    ffStrbufInit(&ds->deProcessName);
+    ffStrbufInit(&ds->dePrettyName);
+    ffStrbufInit(&ds->deVersion);
+    ffListInit(&ds->resolutions, sizeof(FFResolutionResult));
+
+    DISPLAY_DEVICEW displayDevice = { .cb = sizeof(DISPLAY_DEVICEW) };
+    for(DWORD devNum = 0; EnumDisplayDevicesW(NULL, devNum, &displayDevice, 0) != 0; ++devNum)
+    {
+        if(!(displayDevice.StateFlags & DISPLAY_DEVICE_ACTIVE))
+            continue;
+        DEVMODEW devMode = { .dmSize = sizeof(DEVMODEW) };
+        if(EnumDisplaySettingsW(displayDevice.DeviceName, ENUM_CURRENT_SETTINGS, &devMode) == 0)
+            continue;
+
+        ffdsAppendResolution(ds, devMode.dmPelsWidth, devMode.dmPelsHeight, devMode.dmDisplayFrequency);
+    }
+
+    //https://github.com/hykilpikonna/hyfetch/blob/master/neofetch#L2067
+    const FFOSResult* os = ffDetectOS(instance);
+    if(ffStrbufCompS(&os->version, "11") == 0 || ffStrbufCompS(&os->version, "10") == 0)
+        ffStrbufSetS(&ds->dePrettyName, "Fluent");
+    else if(ffStrbufCompS(&os->version, "8") == 0 || ffStrbufStartsWithS(&os->version, "8."))
+        ffStrbufSetS(&ds->dePrettyName, "Metro");
+    else
+        ffStrbufSetS(&ds->dePrettyName, "Aero");
+}
@@ -34,7 +34,7 @@ static void parseDRM(FFDisplayServerResult* result)
        resolution->height = 0;
        resolution->refreshRate = 0;

-        int scanned = fscanf(modeFile, "%ix%i", &resolution->width, &resolution->height);
+        int scanned = fscanf(modeFile, "%ux%u", &resolution->width, &resolution->height);
        if(scanned < 2 || resolution->width == 0 || resolution->height == 0)
            --result->resolutions.length;

@@ -1,5 +1,3 @@
-#define _GNU_SOURCE //required for struct ucred
-
 #include "displayserver_linux.h"

 #include <stdlib.h>
@@ -17,9 +15,11 @@ typedef struct WaylandData
    FFlist* results;
    FF_LIBRARY_SYMBOL(wl_proxy_marshal_constructor_versioned)
    FF_LIBRARY_SYMBOL(wl_proxy_add_listener)
+    FF_LIBRARY_SYMBOL(wl_proxy_destroy)
    const struct wl_interface* ffwl_output_interface;
 } WaylandData;

+#ifndef __FreeBSD__
 static void waylandDetectWM(int fd, FFDisplayServerResult* result)
 {
    struct ucred ucred;
@@ -35,6 +35,12 @@ static void waylandDetectWM(int fd, FFDisplayServerResult* result)
    ffStrbufSubstrAfterLastC(&result->wmProcessName, '/'); //Trim the path
    ffStrbufDestroy(&procPath);
 }
+#else
+static void waylandDetectWM(int fd, FFDisplayServerResult* result)
+{
+    FF_UNUSED(fd, result);
+}
+#endif

 static void stubListener(void* data, ...)
 {
@@ -43,10 +49,10 @@ static void stubListener(void* data, ...)

 static void waylandOutputModeListener(void* data, struct wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refreshRate)
 {
-    FF_UNUSED(output);
-
    WaylandData* wldata = data;

+    wldata->ffwl_proxy_destroy((struct wl_proxy*) output);
+
    if(!(flags & WL_OUTPUT_MODE_CURRENT) || width <= 0 || height <= 0)
        return;

@@ -96,7 +102,7 @@ static void waylandGlobalAddListener(void* data, struct wl_registry* registry, u

 bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(wayland, instance->config.libWayland, false, "libwayland-client.so", 1)
+    FF_LIBRARY_LOAD(wayland, &instance->config.libWayland, false, "libwayland-client.so", 1)

    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_connect, false)
    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_get_fd, false)
@@ -110,6 +116,7 @@ bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)

    FF_LIBRARY_LOAD_SYMBOL_VAR(wayland, data, wl_proxy_marshal_constructor_versioned, false)
    FF_LIBRARY_LOAD_SYMBOL_VAR(wayland, data, wl_proxy_add_listener, false)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(wayland, data, wl_proxy_destroy, false)
    FF_LIBRARY_LOAD_SYMBOL_VAR(wayland, data, wl_output_interface, false)

    struct wl_display* display = ffwl_display_connect(NULL);
@@ -140,7 +147,8 @@ bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)
    ffwl_display_dispatch(display);
    ffwl_display_roundtrip(display);

-    ffwl_display_disconnect(display); //This will also destroy our wl_registry and wl_output proxies
+    data.ffwl_proxy_destroy(registry);
+    ffwl_display_disconnect(display);
    dlclose(wayland);

    //We successfully connected to wayland and detected the resolution.
@@ -129,6 +129,10 @@ static void getKDE(FFDisplayServerResult* result)
        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/wayland-sessions/plasmawayland.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
    if(result->deVersion.length == 0)
        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/wayland-sessions/plasmawayland5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/local/share/xsessions/plasma.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/local/share/wayland-sessions/plasmawayland.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);

    applyBetterWM(result, getenv("KDEWM"));
 }
@@ -91,7 +91,7 @@ static void xcbDetectWMfromEWMH(XcbPropertyData* data, xcb_connection_t* connect

 void ffdsConnectXcb(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcb, instance->config.libXcb, , "libxcb.so", 2)
+    FF_LIBRARY_LOAD(xcb, &instance->config.libXcb, , "libxcb.so", 2)
    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_connect,)
    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_get_setup,)
    FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_setup_roots_iterator,)
@@ -326,7 +326,7 @@ static void xcbRandrHandleScreen(XcbRandrData* data, xcb_screen_t* screen)

 void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcbRandr, instance->config.libXcbRandr, , "libxcb-randr.so", 1)
+    FF_LIBRARY_LOAD(xcbRandr, &instance->config.libXcbRandr, , "libxcb-randr.so", 1)
    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_connect,)
    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_get_setup,)
    FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_setup_roots_iterator,)
@@ -55,7 +55,7 @@ static void x11DetectWMFromEWMH(X11PropertyData* data, Display* display, FFDispl

 void ffdsConnectXlib(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(x11, instance->config.libX11, , "libX11.so", 7, "libX11-xcb.so", 2)
+    FF_LIBRARY_LOAD(x11, &instance->config.libX11, , "libX11.so", 7, "libX11-xcb.so", 2)
    FF_LIBRARY_LOAD_SYMBOL(x11, XOpenDisplay,)
    FF_LIBRARY_LOAD_SYMBOL(x11, XCloseDisplay,)

@@ -259,7 +259,7 @@ static void xrandrHandleScreen(XrandrData* data, Screen* screen)

 void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xrandr, instance->config.libXrandr, , "libXrandr.so", 3)
+    FF_LIBRARY_LOAD(xrandr, &instance->config.libXrandr, , "libXrandr.so", 3)

    FF_LIBRARY_LOAD_SYMBOL(xrandr, XOpenDisplay,)
    FF_LIBRARY_LOAD_SYMBOL(xrandr, XCloseDisplay,)
@@ -0,0 +1,32 @@
+#include "font.h"
+#include "detection/internal.h"
+
+void ffDetectFontImpl(const FFinstance* instance, FFFontResult* font);
+
+static void detectFont(const FFinstance* instance, FFFontResult* font)
+{
+    ffStrbufInit(&font->error);
+
+    for(uint32_t i = 0; i < FF_DETECT_FONT_NUM_FONTS; ++i)
+        ffStrbufInit(&font->fonts[i]);
+
+    ffDetectFontImpl(instance, font);
+
+    if(font->error.length > 0)
+        return;
+
+    for(uint32_t i = 0; i < FF_DETECT_FONT_NUM_FONTS; ++i)
+    {
+        if(font->fonts[i].length > 0)
+            return;
+    }
+
+    ffStrbufAppendS(&font->error, "No fonts found");
+}
+
+const FFFontResult* ffDetectFont(const FFinstance* instance)
+{
+    FF_DETECTION_INTERNAL_GUARD(FFFontResult,
+        detectFont(instance, &result);
+    );
+}
@@ -0,0 +1,25 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_font_font
+#define FF_INCLUDED_detection_font_font
+
+#include "fastfetch.h"
+
+#define FF_DETECT_FONT_NUM_FONTS 4
+
+typedef struct FFFontResult
+{
+    FFstrbuf error;
+
+    /**
+     * Linux / BSD: QT,      GTK2,  GTK3,      GTK4
+     * MacOS:       System,  User,  Monospace, Application
+     * Windows:     Desktop, Unset, Unset,     Unset
+     * Other:       Unset,   Unset, Unset,     Unset
+     */
+    FFstrbuf fonts[FF_DETECT_FONT_NUM_FONTS];
+} FFFontResult;
+
+const FFFontResult* ffDetectFont(const FFinstance* instance);
+
+#endif
@@ -0,0 +1,23 @@
+#include "common/font.h"
+#include "common/io.h"
+#include "util/apple/cf_helpers.h"
+#include "font.h"
+
+#import <AppKit/AppKit.h>
+
+static void detectFontForType(CTFontUIFontType uiType, FFstrbuf* font)
+{
+    CTFontRef ctFont = CTFontCreateUIFontForLanguage(uiType, 12, NULL);
+    ffCfStrGetString(CTFontCopyFamilyName(ctFont), font);
+}
+
+void ffDetectFontImpl(const FFinstance* instance, FFFontResult* result)
+{
+    FF_UNUSED(instance);
+    ffSuppressIO(true);
+    detectFontForType(kCTFontUIFontSystem, &result->fonts[0]);
+    detectFontForType(kCTFontUIFontUser, &result->fonts[1]);
+    detectFontForType(kCTFontUIFontUserFixedPitch, &result->fonts[2]);
+    detectFontForType(kCTFontUIFontApplication, &result->fonts[3]);
+    ffSuppressIO(false);
+}
@@ -0,0 +1,27 @@
+#include "detection/qt.h"
+#include "detection/gtk.h"
+#include "common/font.h"
+#include "font.h"
+
+void ffDetectFontImpl(const FFinstance* instance, FFFontResult* result)
+{
+    FFfont qt;
+    ffFontInitQt(&qt, ffDetectQt(instance)->font.chars);
+    ffStrbufAppend(&result->fonts[0], &qt.pretty);
+    ffFontDestroy(&qt);
+
+    FFfont gtk2;
+    ffFontInitPango(&gtk2, ffDetectGTK2(instance)->font.chars);
+    ffStrbufAppend(&result->fonts[1], &gtk2.pretty);
+    ffFontDestroy(&gtk2);
+
+    FFfont gtk3;
+    ffFontInitPango(&gtk3, ffDetectGTK3(instance)->font.chars);
+    ffStrbufAppend(&result->fonts[2], &gtk3.pretty);
+    ffFontDestroy(&gtk3);
+
+    FFfont gtk4;
+    ffFontInitPango(&gtk4, ffDetectGTK4(instance)->font.chars);
+    ffStrbufAppend(&result->fonts[3], &gtk4.pretty);
+    ffFontDestroy(&gtk4);
+}
@@ -0,0 +1,8 @@
+#include "fastfetch.h"
+#include "font.h"
+
+void ffDetectFontImpl(const FFinstance* instance, FFFontResult* result)
+{
+    FF_UNUSED(instance);
+    ffStrbufAppendS(&result->error, "Not supported on this platform");
+}
@@ -0,0 +1,44 @@
+extern "C" {
+#include "font.h"
+#include "common/font.h"
+}
+#include "util/windows/wmi.hpp"
+
+#include <wchar.h>
+
+extern "C"
+void ffDetectFontImpl(const FFinstance* instance, FFFontResult* result)
+{
+    wchar_t query[256] = {};
+    swprintf(query, 256, L"SELECT IconTitleFaceName, IconTitleSize FROM Win32_Desktop WHERE Name LIKE '%%\\\\%s'", instance->state.passwd->pw_name);
+
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(query, &result->error);
+    if(!pEnumerator)
+        return;
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
+
+    if(uReturn == 0)
+    {
+        ffStrbufInitS(&result->error, "No WMI result returned");
+        pEnumerator->Release();
+        return;
+    }
+
+    FFstrbuf fontName;
+    ffStrbufInit(&fontName);
+    ffGetWmiObjString(pclsObj, L"IconTitleFaceName", &fontName);
+
+    uint64_t fontSize;
+    ffGetWmiObjUnsigned(pclsObj, L"IconTitleSize", &fontSize);
+
+    ffStrbufAppendF(&result->fonts[0], "%*s (%upt)", fontName.length, fontName.chars, (unsigned)fontSize);
+
+    ffStrbufDestroy(&fontName);
+
+    pclsObj->Release();
+    pEnumerator->Release();
+}
@@ -6,6 +6,7 @@
 #include "fastfetch.h"

 #define FF_GPU_TEMP_UNSET (0/0.0)
+#define FF_GPU_CORE_COUNT_UNSET -1

 typedef struct FFGPUResult
 {
@@ -13,6 +14,7 @@ typedef struct FFGPUResult
    FFstrbuf name;
    FFstrbuf driver;
    double temperature;
+    int coreCount;
 } FFGPUResult;

 const FFlist* ffDetectGPU(const FFinstance* instance);
@@ -1,6 +0,0 @@
-#include "gpu.h"
-
-void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
-{
-    FF_UNUSED(gpus, instance);
-}
@@ -1,33 +1,52 @@
 #include "gpu.h"
 #include "common/library.h"
 #include "detection/cpu/cpu.h"
+#include "detection/temps/temps_apple.h"
+#include "util/apple/cf_helpers.h"

-#include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/graphics/IOGraphicsLib.h>

-void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+static double detectGpuTemp(const FFstrbuf* gpuName)
+{
+    FFlist temps;
+    ffListInit(&temps, sizeof(FFTempValue));
+
+    if(ffStrbufStartsWithS(gpuName, "Apple M1"))
+        ffDetectCoreTemps(FF_TEMP_GPU_M1X, &temps);
+    else if(ffStrbufStartsWithS(gpuName, "Apple M2"))
+        ffDetectCoreTemps(FF_TEMP_GPU_M2X, &temps);
+    else if(ffStrbufStartsWithS(gpuName, "Intel"))
+        ffDetectCoreTemps(FF_TEMP_GPU_INTEL, &temps);
+    else if(ffStrbufStartsWithS(gpuName, "Radeon") || ffStrbufStartsWithS(gpuName, "AMD"))
+        ffDetectCoreTemps(FF_TEMP_GPU_AMD, &temps);
+    else
+        ffDetectCoreTemps(FF_TEMP_GPU_UNKNOWN, &temps);
+
+    if(temps.length == 0)
+        return FF_GPU_TEMP_UNSET;
+
+    double result = 0;
+    for(uint32_t i = 0; i < temps.length; ++i)
+    {
+        FFTempValue* tempValue = (FFTempValue*)ffListGet(&temps, i);
+        result += tempValue->value;
+        //TODO: do we really need this?
+        ffStrbufDestroy(&tempValue->name);
+        ffStrbufDestroy(&tempValue->deviceClass);
+    }
+    result /= temps.length;
+    ffListDestroy(&temps);
+    return result;
+}
+
+const char* ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
 {
    FF_UNUSED(instance);

-    const FFCPUResult* cpu = ffDetectCPU();
-    if(ffStrbufStartsWithIgnCaseS(&cpu->name, "Apple M"))
-    {
-        FFGPUResult* gpu = ffListAdd(gpus);
-
-        ffStrbufInit(&gpu->vendor);
-        ffStrbufAppendS(&gpu->vendor, "Apple");
-
-        ffStrbufInit(&gpu->name);
-        ffStrbufAppendS(&gpu->name, cpu->name.chars + 6); //Cut "Apple "
-
-        ffStrbufInitA(&gpu->driver, 0);
-        gpu->temperature = FF_GPU_TEMP_UNSET;
-    }
-
-    CFMutableDictionaryRef matchDict = IOServiceMatching("IOPCIDevice");
+    CFMutableDictionaryRef matchDict = IOServiceMatching(kIOAcceleratorClassName);
    io_iterator_t iterator;
-    if(IOServiceGetMatchingServices(0, matchDict, &iterator) != kIOReturnSuccess)
-        return;
+    if(IOServiceGetMatchingServices(MACH_PORT_NULL, matchDict, &iterator) != kIOReturnSuccess)
+        return "IOServiceGetMatchingServices() failed";

    io_registry_entry_t registryEntry;
    while((registryEntry = IOIteratorNext(iterator)) != 0)
@@ -39,30 +58,43 @@ void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
            continue;
        }

-        CFStringRef key = CFStringCreateWithCStringNoCopy(NULL, "model", kCFStringEncodingASCII, kCFAllocatorNull);
-        CFStringRef model = CFDictionaryGetValue(properties, key);
-        if(model == NULL || CFGetTypeID(model) != CFDataGetTypeID())
-        {
-            CFRelease(properties);
-            IOObjectRelease(registryEntry);
-            continue;
-        }
-
        FFGPUResult* gpu = ffListAdd(gpus);

-        uint32_t modelLength = (uint32_t) CFStringGetLength(model);
-        ffStrbufInitA(&gpu->name, modelLength + 1);
-        CFStringGetCString(model, gpu->name.chars, modelLength + 1, kCFStringEncodingASCII);
-        gpu->name.length = modelLength;
-        gpu->name.chars[gpu->name.length] = '\0';
-
        ffStrbufInitA(&gpu->vendor, 0);
-        ffStrbufInitA(&gpu->driver, 0);
-        gpu->temperature = FF_GPU_TEMP_UNSET;
+
+        ffStrbufInit(&gpu->driver);
+        ffCfDictGetString(properties, CFSTR("CFBundleIdentifier"), &gpu->driver);
+
+        ffStrbufInit(&gpu->name);
+        //IOAccelerator returns model property for Apple Silicon, but not for Intel Iris GPUs.
+        //Still needs testing for AMD's
+        if(ffCfDictGetString(properties, CFSTR("model"), &gpu->name))
+        {
+            CFRelease(properties);
+
+            io_registry_entry_t parentEntry;
+            IORegistryEntryGetParentEntry(registryEntry, kIOServicePlane, &parentEntry);
+            if(IORegistryEntryCreateCFProperties(parentEntry, &properties, kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
+            {
+                IOObjectRelease(parentEntry);
+                IOObjectRelease(registryEntry);
+                continue;
+            }
+            ffCfDictGetString(properties, CFSTR("model"), &gpu->name);
+        }
+
+        if(ffCfDictGetInt(properties, CFSTR("gpu-core-count"), &gpu->coreCount))
+            gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
+
+        if(instance->config.gpuTemp)
+            gpu->temperature = detectGpuTemp(&gpu->name);
+        else
+            gpu->temperature = FF_GPU_TEMP_UNSET;

        CFRelease(properties);
        IOObjectRelease(registryEntry);
    }

    IOObjectRelease(iterator);
+    return NULL;
 }
@@ -9,7 +9,7 @@
 #include "common/library.h"
 #include "common/properties.h"
 #include "common/parsing.h"
-#include "detection/temps.h"
+#include "detection/temps/temps_linux.h"
 #include <string.h>
 #include <unistd.h>
 #include <pci/pci.h>
@@ -17,10 +17,14 @@
 typedef struct PCIData
 {
    struct pci_access* access;
-    FF_LIBRARY_SYMBOL(pci_read_byte);
-    FF_LIBRARY_SYMBOL(pci_read_word);
-    FF_LIBRARY_SYMBOL(pci_lookup_name);
-    FF_LIBRARY_SYMBOL(pci_get_param);
+    FF_LIBRARY_SYMBOL(pci_fill_info)
+    FF_LIBRARY_SYMBOL(pci_read_byte)
+    FF_LIBRARY_SYMBOL(pci_lookup_name)
+    FF_LIBRARY_SYMBOL(pci_get_param)
+
+    #if PCI_LIB_VERSION >= 0x030800
+        FF_LIBRARY_SYMBOL(pci_get_string_property)
+    #endif
 } PCIData;

 static bool pciIDsContains(u16 searched, const u16* ids)
@@ -60,9 +64,27 @@ static void pciDetectVendorName(FFGPUResult* gpu, PCIData* pci, struct pci_dev*

 static void drmDetectDeviceName(FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
 {
+    u8 revId;
+    bool revIdSet = false;;
+
+    #if PCI_LIB_VERSION >= 0x030800
+        revIdSet = pci->ffpci_fill_info(device, PCI_FILL_CLASS_EXT) & PCI_FILL_CLASS_EXT;
+        if(revIdSet)
+            revId = device->rev_id;
+    #endif
+
+    if(!revIdSet)
+    {
+        #ifdef __FreeBSD__
+            return;
+        #else
+            revId = pci->ffpci_read_byte(device, PCI_REVISION_ID);
+        #endif
+    }
+
    FFstrbuf query;
    ffStrbufInit(&query);
-    ffStrbufAppendF(&query, "%X, %X,", device->device_id, pci->ffpci_read_byte(device, PCI_REVISION_ID));
+    ffStrbufAppendF(&query, "%X, %X,", device->device_id, revId);

    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/libdrm/amdgpu.ids", query.chars, &gpu->name);

@@ -100,6 +122,14 @@ static void pciDetectDeviceName(FFGPUResult* gpu, PCIData* pci, struct pci_dev*

 static void pciDetectDriverName(FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
 {
+    #if PCI_LIB_VERSION >= 0x030800
+        pci->ffpci_fill_info(device, PCI_FILL_DRIVER);
+        ffStrbufAppendS(&gpu->driver, pci->ffpci_get_string_property(device, PCI_FILL_DRIVER));
+
+        if(gpu->driver.length > 0)
+            return;
+    #endif
+
    const char* base = pci->ffpci_get_param(pci->access, "sysfs.path");
    if(!ffStrSet(base))
        return;
@@ -120,9 +150,9 @@ static void pciDetectDriverName(FFGPUResult* gpu, PCIData* pci, struct pci_dev*
    ffStrbufDestroy(&path);
 }

-static void pciDetectTemperatur(FFGPUResult* gpu, struct pci_dev* device)
+static void pciDetectTemperatur(const FFinstance* instance, FFGPUResult* gpu, struct pci_dev* device)
 {
-    const FFTempsResult* tempsResult = ffDetectTemps();
+    const FFTempsResult* tempsResult = ffDetectTemps(instance);

    for(uint32_t i = 0; i < tempsResult->values.length; i++)
    {
@@ -141,9 +171,9 @@ static void pciDetectTemperatur(FFGPUResult* gpu, struct pci_dev* device)
    }
 }

-static void pciHandleDevice(FFlist* results, PCIData* pci, struct pci_dev* device)
+static void pciHandleDevice(const FFinstance* instance, FFlist* results, PCIData* pci, struct pci_dev* device)
 {
-    device->device_class = pci->ffpci_read_word(device, PCI_CLASS_DEVICE);
+    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);
@@ -154,8 +184,7 @@ static void pciHandleDevice(FFlist* results, PCIData* pci, struct pci_dev* devic
        strcasecmp("Display controller", class)        != 0
    ) return;

-    device->vendor_id = pci->ffpci_read_word(device, PCI_VENDOR_ID);
-    device->device_id = pci->ffpci_read_word(device, PCI_DEVICE_ID);
+    pci->ffpci_fill_info(device, PCI_FILL_IDENT);

    FFGPUResult* gpu = ffListAdd(results);

@@ -168,24 +197,31 @@ static void pciHandleDevice(FFlist* results, PCIData* pci, struct pci_dev* devic
    ffStrbufInit(&gpu->driver);
    pciDetectDriverName(gpu, pci, device);

+    gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
+
    gpu->temperature = FF_GPU_TEMP_UNSET;
-    pciDetectTemperatur(gpu, device);
+    if(instance->config.gpuTemp)
+        pciDetectTemperatur(instance, gpu, device);
 }

-static void pciDetectGPUs(const FFinstance* instance, FFlist* gpus)
+static const char* pciDetectGPUs(const FFinstance* instance, FFlist* gpus)
 {
    PCIData pci;

-    FF_LIBRARY_LOAD(libpci, instance->config.libPCI, , "libpci.so", 4)
-    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_alloc, )
-    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_init, )
-    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_scan_bus, )
-    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_cleanup, )
+    FF_LIBRARY_LOAD(libpci, &instance->config.libPCI, "dlopen libpci.so failed", "libpci.so", 4);
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libpci, pci_alloc);
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libpci, pci_init);
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libpci, pci_scan_bus);
+    FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libpci, pci_cleanup);

-    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_read_byte, )
-    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_read_word, )
-    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_lookup_name, )
-    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_get_param, )
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libpci, pci, pci_fill_info);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libpci, pci, pci_lookup_name);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libpci, pci, pci_read_byte);
+    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libpci, pci, pci_get_param);
+
+    #if PCI_LIB_VERSION >= 0x030800
+        FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libpci, pci, pci_get_string_property);
+    #endif

    pci.access = ffpci_alloc();
    ffpci_init(pci.access);
@@ -194,12 +230,13 @@ static void pciDetectGPUs(const FFinstance* instance, FFlist* gpus)
    struct pci_dev* device = pci.access->devices;
    while(device != NULL)
    {
-        pciHandleDevice(gpus, &pci, device);
+        pciHandleDevice(instance, gpus, &pci, device);
        device = device->next;
    }

    ffpci_cleanup(pci.access);
    dlclose(libpci);
+    return NULL;
 }

 #endif
@@ -208,5 +245,7 @@ void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
 {
    #ifdef FF_HAVE_LIBPCI
        pciDetectGPUs(instance, gpus);
+    #else
+        FF_UNUSED(gpus, instance);
    #endif
 }
@@ -0,0 +1,7 @@
+#include "gpu.h"
+
+const char* ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+{
+    FF_UNUSED(gpus, instance);
+    return "Not supported on this platform";
+}
@@ -0,0 +1,44 @@
+extern "C" {
+#include "gpu.h"
+}
+#include "util/windows/wmi.hpp"
+
+extern "C"
+const char* ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+{
+    FF_UNUSED(instance);
+
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT Name, AdapterCompatibility, DriverVersion FROM Win32_VideoController", nullptr);
+
+    if(!pEnumerator)
+        return "Query WMI service failed";
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    while(SUCCEEDED(pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn)) && uReturn != 0)
+    {
+        FFGPUResult* gpu = (FFGPUResult*)ffListAdd(gpus);
+
+        ffStrbufInit(&gpu->vendor);
+        ffGetWmiObjString(pclsObj, L"AdapterCompatibility", &gpu->vendor);
+        if(ffStrbufStartsWithS(&gpu->vendor, "Intel "))
+        {
+            //Intel returns "Intel Corporation", not sure about AMD
+            ffStrbufSetS(&gpu->vendor, "Intel");
+        }
+
+        ffStrbufInit(&gpu->name);
+        ffGetWmiObjString(pclsObj, L"Name", &gpu->name);
+
+        ffStrbufInit(&gpu->driver);
+        ffGetWmiObjString(pclsObj, L"DriverVersion", &gpu->driver);
+
+        gpu->temperature = FF_GPU_TEMP_UNSET;
+        gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
+    }
+
+    pclsObj->Release();
+    pEnumerator->Release();
+    return nullptr;
+}
@@ -32,7 +32,7 @@ static inline void applyGTKSettings(FFGTKResult* result, const char* themeName,
        ffStrbufAppendF(&result->cursorSize, "%i", cursorSize);
 }

-static void detectGTKFromSettings(FFinstance* instance, FFGTKResult* result)
+static void detectGTKFromSettings(const FFinstance* instance, FFGTKResult* result)
 {
    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

@@ -144,7 +144,7 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
    ffStrbufSubstrBefore(configDir, configDirLength);
 }

-static void detectGTK(FFinstance* instance, const char* version, FFGTKResult* result)
+static void detectGTK(const FFinstance* instance, const char* version, FFGTKResult* result)
 {
    //Mate, Cinnamon and Gnome use dconf to save theme config
    //On other DEs, this will do nothing
@@ -186,17 +186,17 @@ static void detectGTK(FFinstance* instance, const char* version, FFGTKResult* re
    pthread_mutex_unlock(&mutex); \
    return &result;

-const FFGTKResult* ffDetectGTK2(FFinstance* instance)
+const FFGTKResult* ffDetectGTK2(const FFinstance* instance)
 {
    FF_DETECT_GTK_IMPL(2)
 }

-const FFGTKResult* ffDetectGTK3(FFinstance* instance)
+const FFGTKResult* ffDetectGTK3(const FFinstance* instance)
 {
    FF_DETECT_GTK_IMPL(3)
 }

-const FFGTKResult* ffDetectGTK4(FFinstance* instance)
+const FFGTKResult* ffDetectGTK4(const FFinstance* instance)
 {
    FF_DETECT_GTK_IMPL(4)
 }
@@ -14,8 +14,8 @@ typedef struct FFGTKResult
    FFstrbuf cursorSize;
 } FFGTKResult;

-const FFGTKResult* ffDetectGTK2(FFinstance* instance);
-const FFGTKResult* ffDetectGTK4(FFinstance* instance);
-const FFGTKResult* ffDetectGTK3(FFinstance* instance);
+const FFGTKResult* ffDetectGTK2(const FFinstance* instance);
+const FFGTKResult* ffDetectGTK4(const FFinstance* instance);
+const FFGTKResult* ffDetectGTK3(const FFinstance* instance);

 #endif
@@ -6,6 +6,7 @@
 #include "fastfetch.h"

 #define FF_HOST_PRODUCT_NAME_WSL "Windows Subsystem for Linux"
+#define FF_HOST_PRODUCT_NAME_MSYS "Windows on MSYS"

 typedef struct FFHostResult
 {
@@ -13,17 +14,11 @@ typedef struct FFHostResult
    FFstrbuf productName;
    FFstrbuf productVersion;
    FFstrbuf productSku;
-    FFstrbuf biosDate;
-    FFstrbuf biosRelease;
-    FFstrbuf biosVendor;
-    FFstrbuf biosVersion;
-    FFstrbuf boardName;
-    FFstrbuf boardVendor;
-    FFstrbuf boardVersion;
    FFstrbuf chassisType;
    FFstrbuf chassisVendor;
    FFstrbuf chassisVersion;
    FFstrbuf sysVendor;
+    FFstrbuf error;
 } FFHostResult;

 const FFHostResult* ffDetectHost();
@@ -4,6 +4,8 @@

 void ffDetectHostImpl(FFHostResult* host)
 {
+    ffStrbufInit(&host->error);
+
    //Family

    ffStrbufInit(&host->productFamily);
@@ -32,13 +34,6 @@ void ffDetectHostImpl(FFHostResult* host)

    ffStrbufInitA(&host->productVersion, 0);
    ffStrbufInitA(&host->productSku, 0);
-    ffStrbufInitA(&host->biosDate, 0);
-    ffStrbufInitA(&host->biosRelease, 0);
-    ffStrbufInitA(&host->biosVendor, 0);
-    ffStrbufInitA(&host->biosVersion, 0);
-    ffStrbufInitA(&host->boardName, 0);
-    ffStrbufInitA(&host->boardVendor, 0);
-    ffStrbufInitA(&host->boardVersion, 0);
    ffStrbufInitA(&host->chassisType, 0);
    ffStrbufInitA(&host->chassisVendor, 0);
    ffStrbufInitA(&host->chassisVersion, 0);
@@ -1,24 +1,129 @@
 #include "host.h"
-#include "common/settings.h"
+#include "common/sysctl.h"
+
+static const char* getProductName(const FFstrbuf* hwModel)
+{
+    //https://github.com/hykilpikonna/hyfetch/blob/master/neofetch#L1386
+    if(ffStrbufCompS(hwModel, "Mac14,7") == 0)               return "MacBook Pro (13-inch, M2, 2022)";
+    if(ffStrbufCompS(hwModel, "MacBookPro18,3") == 0 ||
+       ffStrbufCompS(hwModel, "MacBookPro18,4") == 0)        return "MacBook Pro (14-inch, 2021)";
+    if(ffStrbufCompS(hwModel, "MacBookPro18,1") == 0 ||
+       ffStrbufCompS(hwModel, "MacBookPro18,2") == 0)        return "MacBook Pro (16-inch, 2021)";
+    if(ffStrbufCompS(hwModel, "MacBookPro17,1") == 0)        return "MacBook Pro (13-inch, M1, 2020)";
+    if(ffStrbufCompS(hwModel, "MacBookPro16,4") == 0)        return "MacBook Pro (16-inch, 2019)";
+    if(ffStrbufCompS(hwModel, "MacBookPro16,3") == 0)        return "MacBook Pro (13-inch, 2020, Two Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro16,2") == 0)        return "MacBook Pro (13-inch, 2020, Four Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro16,1") == 0)        return "MacBook Pro (16-inch, 2019)";
+    if(ffStrbufCompS(hwModel, "MacBookPro15,4") == 0)        return "MacBook Pro (13-inch, 2019, Two Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro15,3") == 0)        return "MacBook Pro (15-inch, 2019)";
+    if(ffStrbufCompS(hwModel, "MacBookPro15,2") == 0)        return "MacBook Pro (13-inch, 2018/2019, Four Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro15,1") == 0)        return "MacBook Pro (15-inch, 2018/2019)";
+    if(ffStrbufCompS(hwModel, "MacBookPro14,3") == 0)        return "MacBook Pro (15-inch, 2017)";
+    if(ffStrbufCompS(hwModel, "MacBookPro14,2") == 0)        return "MacBook Pro (13-inch, 2017, Four Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro14,1") == 0)        return "MacBook Pro (13-inch, 2017, Two Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro13,3") == 0)        return "MacBook Pro (15-inch, 2016)";
+    if(ffStrbufCompS(hwModel, "MacBookPro13,2") == 0)        return "MacBook Pro (13-inch, 2016, Four Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro13,1") == 0)        return "MacBook Pro (13-inch, 2016, Two Thunderbolt 3 ports)";
+    if(ffStrbufCompS(hwModel, "MacBookPro12,1") == 0)        return "MacBook Pro (Retina, 13-inch, Early 2015)";
+    if(ffStrbufCompS(hwModel, "MacBookPro11,4") == 0 ||
+       ffStrbufCompS(hwModel, "MacBookPro11,5") == 0)        return "MacBook Pro (Retina, 15-inch, Mid 2015)";
+    if(ffStrbufCompS(hwModel, "MacBookPro11,2") == 0 ||
+       ffStrbufCompS(hwModel, "MacBookPro11,3") == 0)        return "MacBook Pro (Retina, 15-inch, Late 2013/Mid 2014)";
+    if(ffStrbufCompS(hwModel, "MacBookPro11,1") == 0)        return "MacBook Pro (Retina, 13-inch, Late 2013/Mid 2014)";
+    if(ffStrbufCompS(hwModel, "MacBookPro10,2") == 0)        return "MacBook Pro (Retina, 13-inch, Late 2012/Early 2013)";
+    if(ffStrbufCompS(hwModel, "MacBookPro10,1") == 0)        return "MacBook Pro (Retina, 15-inch, Mid 2012/Early 2013)";
+    if(ffStrbufCompS(hwModel, "MacBookPro9,2") == 0)         return "MacBook Pro (13-inch, Mid 2012)";
+    if(ffStrbufCompS(hwModel, "MacBookPro9,1") == 0)         return "MacBook Pro (15-inch, Mid 2012)";
+    if(ffStrbufCompS(hwModel, "MacBookPro8,3") == 0)         return "MacBook Pro (17-inch, 2011)";
+    if(ffStrbufCompS(hwModel, "MacBookPro8,2") == 0)         return "MacBook Pro (15-inch, 2011)";
+    if(ffStrbufCompS(hwModel, "MacBookPro8,1") == 0)         return "MacBook Pro (13-inch, 2011)";
+    if(ffStrbufCompS(hwModel, "MacBookPro7,1") == 0)         return "MacBook Pro (13-inch, Mid 2010)";
+    if(ffStrbufCompS(hwModel, "MacBookPro6,2") == 0)         return "MacBook Pro (15-inch, Mid 2010)";
+    if(ffStrbufCompS(hwModel, "MacBookPro6,1") == 0)         return "MacBook Pro (17-inch, Mid 2010)";
+    if(ffStrbufCompS(hwModel, "MacBookPro5,5") == 0)         return "MacBook Pro (13-inch, Mid 2009)";
+    if(ffStrbufCompS(hwModel, "MacBookPro5,3") == 0)         return "MacBook Pro (15-inch, Mid 2009)";
+    if(ffStrbufCompS(hwModel, "MacBookPro5,2") == 0)         return "MacBook Pro (17-inch, Mid/Early 2009)";
+    if(ffStrbufCompS(hwModel, "MacBookPro5,1") == 0)         return "MacBook Pro (15-inch, Late 2008)";
+    if(ffStrbufCompS(hwModel, "MacBookPro4,1") == 0)         return "MacBook Pro (17/15-inch, Early 2008)";
+    if(ffStrbufCompS(hwModel, "Mac14,2") == 0)               return "MacBook Air (M2, 2022)";
+    if(ffStrbufCompS(hwModel, "MacBookAir10,1") == 0)        return "MacBook Air (M1, 2020)";
+    if(ffStrbufCompS(hwModel, "MacBookAir9,1") == 0)         return "MacBook Air (Retina, 13-inch, 2020)";
+    if(ffStrbufCompS(hwModel, "MacBookAir8,2") == 0)         return "MacBook Air (Retina, 13-inch, 2019)";
+    if(ffStrbufCompS(hwModel, "MacBookAir8,1") == 0)         return "MacBook Air (Retina, 13-inch, 2018)";
+    if(ffStrbufCompS(hwModel, "MacBookAir7,2") == 0)         return "MacBook Air (13-inch, Early 2015/2017)";
+    if(ffStrbufCompS(hwModel, "MacBookAir7,1") == 0)         return "MacBook Air (11-inch, Early 2015)";
+    if(ffStrbufCompS(hwModel, "MacBookAir6,2") == 0)         return "MacBook Air (13-inch, Mid 2013/Early 2014)";
+    if(ffStrbufCompS(hwModel, "MacBookAir6,1") == 0)         return "MacBook Air (11-inch, Mid 2013/Early 2014)";
+    if(ffStrbufCompS(hwModel, "MacBookAir5,2") == 0)         return "MacBook Air (13-inch, Mid 2012)";
+    if(ffStrbufCompS(hwModel, "MacBookAir5,1") == 0)         return "MacBook Air (11-inch, Mid 2012)";
+    if(ffStrbufCompS(hwModel, "MacBookAir4,2") == 0)         return "MacBook Air (13-inch, Mid 2011)";
+    if(ffStrbufCompS(hwModel, "MacBookAir4,1") == 0)         return "MacBook Air (11-inch, Mid 2011)";
+    if(ffStrbufCompS(hwModel, "MacBookAir3,2") == 0)         return "MacBook Air (13-inch, Late 2010)";
+    if(ffStrbufCompS(hwModel, "MacBookAir3,1") == 0)         return "MacBook Air (11-inch, Late 2010)";
+    if(ffStrbufCompS(hwModel, "MacBookAir2,1") == 0)         return "MacBook Air (Mid 2009)";
+    if(ffStrbufCompS(hwModel, "MacBook10,1") == 0)           return "MacBook (Retina, 12-inch, 2017)";
+    if(ffStrbufCompS(hwModel, "MacBook9,1") == 0)            return "MacBook (Retina, 12-inch, Early 2016)";
+    if(ffStrbufCompS(hwModel, "MacBook8,1") == 0)            return "MacBook (Retina, 12-inch, Early 2015)";
+    if(ffStrbufCompS(hwModel, "MacBook7,1") == 0)            return "MacBook (13-inch, Mid 2010)";
+    if(ffStrbufCompS(hwModel, "MacBook6,1") == 0)            return "MacBook (13-inch, Late 2009)";
+    if(ffStrbufCompS(hwModel, "MacBook5,2") == 0)            return "MacBook (13-inch, Early/Mid 2009)";
+    if(ffStrbufCompS(hwModel, "Mac13,1") == 0)               return "Mac Studio (2022, Two USB-C front ports)";
+    if(ffStrbufCompS(hwModel, "Mac13,2") == 0)               return "Mac Studio (2022, Two Thunderbolt 4 front ports)";
+    if(ffStrbufCompS(hwModel, "Macmini9,1") == 0)            return "Mac mini (M1, 2020)";
+    if(ffStrbufCompS(hwModel, "Macmini8,1") == 0)            return "Mac mini (2018)";
+    if(ffStrbufCompS(hwModel, "Macmini7,1") == 0)            return "Mac mini (Mid 2014)";
+    if(ffStrbufCompS(hwModel, "Macmini6,1") == 0 ||
+       ffStrbufCompS(hwModel, "Macmini6,2") == 0)            return "Mac mini (Late 2012)";
+    if(ffStrbufCompS(hwModel, "Macmini5,1") == 0 ||
+       ffStrbufCompS(hwModel, "Macmini5,2") == 0)            return "Mac mini (Mid 2011)";
+    if(ffStrbufCompS(hwModel, "Macmini4,1") == 0)            return "Mac mini (Mid 2010)";
+    if(ffStrbufCompS(hwModel, "Macmini3,1") == 0)            return "Mac mini (Early/Late 2009)";
+    if(ffStrbufCompS(hwModel, "MacPro7,1") == 0)             return "Mac Pro (2019)";
+    if(ffStrbufCompS(hwModel, "MacPro6,1") == 0)             return "Mac Pro (Late 2013)";
+    if(ffStrbufCompS(hwModel, "MacPro5,1") == 0)             return "Mac Pro (Mid 2010 - Mid 2012)";
+    if(ffStrbufCompS(hwModel, "MacPro4,1") == 0)             return "Mac Pro (Early 2009)";
+    if(ffStrbufCompS(hwModel, "iMac21,1") == 0 ||
+       ffStrbufCompS(hwModel, "iMac21,2") == 0)              return "iMac (24-inch, M1, 2021)";
+    if(ffStrbufCompS(hwModel, "iMac20,1") == 0 ||
+       ffStrbufCompS(hwModel, "iMac20,2") == 0)              return "iMac (Retina 5K, 27-inch, 2020)";
+    if(ffStrbufCompS(hwModel, "iMac19,1") == 0 ||
+       ffStrbufCompS(hwModel, "iMac19,2") == 0)              return "iMac (Retina 4K, 21.5-inch, 2019)";
+    if(ffStrbufCompS(hwModel, "iMacPro1,1") == 0)            return "iMac Pro (2017)";
+    if(ffStrbufCompS(hwModel, "iMac18,3") == 0)              return "iMac (Retina 5K, 27-inch, 2017)";
+    if(ffStrbufCompS(hwModel, "iMac18,2") == 0)              return "iMac (Retina 4K, 21.5-inch, 2017)";
+    if(ffStrbufCompS(hwModel, "iMac18,1") == 0)              return "iMac (21.5-inch, 2017)";
+    if(ffStrbufCompS(hwModel, "iMac17,1") == 0)              return "iMac (Retina 5K, 27-inch, Late 2015)";
+    if(ffStrbufCompS(hwModel, "iMac16,2") == 0)              return "iMac (Retina 4K, 21.5-inch, Late 2015)";
+    if(ffStrbufCompS(hwModel, "iMac16,1") == 0)              return "iMac (21.5-inch, Late 2015)";
+    if(ffStrbufCompS(hwModel, "iMac15,1") == 0)              return "iMac (Retina 5K, 27-inch, Late 2014 - Mid 2015)";
+    if(ffStrbufCompS(hwModel, "iMac14,4") == 0)              return "iMac (21.5-inch, Mid 2014)";
+    if(ffStrbufCompS(hwModel, "iMac14,2") == 0)              return "iMac (27-inch, Late 2013)";
+    if(ffStrbufCompS(hwModel, "iMac14,1") == 0)              return "iMac (21.5-inch, Late 2013)";
+    if(ffStrbufCompS(hwModel, "iMac13,2") == 0)              return "iMac (27-inch, Late 2012)";
+    if(ffStrbufCompS(hwModel, "iMac13,1") == 0)              return "iMac (21.5-inch, Late 2012)";
+    if(ffStrbufCompS(hwModel, "iMac12,2") == 0)              return "iMac (27-inch, Mid 2011)";
+    if(ffStrbufCompS(hwModel, "iMac12,1") == 0)              return "iMac (21.5-inch, Mid 2011)";
+    if(ffStrbufCompS(hwModel, "iMac11,3") == 0)              return "iMac (27-inch, Mid 2010)";
+    if(ffStrbufCompS(hwModel, "iMac11,2") == 0)              return "iMac (21.5-inch, Mid 2010)";
+    if(ffStrbufCompS(hwModel, "iMac10,1") == 0)              return "iMac (27/21.5-inch, Late 2009)";
+    if(ffStrbufCompS(hwModel, "iMac9,1") == 0)               return "iMac (24/20-inch, Early 2009)";
+    return hwModel->chars;
+}

 void ffDetectHostImpl(FFHostResult* host)
 {
-    ffStrbufInit(&host->productName);
+    ffStrbufInit(&host->error);
+
+    ffStrbufInit(&host->productName);
+    ffStrbufInit(&host->productFamily);
+    ffStrbufInit(&host->productVersion);
+    ffStrbufInit(&host->productSku);

-    ffStrbufInitA(&host->productFamily, 0);
    ffStrbufInitA(&host->sysVendor, 0);
-    ffStrbufInitA(&host->productVersion, 0);
-    ffStrbufInitA(&host->productSku, 0);
-    ffStrbufInitA(&host->biosDate, 0);
-    ffStrbufInitA(&host->biosRelease, 0);
-    ffStrbufInitA(&host->biosVendor, 0);
-    ffStrbufInitA(&host->biosVersion, 0);
-    ffStrbufInitA(&host->boardName, 0);
-    ffStrbufInitA(&host->boardVendor, 0);
-    ffStrbufInitA(&host->boardVersion, 0);
    ffStrbufInitA(&host->chassisType, 0);
    ffStrbufInitA(&host->chassisVendor, 0);
    ffStrbufInitA(&host->chassisVersion, 0);

-    ffSettingsGetAppleProperty("hw.model", &host->productName);
+    ffSysctlGetString("hw.model", &host->productFamily);
+    ffStrbufAppendS(&host->productName, getProductName(&host->productFamily));
 }
@@ -60,6 +60,8 @@ static void getHostProductName(FFstrbuf* name)

 void ffDetectHostImpl(FFHostResult* host)
 {
+    ffStrbufInit(&host->error);
+
    ffStrbufInit(&host->productFamily);
    getHostValue("/sys/devices/virtual/dmi/id/product_family", "/sys/class/dmi/id/product_family", &host->productFamily);

@@ -72,27 +74,6 @@ void ffDetectHostImpl(FFHostResult* host)
    ffStrbufInit(&host->productSku);
    getHostValue("/sys/devices/virtual/dmi/id/product_sku", "/sys/class/dmi/id/product_sku", &host->productSku);

-    ffStrbufInit(&host->biosDate);
-    getHostValue("/sys/devices/virtual/dmi/id/bios_date", "/sys/class/dmi/id/bios_date", &host->biosDate);
-
-    ffStrbufInit(&host->biosRelease);
-    getHostValue("/sys/devices/virtual/dmi/id/bios_release", "/sys/class/dmi/id/bios_release", &host->biosRelease);
-
-    ffStrbufInit(&host->biosVendor);
-    getHostValue("/sys/devices/virtual/dmi/id/bios_vendor", "/sys/class/dmi/id/bios_vendor", &host->biosVendor);
-
-    ffStrbufInit(&host->biosVersion);
-    getHostValue("/sys/devices/virtual/dmi/id/bios_version", "/sys/class/dmi/id/bios_version", &host->biosVersion);
-
-    ffStrbufInit(&host->boardName);
-    getHostValue("/sys/devices/virtual/dmi/id/board_name", "/sys/class/dmi/id/board_name", &host->boardName);
-
-    ffStrbufInit(&host->boardVendor);
-    getHostValue("/sys/devices/virtual/dmi/id/board_vendor", "/sys/class/dmi/id/board_vendor", &host->boardVendor);
-
-    ffStrbufInit(&host->boardVersion);
-    getHostValue("/sys/devices/virtual/dmi/id/board_version", "/sys/class/dmi/id/board_version", &host->boardVersion);
-
    ffStrbufInit(&host->chassisType);
    getHostValue("/sys/devices/virtual/dmi/id/chassis_type", "/sys/class/dmi/id/chassis_type", &host->chassisType);

@@ -109,10 +90,10 @@ void ffDetectHostImpl(FFHostResult* host)
    if(ffStrbufStartsWithS(&host->productName, "Standard PC"))
        ffStrbufPrependS(&host->productName, "KVM/QEMU ");

-    //On WSL, the real host can't be detected. Instead use WSL as host.
-    if(host->productFamily.length == 0 && host->productName.length == 0 && (
-        getenv("WSLENV") != NULL ||
-        getenv("WSL_DISTRO") != NULL ||
-        getenv("WSL_INTEROP") != NULL
-    )) ffStrbufAppendS(&host->productName, FF_HOST_PRODUCT_NAME_WSL);
+    if(host->productFamily.length == 0 && host->productName.length == 0)
+    {
+        //On WSL, the real host can't be detected. Instead use WSL as host.
+        if(getenv("WSL_DISTRO") != NULL || getenv("WSL_INTEROP") != NULL)
+            ffStrbufAppendS(&host->productName, FF_HOST_PRODUCT_NAME_WSL);
+    }
 }
@@ -0,0 +1,42 @@
+extern "C" {
+#include "host.h"
+}
+#include "util/windows/wmi.hpp"
+
+extern "C" void ffDetectHostImpl(FFHostResult* host)
+{
+    ffStrbufInit(&host->error);
+
+    ffStrbufInit(&host->productName);
+    ffStrbufInit(&host->productFamily);
+    ffStrbufInit(&host->productVersion);
+    ffStrbufInit(&host->productSku);
+    ffStrbufInit(&host->sysVendor);
+    ffStrbufInit(&host->chassisType);
+    ffStrbufInit(&host->chassisVendor);
+    ffStrbufInit(&host->chassisVersion);
+
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT Name, Version, SKUNumber, Vendor FROM Win32_ComputerSystemProduct", &host->error);
+    if(!pEnumerator)
+        return;
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
+
+    if(uReturn == 0)
+    {
+        ffStrbufInitS(&host->error, "No Wmi result returned");
+        pEnumerator->Release();
+        return;
+    }
+
+    ffGetWmiObjString(pclsObj, L"Name", &host->productName);
+    ffGetWmiObjString(pclsObj, L"Version", &host->productVersion);
+    ffGetWmiObjString(pclsObj, L"SKUNumber", &host->productSku);
+    ffGetWmiObjString(pclsObj, L"Vendor", &host->sysVendor);
+
+    pclsObj->Release();
+    pEnumerator->Release();
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_kernel_kernel
+#define FF_INCLUDED_detection_kernel_kernel
+
+#include "fastfetch.h"
+
+typedef struct FFKernelResult
+{
+    FFstrbuf sysname;
+    FFstrbuf release;
+    FFstrbuf version;
+    FFstrbuf error;
+} FFKernelResult;
+
+void ffDetectKernel(FFinstance* instance, FFKernelResult* result);
+
+#endif
@@ -0,0 +1,9 @@
+#include "kernel.h"
+
+void ffDetectKernel(FFinstance* instance, FFKernelResult* result)
+{
+    ffStrbufInit(&result->error);
+    ffStrbufInitS(&result->sysname, instance->state.utsname.sysname);
+    ffStrbufInitS(&result->release, instance->state.utsname.release);
+    ffStrbufInitS(&result->version, instance->state.utsname.version);
+}
@@ -0,0 +1,34 @@
+extern "C" {
+#include "kernel.h"
+}
+#include "util/windows/wmi.hpp"
+
+extern "C" void ffDetectKernel(FFinstance* instance, FFKernelResult* kernel)
+{
+    FF_UNUSED(instance);
+
+    ffStrbufInit(&kernel->error);
+
+    ffStrbufInitS(&kernel->sysname, "Windows_NT");
+    ffStrbufInit(&kernel->release);
+    ffStrbufInit(&kernel->version);
+
+    IEnumWbemClassObject* pEnumerator = ffQueryWmi(L"SELECT Version FROM Win32_OperatingSystem", &kernel->error);
+    if(!pEnumerator)
+        return;
+
+    IWbemClassObject *pclsObj = NULL;
+    ULONG uReturn = 0;
+
+    if(FAILED(pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn)) || uReturn == 0)
+    {
+        ffStrbufInitS(&kernel->error, "No WMI result returned");
+        pEnumerator->Release();
+        return;
+    }
+
+    ffGetWmiObjString(pclsObj, L"Version", &kernel->release);
+
+    pclsObj->Release();
+    pEnumerator->Release();
+}
@@ -0,0 +1,17 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_localip_localip
+#define FF_INCLUDED_detection_localip_localip
+
+#include "fastfetch.h"
+
+typedef struct FFLocalIpResult
+{
+    FFstrbuf name;
+    FFstrbuf addr;
+    bool ipv6;
+} FFLocalIpResult;
+
+const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results);
+
+#endif
@@ -0,0 +1,66 @@
+#include "localip.h"
+
+#include <string.h>
+#include <ctype.h>
+#include <ifaddrs.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+
+#ifdef __FreeBSD__
+    #include <sys/socket.h> // FreeBSD needs this for AF_INET
+#endif
+
+static void addNewIp(FFlist* list, const char* name, const char* addr, bool ipv6)
+{
+    FFLocalIpResult* ip = (FFLocalIpResult*) ffListAdd(list);
+    ffStrbufInitS(&ip->name, name);
+    ffStrbufInitS(&ip->addr, addr);
+    ip->ipv6 = ipv6;
+}
+
+const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
+{
+    struct ifaddrs* ifAddrStruct = NULL;
+    if(getifaddrs(&ifAddrStruct) < 0)
+        return "getifaddrs(&ifAddrStruct) failed";
+
+    for (struct ifaddrs* ifa = ifAddrStruct; ifa; ifa = ifa->ifa_next)
+    {
+        if (!ifa->ifa_addr || !(ifa->ifa_flags & IFF_RUNNING))
+            continue;
+
+        // loop back
+        if (strncmp(ifa->ifa_name, "lo", 2) == 0 && (ifa->ifa_name[2] == '\0' || isdigit(ifa->ifa_name[2])) && !instance->config.localIpShowLoop)
+            continue;
+
+        if (instance->config.localIpNamePrefix.length && strncmp(ifa->ifa_name, instance->config.localIpNamePrefix.chars, instance->config.localIpNamePrefix.length) != 0)
+            continue;
+
+        if (ifa->ifa_addr->sa_family == AF_INET)
+        {
+            // IPv4
+            if (!instance->config.localIpShowIpV4)
+                continue;
+
+            struct sockaddr_in* ipv4 = (struct sockaddr_in*) ifa->ifa_addr;
+            char addressBuffer[INET_ADDRSTRLEN];
+            inet_ntop(AF_INET, &ipv4->sin_addr, addressBuffer, INET_ADDRSTRLEN);
+            addNewIp(results, ifa->ifa_name, addressBuffer, false);
+        }
+        else if (ifa->ifa_addr->sa_family == AF_INET6)
+        {
+            // IPv6
+            if (!instance->config.localIpShowIpV6)
+                continue;
+
+            struct sockaddr_in6* ipv6 = (struct sockaddr_in6 *)ifa->ifa_addr;
+            char addressBuffer[INET6_ADDRSTRLEN];
+            inet_ntop(AF_INET6, &ipv6->sin6_addr, addressBuffer, INET6_ADDRSTRLEN);
+            addNewIp(results, ifa->ifa_name, addressBuffer, true);
+        }
+    }
+
+    if (ifAddrStruct) freeifaddrs(ifAddrStruct);
+    return NULL;
+}
@@ -0,0 +1,89 @@
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <iphlpapi.h>
+#include <wchar.h>
+
+#include "localip.h"
+
+static void addNewIp(FFlist* list, const wchar_t* name, const char* addr, bool ipv6)
+{
+    FFLocalIpResult* ip = (FFLocalIpResult*) ffListAdd(list);
+
+    int len = (int)wcslen(name);
+    int size_needed = WideCharToMultiByte(CP_UTF8, 0, name, len, NULL, 0, NULL, NULL);
+    ffStrbufInitA(&ip->name, (uint32_t)size_needed + 1);
+    WideCharToMultiByte(CP_UTF8, 0, name, len, ip->name.chars, size_needed, NULL, NULL);
+    ip->name.length = (uint32_t)size_needed;
+    ip->name.chars[size_needed] = '\0';
+
+    ffStrbufInitS(&ip->addr, addr);
+    ip->ipv6 = ipv6;
+}
+
+const char* ffDetectLocalIps(const FFinstance* instance, FFlist* results)
+{
+    IP_ADAPTER_ADDRESSES* adapter_addresses = NULL;
+
+    // Start with a 16 KB buffer and resize if needed -
+    // multiple attempts in case interfaces change while
+    // we are in the middle of querying them.
+    DWORD adapter_addresses_buffer_size = 16 * 1024;
+    for (int attempts = 0; attempts != 3; ++attempts)
+    {
+        adapter_addresses = (IP_ADAPTER_ADDRESSES*)realloc(adapter_addresses, adapter_addresses_buffer_size);
+        assert(adapter_addresses);
+
+        DWORD error = GetAdaptersAddresses(
+            AF_UNSPEC,
+            GAA_FLAG_SKIP_ANYCAST |
+            GAA_FLAG_SKIP_MULTICAST |
+            GAA_FLAG_SKIP_DNS_SERVER |
+            GAA_FLAG_SKIP_FRIENDLY_NAME,
+            NULL,
+            adapter_addresses,
+            &adapter_addresses_buffer_size);
+
+        if (error == ERROR_SUCCESS)
+            break;
+        else if (ERROR_BUFFER_OVERFLOW == error)
+            continue;
+        else
+            return "GetAdaptersAddresses() failed";
+    }
+
+    // Iterate through all of the adapters
+    for (IP_ADAPTER_ADDRESSES* adapter = adapter_addresses; adapter; adapter = adapter->Next)
+    {
+        if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK && !instance->config.localIpShowLoop)
+            continue;
+
+        for (IP_ADAPTER_UNICAST_ADDRESS* ifa = adapter->FirstUnicastAddress; ifa; ifa = ifa->Next)
+        {
+            if (ifa->Address.lpSockaddr->sa_family == AF_INET)
+            {
+                // IPv4
+                if (!instance->config.localIpShowIpV4)
+                    continue;
+
+                SOCKADDR_IN* ipv4 = (SOCKADDR_IN*) ifa->Address.lpSockaddr;
+                char addressBuffer[INET_ADDRSTRLEN];
+                inet_ntop(AF_INET, &ipv4->sin_addr, addressBuffer, INET_ADDRSTRLEN);
+                addNewIp(results, adapter->FriendlyName, addressBuffer, false);
+            }
+            else if (ifa->Address.lpSockaddr->sa_family == AF_INET6)
+            {
+                // IPv6
+                if (!instance->config.localIpShowIpV6)
+                    continue;
+
+                SOCKADDR_IN6* ipv6 = (SOCKADDR_IN6*) ifa->Address.lpSockaddr;
+                char addressBuffer[INET6_ADDRSTRLEN];
+                inet_ntop(AF_INET6, &ipv6->sin6_addr, addressBuffer, INET6_ADDRSTRLEN);
+                addNewIp(results, adapter->FriendlyName, addressBuffer, false);
+            }
+        }
+    }
+
+    free(adapter_addresses);
+    return NULL;
+}
--- a/Show More
+++ b/Show More