Print the last element of the default structure

#283
Release 1.7.3
2026-09-12 18:32:10 +02:00 · 2022-10-10 10:30:52 +02:00 · 2022-10-09 21:36:53 +02:00 · 2022-10-09 13:34:55 +02:00 · 2022-10-09 10:39:57 +02:00 · 2022-10-09 10:25:38 +02:00
197 changed files with 7827 additions and 3104 deletions
@@ -10,7 +10,7 @@ trim_trailing_whitespace = true
 [*.{md,fflogo}]
 trim_trailing_whitespace = false

-[*.{txt,fflogo}]
+[*.{fflogo}]
 insert_final_newline = false

 [*.yml]
@@ -1 +1 @@
-custom: paypal.me/linusdierheimer
+github: LinusDierheimer
@@ -1,37 +0,0 @@
-name: manage pull requests
-
-on: pull_request
-
-jobs:
-  check:
-    name: manage pull request
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v2
-
-      - 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
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
-
-      - name: configure project
-        run: cmake -DBUILD_TESTS=On .
-
-      - name: build project
-        run: cmake --build . -j$(nproc) --target package
-
-      - name: run fastfetch
-        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
-
-      - name: run flashfetch
-        run: ./flashfetch
-
-      - name: run tests
-        run: ctest
-
-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v1
@@ -1,36 +1,41 @@
 name: manage pushes

 on:
-  push:
-    branches: [ master ]
+  - push
+  - pull_request

 jobs:
-  manage:
-    name: manage push
+  linux:
+    name: Linux
    runs-on: ubuntu-latest
    permissions:
-      contents: write
      security-events: write
+      contents: read
+    outputs:
+      ffversion: ${{ steps.ffversion.outputs.ffversion }}
    steps:
      - name: checkout repository
-        uses: actions/checkout@v2
+        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@v1
+        uses: github/codeql-action/init@v2
+        with:
+          languages: c

      - name: configure project
-        # We reuse the build binary only for the releases.
-        # We set tweak version to off, because it is wrong, as git tag will happen after this step. Releases don't have a tweak, so this is ok.
        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

      - name: run fastfetch
-        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
+        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all

      - name: run flashfetch
        run: ./flashfetch
@@ -38,12 +43,99 @@ jobs:
      - name: run tests
        run: ctest

-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v1
-
      - name: get fastfetch version
-        id: get_version_fastfetch
-        run: echo "::set-output name=release::$(./fastfetch --version-raw)"
+        id: ffversion
+        run: echo "::set-output name=ffversion::$(./fastfetch --version-raw)"
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: fastfetch-linux
+          path: ./fastfetch-*.*
+
+  macos:
+    name: MacOS
+    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 molten-vk
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: c
+
+      - name: configure project
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . --target package
+
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v2
+
+      - name: run fastfetch
+        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true --load-config presets/all
+
+      - name: run flashfetch
+        run: ./flashfetch
+
+      - name: run tests
+        run: ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          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' && github.repository == 'LinusDierheimer/fastfetch'
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - linux
+      - macos
+      - bsd
+    permissions:
+      contents: write
+    steps:
+      - name: download artifacts
+        uses: actions/download-artifact@v3

      - name: get latest release version
        id: get_version_release
@@ -52,9 +144,10 @@ jobs:
          repository: ${{ github.repository }}

      - name: create release
-        if: steps.get_version_fastfetch.outputs.release != steps.get_version_release.outputs.release
+        if: needs.linux.outputs.ffversion != steps.get_version_release.outputs.release
        uses: ncipollo/release-action@v1
        with:
-          tag: ${{ steps.get_version_fastfetch.outputs.release }}
+          tag: ${{ needs.linux.outputs.ffversion }}
          commit: ${{ github.sha }}
-          artifacts: ./fastfetch-*.*
+          artifactErrorsFailBuild: true
+          artifacts: fastfetch-linux/*,fastfetch-macos/*,fastfetch-bsd/*
@@ -2,6 +2,7 @@
 **/.vscode/
 **/.cache/
 **/.kdev4/
+**/.DS_Store
 cscope.*
 tags
 fastfetch.kdev4
@@ -1,3 +1,94 @@
+# 1.7.4
+
+The last element in the default structure (currently the color blocks) is now printed again (#283)
+
+# 1.7.3
+
+A lot of small improvements for MacOS & BSD platforms.
+
+Features:
+* BSD is now officially supported (#228)
+* MacPorts package manager support (@SladeGetz, #234)
+* Battery support for MacOS (@CarterLi, #235)
+* Processes, swap & terminal font support for MacOS(@CarterLi, #237)
+* Song support for MacOS (@CarterLi, #242)
+* Player support for MacOS (@CarterLi, #245)
+* WM theme support for MacOS (@CarterLi, #246)
+* CPU usage support for MacOS (@CarterLi, #247)
+* Power Adapter module (@CarterLi, #249)
+* Windows terminal font for WSL (@CarterLi, #254)
+* Temps & Font support for MacOS (@CarterLi, #258)
+* Terminal font support for Termux (@CarterLi, #263)
+* Weather module (@CarterLi, #266)
+
+Logos
+* Crystal linux (@AloneER0, #239)
+* FreeBSD (@draumaz, #244)
+* New Ubuntu (@AloneER0, #259)
+
+Bugfixes:
+* Don't segfault in GPU code on Intel Macs (@CarterLi, #236)
+* Don't use hardcoded size units in presets (@dr460nf1r3, #255)
+* Don't crash with some format strings (#252)
+* --logo-none keeps key color now (#264)
+
+# 1.7.2
+
+Fixes the bash completions
+
+# 1.7.1
+
+This release brings a lot of bug fixes and improvements for MacOS. Big thanks to @CarterLi for the help on this!
+
+Features:
+* The color of the title and the keys can now be configured individually, using `--color-keys` and `--color-title` respectively. Some distros have different defaults now, similar to neofetch
+* Swap module, similar to the Memory module, but for swap. Add `Swap` to your structure to enable it (#225)
+
+Logos:
+* Slackware (#227)
+
+Bugfixes:
+* Used disk space is now calculated much more accurately
+* On Linux, GPU names are no longer truncated, if they are longer than 32 characters (#224)
+* On Linux, NVIDIA GPUs once again have a proper name
+
+* On M1 platforms, showing the GPU name no longer crashes the program (#222)
+* Brew package count does now work on M1 platforms too
+* The Vulkan module now does work on MacOS too
+* The OpenGL and OpenCL modules now work on MacOS too (@CarterLi, #226)
+* The LocalIp module now works on MacOS too (@CarterLi, #232)
+* Detecting custom WMs on MacOS does now work
+
+Other:
+* GitHub actions now builds a dmg file for MacOS, as you can see in the release page
+
+# 1.7.0
+
+This release brings support for MacOS!  
+The basics things are working, but it is far from feature parity with Linux.
+I developed this in a VM, so bugs on real hardware are likely.
+If you have a Mac and no idea what to do with your free time, i am very happy to accept pull requests / work on issues.
+
+A lot of things were changed under the hood to make this possible, which should bring better performance and stability on all platforms. 
+
+Besides that, the following things have changed:
+
+Features:
+* The binary prefix used can now be configured, and is used consistently across all modules. Set `--binary-prefix` to `iec` (default), `si` or `jedec`.
+* AMD GPUs now have a much better name, if the file `/usr/share/libdrm/amdgpu.ids` exists. For example my dedicated GPU, which was displayed as `AMD/ATI Radeon RX 5600 OEM/5600 XT / 5700/5700 XT`, is now `AMD Radeon RX 5600M`.
+
+Logos:
+* MacOS
+* CachyOS small (@sirlucjan, #220)
+* MSYS2 (#219)
+
+Bugfixes:
+* the `--file` option, which can be used to display the contents of a file as the logo, is now working again.
+
+# 1.6.5
+
+Fixes parsing quoted values in config files
+
 # 1.6.4

 Releasing this, so fedora can package fastfetch. Thanks to @jonathanspw for doing that!
@@ -1,38 +1,56 @@
-cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs
+cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url

 project(fastfetch
-    VERSION 1.6.4
+    VERSION 1.7.4
    LANGUAGES C
+    DESCRIPTION "Fast system information tool"
+    HOMEPAGE_URL "https://github.com/LinusDierheimer/fastfetch"
 )

+###################
+# Target 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)
+    message(FATAL_ERROR "Unsupported platform")
+endif()
+
 #####################
 # Configure options #
 #####################

-OPTION(ENABLE_LIBPCI "Enable libpci" ON)
-OPTION(ENABLE_VULKAN "Enable vulkan" ON)
-OPTION(ENABLE_WAYLAND "Enable wayland-client" ON)
-OPTION(ENABLE_XCB_RANDR "Enable xcb-randr" ON)
-OPTION(ENABLE_XCB "Enable xcb" ON)
-OPTION(ENABLE_XRANDR "Enable xrandr" ON)
-OPTION(ENABLE_X11 "Enable x11" ON)
-OPTION(ENABLE_GIO "Enable gio-2.0" ON)
-OPTION(ENABLE_DCONF "Enable dconf" ON)
-OPTION(ENABLE_DBUS "Enable dbus-1" ON)
-OPTION(ENABLE_XFCONF "Enable libxfconf-0" ON)
-OPTION(ENABLE_SQLITE3 "Enable sqlite3" ON)
-OPTION(ENABLE_RPM "Enable rpm" ON)
-OPTION(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON)
-OPTION(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON)
-OPTION(ENABLE_ZLIB "Enable zlib" ON)
-OPTION(ENABLE_CHAFA "Enable chafa" ON)
-OPTION(ENABLE_EGL "Enable egl" ON)
-OPTION(ENABLE_GLX "Enable glx" ON)
-OPTION(ENABLE_OSMESA "Enable osmesa" ON)
-OPTION(ENABLE_OPENCL "Enable opencl" ON)
+include(CMakeDependentOption)

-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
+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" 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 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 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" OFF)
+cmake_dependent_option(ENABLE_LIBCJSON "Enable libcjson" ON "LINUX" 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

 #############################
 # Compile time dependencies #
@@ -43,6 +61,8 @@ find_package(Threads REQUIRED)

 find_package(PkgConfig REQUIRED)

+include(CheckIncludeFile)
+
 ####################
 # Compiler options #
 ####################
@@ -51,9 +71,21 @@ 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")

+# 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 -fsanitize=address -fsanitize=undefined")
+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)
@@ -81,13 +113,28 @@ if(NOT TARGET_DIR_USR)
 endif()

 if(NOT TARGET_DIR_HOME)
-    if(NOT ANDROID)
-        set(TARGET_DIR_HOME "${TARGET_DIR_ROOT}/home")
-    else()
+    if(APPLE)
+        set(TARGET_DIR_HOME "${TARGET_DIR_ROOT}/Users")
+    elseif(ANDROID)
        set(TARGET_DIR_HOME "/data/data/com.termux/files/home")
+    else()
+        set(TARGET_DIR_HOME "${TARGET_DIR_ROOT}/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 #
 #################
@@ -108,9 +155,10 @@ endif()

 function(fastfetch_load_text FILENAME OUTVAR)
    file(READ "${FILENAME}" TEMP)
-    string(REPLACE "\n" "\\n" TEMP "${TEMP}")
-    string(REPLACE "\"" "\\\"" TEMP "${TEMP}")
-    string(REPLACE "$\\" "" TEMP "${TEMP}")
+    string(REGEX REPLACE "\n$" "" TEMP "${TEMP}") # Remove trailing newline
+    string(REPLACE "\n" "\\n" TEMP "${TEMP}")     # Replace newlines with \n
+    string(REPLACE "\"" "\\\"" TEMP "${TEMP}")    # Replace quotes with \"
+    string(REPLACE "$\\" "" TEMP "${TEMP}")       # Remove $\, so we can unescape some things
    set("${OUTVAR}" "${TEMP}" PARENT_SCOPE)
 endfunction(fastfetch_load_text)

@@ -133,7 +181,7 @@ configure_file(src/fastfetch_config.h.in fastfetch_config.h)
 # libfastfetch target #
 #######################

-add_library(libfastfetch OBJECT
+set(LIBFASTFETCH_SRC
    src/util/FFstrbuf.c
    src/util/FFlist.c
    src/util/FFvaluestore.c
@@ -154,20 +202,21 @@ add_library(libfastfetch OBJECT
    src/logo/image/image.c
    src/logo/image/im7.c
    src/logo/image/im6.c
-    src/detection/os.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/displayserver/displayServer.c
-    src/detection/displayserver/wayland.c
-    src/detection/displayserver/xcb.c
-    src/detection/displayserver/xlib.c
-    src/detection/displayserver/wmde.c
+    src/detection/host/host.c
+    src/detection/os/os.c
+    src/detection/cpu/cpu.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
@@ -195,10 +244,12 @@ add_library(libfastfetch OBJECT
    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
@@ -207,247 +258,171 @@ add_library(libfastfetch OBJECT
    src/modules/colors.c
    src/modules/opengl.c
    src/modules/opencl.c
+    src/modules/users.c
 )

-if(ENABLE_LIBPCI)
-    pkg_check_modules(LIBPCI libpci)
-    if(LIBPCI_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBPCI=1)
-    else()
-        message(WARNING "Package libpci not found. Building without support.")
-    endif()
+if(BSD OR APPLE)
+    list(APPEND LIBFASTFETCH_SRC
+        src/common/sysctl.c
+    )
 endif()

-if(ENABLE_VULKAN)
-    pkg_check_modules(VULKAN vulkan)
-    if(VULKAN_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_VULKAN=1)
-    else()
-        message(WARNING "Package vulkan not found. Building without support.")
-    endif()
+if(LINUX OR ANDROID)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/cpu/cpu_linux.c
+        src/detection/memory/memory_linux.c
+    )
 endif()

-if(ENABLE_WAYLAND)
-    pkg_check_modules (WAYLAND wayland-client)
-    if(WAYLAND_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WAYLAND=1)
-    else()
-        message(WARNING "Package wayland-client not found. Building without support.")
-    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/poweradapter/poweradapter_linux.c
+        src/detection/temps/temps_linux.c
+    )
 endif()

-if(ENABLE_XCB_RANDR)
-    pkg_check_modules(XCB_RANDR xcb-randr)
-    if(XCB_RANDR_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XCB_RANDR=1)
-    else()
-        message(WARNING "Package xcb-randr not found. Building without support.")
-    endif()
+if(LINUX OR BSD)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/host/host_linux.c
+        src/detection/os/os_linux.c
+        src/detection/gpu/gpu_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
+    )
 endif()

-if(ENABLE_XCB)
-    pkg_check_modules (XCB xcb)
-    if(XCB_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XCB=1)
-    else()
-        message(WARNING "Package xcb not found. Building without support.")
-    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
+    )
 endif()

-if(ENABLE_XRANDR)
-    pkg_check_modules(XRANDR xrandr)
-    if(XRANDR_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XRANDR=1)
-    else()
-        message(WARNING "Package xrandr not found. Building without support.")
-    endif()
+if(BSD)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/cpu/cpu_bsd.c
+        src/detection/memory/memory_bsd.c
+    )
 endif()

-if(ENABLE_X11)
-    pkg_check_modules(X11 x11)
-    if(X11_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_X11=1)
-    else()
-        message(WARNING "Package x11 not found. Building without support.")
-    endif()
+if(ANDROID)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/host/host_android.c
+        src/detection/os/os_android.c
+        src/detection/gpu/gpu_android.c
+        src/detection/battery/battery_android.c
+        src/detection/displayserver/displayserver_android.c
+        src/detection/terminalfont/terminalfont_android.c
+        src/detection/media/media_android.c
+        src/detection/wmtheme/wmtheme_android.c
+        src/detection/font/font_android.c
+    )
 endif()

-if(ENABLE_GIO)
-    pkg_check_modules(GIO gio-2.0)
-    if(GIO_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_GIO=1)
-    else()
-        message(WARNING "Package gio-2.0 not found. Building without support.")
-    endif()
+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()

-if(ENABLE_DCONF)
-    pkg_check_modules(DCONF dconf)
-    if(DCONF_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_DCONF=1)
-    else()
-        message(WARNING "Package dconf not found. Building without support.")
-    endif()
+CHECK_INCLUDE_FILE("utmpx.h" HAVE_UTMPX_H)
+if(HAVE_UTMPX_H)
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_UTMPX_H)
 endif()

-if(ENABLE_DBUS)
-    pkg_check_modules(DBUS dbus-1)
-    if(DBUS_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_DBUS=1)
-    else()
-        message(WARNING "Package dbus-1 not found. Building without support.")
-    endif()
-endif()
-
-if(ENABLE_XFCONF)
-    pkg_check_modules(XFCONF libxfconf-0)
-    if(XFCONF_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XFCONF=1)
-    else()
-        message(WARNING "Package libxfconf-0 not found. Building without support.")
-    endif()
-endif()
-
-if(ENABLE_SQLITE3)
-    pkg_check_modules(SQLITE3 sqlite3)
-    if(SQLITE3_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_SQLITE3=1)
-    else()
-        message(WARNING "Package sqlite3 not found. Building without support.")
-    endif()
-endif()
-
-if(ENABLE_RPM)
-    pkg_check_modules(RPM rpm)
-    if(RPM_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_RPM=1)
-    else()
-        message(WARNING "Package rpm not found. Building without support.")
-    endif()
-endif()
-
-if(ENABLE_IMAGEMAGICK7)
-    pkg_check_modules(IMAGEMAGICK7 MagickCore-7.Q16HDRI)
-    if(NOT IMAGEMAGICK7_FOUND)
-        pkg_check_modules(IMAGEMAGICK7 /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16HDRI.pc)
-    endif()
-    if(NOT IMAGEMAGICK7_FOUND)
-        pkg_check_modules(IMAGEMAGICK7 MagickCore-7.Q16)
-    endif()
-    if(NOT IMAGEMAGICK7_FOUND)
-        pkg_check_modules(IMAGEMAGICK7 /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16.pc)
+function(ff_lib_enable VARNAME)
+    if(NOT ENABLE_${VARNAME})
+        return()
    endif()

-    if(IMAGEMAGICK7_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_IMAGEMAGICK7=1)
-    else()
-        message(WARNING "Package MagickCore-7.Q16HDRI or MagickCore-7.Q16 not found. Building without support.")
-    endif()
-endif()
-
-if(ENABLE_IMAGEMAGICK6)
-    pkg_check_modules(IMAGEMAGICK6 MagickCore-6.Q16HDRI)
-    if(NOT IMAGEMAGICK6_FOUND)
-        pkg_check_modules(IMAGEMAGICK6 /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16HDRI.pc)
-    endif()
-    if(NOT IMAGEMAGICK6_FOUND)
-        pkg_check_modules(IMAGEMAGICK6 MagickCore-6.Q16)
-    endif()
-    if(NOT IMAGEMAGICK6_FOUND)
-        pkg_check_modules(IMAGEMAGICK6 /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16.pc)
+    pkg_search_module(${VARNAME} ${ARGN})
+    if(NOT ${VARNAME}_FOUND)
+        message(WARNING "Package ${ARGV1} not found, building without support.")
+        return()
    endif()

-    if(IMAGEMAGICK6_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_IMAGEMAGICK6=1)
-    else()
-        message(WARNING "Package MagickCore-6.Q16HDRI or MagickCore-6.Q16 not found. Building without support.")
-    endif()
-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})

-if(ENABLE_ZLIB)
-    pkg_check_modules(ZLIB zlib)
-    if(ZLIB_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_ZLIB=1)
-    else()
-        message(WARNING "Package zlib not found. Building without support")
-    endif()
-endif()
-
-if(ENABLE_CHAFA)
-    if(IMAGEMAGICK6_FOUND OR IMAGEMAGICK7_FOUND)
-        pkg_check_modules(CHAFA chafa>=1.10)
-        if(CHAFA_FOUND)
-            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_CHAFA=1)
-        else()
-            message(WARNING "Package chafa>=1.10 not found. Building without support.")
+    foreach(FLAG ${${VARNAME}_CFLAGS_OTHER})
+        if(FLAG MATCHES "-D.*")
+            string(SUBSTRING ${FLAG} 2 -1 FLAG)
+            target_compile_definitions(libfastfetch PRIVATE ${FLAG})
        endif()
-    else()
-        message(WARNING "Chafa not enabled, because neither ImageMagick6 nor ImageMagick7 were found. Building without support.")
-    endif()
-endif()
+    endforeach()
+endfunction()

-if(ENABLE_EGL)
-    pkg_check_modules(EGL egl)
-    if(EGL_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_EGL=1)
-    else()
-        message(WARNING "Package egl not found. Building without support.")
-    endif()
-endif()
+ff_lib_enable(LIBPCI libpci)
+ff_lib_enable(VULKAN vulkan)
+ff_lib_enable(WAYLAND wayland-client)
+ff_lib_enable(XCB_RANDR xcb-randr)
+ff_lib_enable(XCB xcb)
+ff_lib_enable(XRANDR xrandr)
+ff_lib_enable(X11 x11)
+ff_lib_enable(GIO gio-2.0)
+ff_lib_enable(DCONF dconf)
+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 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(ENABLE_GLX)
-    pkg_check_modules(GLX glx)
-    if(GLX_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_GLX=1)
-    else()
-        message(WARNING "Package glx not found. Building without support.")
-    endif()
-endif()
-
-if(ENABLE_OSMESA)
-    pkg_check_modules(OSMESA osmesa)
-    if(OSMESA_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_OSMESA=1)
-    else()
-        message(WARNING "Package osmesa not found. Building without support.")
-    endif()
-endif()
-
-if(ENABLE_OPENCL)
-    pkg_check_modules(OPENCL OpenCL)
-    if(OPENCL_FOUND)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_OPENCL=1)
-    else()
-        message(WARNING "Package opencl not found. Building without support.")
-    endif()
+if(APPLE)
+    target_link_libraries(libfastfetch
+        PRIVATE "-framework CoreFoundation"
+        PRIVATE "-framework IOKit"
+        PRIVATE "-framework CoreGraphics"
+        PRIVATE "-framework OpenGL"
+        PRIVATE "-framework OpenCL"
+        PRIVATE "-framework Cocoa"
+        PRIVATE "-weak_framework MediaRemote -F /System/Library/PrivateFrameworks"
+    )
 endif()

 target_include_directories(libfastfetch
    PUBLIC ${PROJECT_BINARY_DIR}
    PUBLIC ${PROJECT_SOURCE_DIR}/src
-
-    PRIVATE ${LIBPCI_INCLUDE_DIRS}
-    PRIVATE ${VULKAN_INCLUDE_DIRS}
-    PRIVATE ${WAYLAND_INCLUDE_DIRS}
-    PRIVATE ${XCB_RANDR_INCLUDE_DIRS}
-    PRIVATE ${XCB_INCLUDE_DIRS}
-    PRIVATE ${XRANDR_INCLUDE_DIRS}
-    PRIVATE ${X11_INCLUDE_DIRS}
-    PRIVATE ${GIO_INCLUDE_DIRS}
-    PRIVATE ${DCONF_INCLUDE_DIRS}
-    PRIVATE ${DBUS_INCLUDE_DIRS}
-    PRIVATE ${XFCONF_INCLUDE_DIRS}
-    PRIVATE ${SQLITE3_INCLUDE_DIRS}
-    PRIVATE ${RPM_INCLUDE_DIRS}
-    PRIVATE ${IMAGEMAGICK7_INCLUDE_DIRS}
-    PRIVATE ${IMAGEMAGICK6_INCLUDE_DIRS}
-    PRIVATE ${ZLIB_INCLUDE_DIRS}
-    PRIVATE ${CHAFA_INCLUDE_DIRS}
-    PRIVATE ${VULKAN_INCLUDE_DIRS}
-    PRIVATE ${EGL_INCLUDE_DIRS}
-    PRIVATE ${GLX_INCLUDE_DIRS}
-    PRIVATE ${OSMESA_INCLUDE_DIRS}
-    PRIVATE ${OPENCL_INCLUDE_DIRS}
 )

 target_link_libraries(libfastfetch
@@ -485,23 +460,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")
-endif()
-
 include(GNUInstallDirs)

 install(
@@ -535,21 +509,30 @@ install(
 # package target #
 ##################

-set(CPACK_GENERATOR "DEB;RPM;TGZ;ZIP")
+set(CPACK_GENERATOR "TGZ;ZIP")
+
+if(LINUX)
+    set(CPACK_GENERATOR "${CPACK_GENERATOR};DEB;RPM")
+
+    set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
+    set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+    set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
+
+    set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+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)

 set(CPACK_PACKAGE_CONTACT "Linus Dierheimer <Linus@Dierheimer.de>")
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Neofetch clone written in C")
 set(CPACK_PACKAGE_DESCRIPTION "\
 fastfetch is a neofetch-like tool for fetching system information and displaying them in a pretty way. \
 It is written in c to achieve much better performance.\
 ")
-set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/LinusDierheimer")
-
-set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
-set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
-
-set(CPACK_RPM_PACKAGE_LICENSE "MIT")

 include(CPack)
@@ -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,9 +1,14 @@
-# fastfetch
+# 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 c to achieve much better performance, in return only Linux and Android are supported. It also uses mechanisms like multithreading and caching to finish as fast as possible.  
-  
-The output on my personal machine with default configurations looks like this:
-<img src="screenshots/example.png" alt="example output" width="100%"/>  
+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 and MacOS 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" />
+<img src="screenshots/example4.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" />
+<img src="screenshots/example2.png" width="48%" align="top" />
+<img src="screenshots/example3.png" width="48%" align="top" />
+<img src="screenshots/example5.png" height="15%" align="top" />

 ## Customization

@@ -11,8 +16,8 @@ With customization and speed being two competing goals, this project actually bu
 The main one being `fastfetch`, which can be very greatly configured via flags. These flags can be made persistent in `~/.config/fastfetch/config.conf`. To view the available options run `fastfetch --help`.  
 The second executable being built is called `flashfetch`, which is configured at compile time to eliminate any possible overhead. Configuration of it can be very easily done in [`src/flashfetch.c`](src/flashfetch.c).  
 At the moment the performance difference is measurable, but too small to be human recognizable. But the leap will get bigger with more and more options coming, and on slow machines this might actually make a difference.  
-  
-There are some presets defined for fastfech in [`presets`](presets), you can can load them with `--load-config`. They may also serve as a good example for format arguments.
+
+There are some premade config files in [`presets`](presets), including the ones used for the screenshots above. You can load them using `--load-config <filename>`. They may also serve as a good example for format arguments.

 ## Dependencies

@@ -37,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 ( 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, Disk, Battery, Player, Song, Vulkan, OpenGL, OpenCL, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
+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, 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, Manjaro, Mint, NixOS, OpenSUSE, OpenSUSE Tumbleweed, OpenSUSE LEAP, Pop!_OS, RebornOS, RedstarOS, Rocky, Rosa, 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, 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
+Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap, apk, pkg, brew, MacPorts
 ```

 ##### 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)
 ```

 ##### DE versions
@@ -75,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
 ```

 ## Building
@@ -9,28 +9,39 @@ __fastfetch_complete_help()
        "os-format"
        "host-format"
        "kernel-format"
+        "uptime-format"
+        "processes-format"
        "packages-format"
        "shell-format"
        "resolution-format"
        "de-format"
        "wm-format"
+        "wm-theme-format"
        "theme-format"
        "icons-format"
        "font-format"
+        "cursor-format"
        "terminal-format"
        "terminal-font-format"
        "cpu-format"
        "cpu-usage-format"
        "gpu-format"
        "memory-format"
+        "swap-format"
        "disk-format"
        "battery-format"
+        "poweradapter-format"
        "locale-format"
        "local-ip-format"
        "public-ip-format"
+        "player-format"
+        "media-format"
        "datetime-format"
        "date-format"
        "time-format"
+        "vulkan-format"
+        "opengl-format"
+        "opencl-format"
    )
    COMPREPLY=($(compgen -W "${__ff_helps[*]}" -- "$CURRENT_WORD"))
 }
@@ -57,6 +68,41 @@ __fastfetch_complete_logo()
    COMPREPLY=($(compgen -W "$(fastfetch --list-logos-autocompletion)" -- "$CURRENT_WORD"))
 }

+__fastfetch_complete_logo_type()
+{
+    local __ff_logo_types=(
+        "auto"
+        "builtin"
+        "file"
+        "raw"
+        "sixel"
+        "kitty"
+        "chafa"
+    )
+    COMPREPLY=($(compgen -W "${__ff_logo_types[*]}" -- "$CURRENT_WORD"))
+}
+
+__fastfetch_complete_binary_prefix()
+{
+    local __ff_binary_prefixes=(
+        "iec"
+        "si"
+        "jedec"
+    )
+    COMPREPLY=($(compgen -W "${__ff_binary_prefixes[*]}" -- "$CURRENT_WORD"))
+}
+
+__fastfetch_complete_gl()
+{
+    local __ff_gl_types=(
+        "auto"
+        "egl"
+        "glx"
+        "osmesa"
+    )
+    COMPREPLY=($(compgen -W "${__ff_gl_types[*]}" -- "$CURRENT_WORD"))
+}
+
 __fastfetch_complete_option()
 {
    local FF_OPTIONS_ALL=(
@@ -64,6 +110,9 @@ __fastfetch_complete_option()
        "${FF_OPTIONS_STRING[@]}"
        "${FF_OPTIONS_PATH[@]}"
        "${FF_OPTIONS_LOGO[@]}"
+        "${FF_OPTIONS_LOGO_TYPE[@]}"
+        "${FF_OPTIONS_BINARY_PREFIX[@]}"
+        "${FF_OPTIONS_GL[@]}"
    )

    if [[ $WORD_COUND -lt 3 ]]; then
@@ -128,12 +177,17 @@ __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"
+        "--escape-bedrock"
    )

    local FF_OPTIONS_STRING=(
@@ -149,135 +203,153 @@ __fastfetch_completion()
        "--logo-color-6"
        "--logo-color-7"
        "--logo-color-8"
+        "--logo-width"
+        "--logo-height"
        "--logo-color-9"
        "-c"
        "--color"
+        "--color-keys"
+        "--color-title"
        "--separator"
        "-s"
        "--structure"
        "--set"
        "--set-keyless"
-        "--gl"
-        "--os-format"
+        "--player-name"
+        "--public-ip-url"
+        "--public-ip-timeout"
+        "--weather-output-format"
+        "--weather-timeout"
        "--os-key"
-        "--host-format"
+        "--os-format"
+        "--os-error"
        "--host-key"
-        "--kernel-format"
+        "--host-format"
+        "--host-error"
        "--kernel-key"
-        "--uptime-format"
+        "--kernel-format"
+        "--kernel-error"
        "--uptime-key"
-        "--processes-format"
+        "--uptime-format"
+        "--uptime-error"
        "--processes-key"
-        "--packages-format"
+        "--processes-format"
+        "--processes-error"
        "--packages-key"
-        "--shell-format"
+        "--packages-format"
+        "--packages-error"
        "--shell-key"
-        "--resolution-format"
+        "--shell-format"
+        "--shell-error"
        "--resolution-key"
-        "--de-format"
+        "--resolution-format"
+        "--resolution-error"
        "--de-key"
-        "--wm-format"
+        "--de-format"
+        "--de-error"
        "--wm-key"
-        "--wm-theme-format"
+        "--wm-format"
+        "--wm-error"
        "--wm-theme-key"
-        "--theme-format"
+        "--wm-theme-format"
+        "--wm-theme-error"
        "--theme-key"
-        "--icons-format"
+        "--theme-format"
+        "--theme-error"
        "--icons-key"
-        "--font-format"
+        "--icons-format"
+        "--icons-error"
        "--font-key"
-        "--cursor-format"
+        "--font-format"
+        "--font-error"
        "--cursor-key"
-        "--terminal-format"
+        "--cursor-format"
+        "--cursor-error"
        "--terminal-key"
-        "--terminal-font-format"
+        "--terminal-format"
+        "--terminal-error"
        "--terminal-font-key"
-        "--cpu-format"
+        "--terminal-font-format"
+        "--terminal-font-error"
        "--cpu-key"
-        "--cpu-usage-format"
-        "--cpu-usage-key"
-        "--gpu-format"
+        "--cpu-format"
+        "--cpu-error"
+        "--cpu-useage-key"
+        "--cpu-useage-format"
+        "--cpu-useage-error"
        "--gpu-key"
-        "--memory-format"
+        "--gpu-format"
+        "--gpu-error"
        "--memory-key"
+        "--memory-format"
+        "--memory-error"
+        "--swap-key"
+        "--swap-format"
+        "--swap-error"
+        "--disk-key"
        "--disk-format"
-        "--disk-key"
-        "--battery-format"
+        "--disk-error"
        "--battery-key"
-        "--locale-format"
+        "--battery-format"
+        "--battery-error"
+        "--poweradapter-key"
+        "--poweradapter-format"
+        "--poweradapter-error"
        "--locale-key"
-        "--disk-folders"
-        "--disk-key"
-        "--local-ip-format"
+        "--locale-format"
+        "--locale-error"
        "--local-ip-key"
-        "--public-ip-format"
+        "--local-ip-format"
+        "--local-ip-error"
        "--public-ip-key"
-        "--player-format"
+        "--public-ip-format"
+        "--public-ip-error"
+        "--weather-key"
+        "--weather-format"
+        "--weather-error"
        "--player-key"
-        "--song-format"
-        "--song-key"
+        "--player-format"
+        "--player-error"
+        "--media-key"
+        "--media-format"
+        "--media-error"
        "--datetime-key"
        "--datetime-format"
-        "--date-format"
+        "--datetime-error"
        "--date-key"
-        "--time-format"
+        "--date-format"
+        "--date-error"
        "--time-key"
+        "--time-format"
+        "--time-error"
        "--vulkan-key"
        "--vulkan-format"
+        "--vulkan-error"
        "--opengl-key"
        "--opengl-format"
+        "--opengl-error"
        "--opencl-key"
        "--opencl-format"
-        "--os-error"
-        "--host-error"
-        "--kernel-error"
-        "--uptime-error"
-        "--processes-error"
-        "--packages-error"
-        "--shell-error"
-        "--resolution-error"
-        "--de-error"
-        "--wm-error"
-        "--wm-theme-error"
-        "--theme-error"
-        "--icons-error"
-        "--font-error"
-        "--cursor-error"
-        "--terminal-error"
-        "--terminal-font-error"
-        "--cpu-error"
-        "--cpu-usage-error"
-        "--gpu-error"
-        "--memory-error"
-        "--disk-error"
-        "--battery-error"
-        "--locale-error"
-        "--disk-error"
-        "--local-ip-error"
-        "--public-ip-error"
-        "--player-error"
-        "--song-error"
-        "--datetime-error"
-        "--date-error"
-        "--time-error"
-        "--vulkan-error"
-        "--opengl-error"
        "--opencl-error"
+        "--users-key"
+        "--users-format"
+        "--users-error"
    )

    local FF_OPTIONS_PATH=(
+        "--load-config"
        "--os-file"
-        "--lib-PCI"
+        "--lib-pci"
        "--lib-vulkan"
        "--lib-wayland"
        "--lib-xcb-randr"
        "--lib-xcb"
-        "--lib-Xrandr"
+        "--lib-xrandr"
        "--lib-X11"
        "--lib-gio"
-        "--lib-DConf"
-        "--lib-DBus"
-        "--lib-XFConf"
+        "--lib-dconf"
+        "--lib-dbus"
+        "--lib-xfconf"
        "--lib-sqlite3"
        "--lib-rpm"
        "--lib-imagemagick"
@@ -288,7 +360,6 @@ __fastfetch_completion()
        "--lib-osmesa"
        "--lib-opencl"
        "--battery-dir"
-        "--load-config"
    )

    local FF_OPTIONS_LOGO=(
@@ -296,6 +367,18 @@ __fastfetch_completion()
        "--logo"
    )

+    local FF_OPTIONS_LOGO_TYPE=(
+        "--logo-type"
+    )
+
+    local FF_OPTIONS_BINARY_PREFIX=(
+        "--binary-prefix"
+    )
+
+    local FF_OPTIONS_GL=(
+        "--gl"
+    )
+
    if __fastfetch_previous_matches "${FF_OPTIONS_SINGLE[@]}"; then
        return
    elif [[ $WORD_COUND -gt 3 && ( ${COMP_WORDS[$COMP_CWORD - 2]} == "--help" || ${COMP_WORDS[$COMP_CWORD - 2]} == "-h" ) ]]; then
@@ -312,6 +395,12 @@ __fastfetch_completion()
        __fastfetch_complete_path
    elif __fastfetch_previous_matches "${FF_OPTIONS_LOGO[@]}"; then
        __fastfetch_complete_logo
+    elif __fastfetch_previous_matches "${FF_OPTIONS_LOGO_TYPE[@]}"; then
+        __fastfetch_complete_logo_type
+    elif __fastfetch_previous_matches "${FF_OPTIONS_BINARY_PREFIX[@]}"; then
+        __fastfetch_complete_binary_prefix
+    elif __fastfetch_previous_matches "${FF_OPTIONS_GL[@]}"; then
+        __fastfetch_complete_gl
    else
        __fastfetch_complete_option
    fi
@@ -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: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
@@ -1,4 +1,4 @@
 --disable-linewrap false
 --multithreading false
--show-errors true
+--show-errors
 --recache
@@ -1,2 +1,3 @@
--load-config verbose
 --load-config devinfo
+--load-config all
+--load-config verbose
@@ -0,0 +1 @@
+# Load with --load-config examples/1
@@ -0,0 +1,24 @@
+# Load with --load-config examples/2
+# Note that you must replace the image path to an existing image to display it.
+
+--kitty /home/linus/Bilder/Gentoo.png
+--logo-width 28
+
+--separator "  "
+
+--set-keyless HardwareStart=┌───────── \e[1mHardware Information\e[0m ─────────┐
+--set-keyless SoftwareStart=├───────── \e[1mSoftware Information\e[0m ─────────┤
+--set-keyless InformationEnd=└────────────────────────────────────────┘
+--set-keyless Colors=    \e[38m \e[37m \e[36m \e[35m \e[34m \e[33m \e[32m \e[31m
+--structure HardwareStart:Host:CPU:GPU:SoftwareStart:OS:Kernel:WM:Shell:Terminal:TerminalFont:Packages:InformationEnd:Colors
+
+--host-key "  "
+--cpu-key "  "
+--gpu-key "  ﬙"
+--os-key "  "
+--kernel-key "  "
+--wm-key "  "
+--shell-key "  "
+--terminal-key "  "
+--terminal-font-key "  "
+--packages-key "  "
@@ -0,0 +1,7 @@
+# Load with --load-config example/3
+
+--logo debian_small
+--structure Vulkan:OpenGL:OpenCL:Memory:Disk:LocalIP
+--binary-prefix si
+--localip-show-loop false
+--disk-folders /:/home:/boot:/efi
@@ -0,0 +1,7 @@
+# Load with --load-config examples/4
+
+--color blue
+--logo arch_small
+--logo-padding-right 1
+--separator "  "
+--structure Date:Time:Break:Player:Media
@@ -0,0 +1,11 @@
+# Load with --load-config examples/5
+
+--logo none
+--color reset_magenta
+--structure Theme:Icons:Font:Cursor
+--theme-key T
+--theme-format {7}
+--icons-key I
+--icons-format {5}
+--font-key F
+--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"
@@ -1,31 +1,30 @@
--load-config all
-
--os-format "System: {}; Name: {}; Pretty name: {}; ID: {}; ID like: {}; Variant: {}; Variant ID: {}; Version: {}; Version ID: {}; Version codename: {}; Build ID: {}; Architecture: {}"
--host-format "Family: "product_family: {}; product_name: {}; product_version: {}; product_sku: {}; bios_date: {}; bios_release: {}; bios_vendor: {}; bios_version: {}; board_name: {}; board_vendor: {}; board_version: {}; chassis_type: {}; chassis_vendor: {}; chassis_version: {}; sys_vendor: {}"
--kernel-format "Sysname: {}; Release: {}; Version: {}"
--uptime-format "Days: {}; Hours: {}; Minutes: {}; Seconds: {}"
--processes-format "Count: {}"
--packages-format "All: {}; pacman: {}; pacman branch: {}; dpkg: {}; rpm: {}; emerge: {}; xbps: {}; flatpak: {}; snap: {}"
--shell-format "Process name: {}; Process path: {}; Process exe: {}; Process version: {}; User path: {}; User exe: {}; User version: {}"
--resolution-format "Width: {}; Height: {}; Refresh rate: {}"
--de-format "Process name: {}; Pretty name: {}; Version: {}"
--wm-format "Process name: {}; Pretty name: {}; Protocol: {}"
--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: {}"
--cursor-format "Theme: {}; Size: {}"
--terminal-format "Process: {}; Path: {}; Exe: {}"
--terminal-font-format "Raw: {}; Name: {}; Size: {}; Styles: {}; Pretty: {}"
--cpu-format "Name: {}; Pretty: {}; Vendor: {}; Logical online: {}; Logical configured: {}; Physical: {}; Cores: {}; temperature: {}; bios: {}; scaling max: {}; scaling min: {}; info max: {}; info min: {}; cpuinfo: {}; frequency: {}"
--cpu-usage-format "Percentage: {}"
--gpu-format "Vendor: {}; Vendor pretty: {}; Name: {}; Name pretty: {}; Driver: {}; Temperature: {}"
--memory-format "Used: {}; Total: {}; Percentage: {}"
--disk-format "Used: {}; Total: {}; Files: {}; Percentage: {}"
--battery-format "Manufactor: {}; Model: {}; Technology: {}; Capacaty: {}; Status: {}"
--player-format "Name: {}"
--song-format "Song: {}; Artist: {}; Album: {}"
--datetime-format "year: {}; yearShort: {}; month: {}; monthPretty: {}; monthName: {}; monthNameShort: {}; weekNumber: {}; weekday: {}; weekdayShort: {}; dayInYear: {}; dayInMonth: {}; dayInWeek: {}; hour: {}; hourPretty: {}; hour12: {}; hour12Pretty: {}; minute: {}; minutePretty: {}; second: {}; secondPretty: {}"
--vulkan-format "driver: {}; Api Version: {}; Conformance Version: {}"
--opengl-format "version: {}; renderer: {}; vendor: {}"
--opencl-format "version: {}; device: {}; vendor: {}"
+--os-format System: {}; Name: {}; Pretty name: {}; ID: {}; ID like: {}; Variant: {}; Variant ID: {}; Version: {}; Version ID: {}; Version codename: {}; Build ID: {}; Architecture: {}
+--host-format Family: product_family: {}; product_name: {}; product_version: {}; product_sku: {}; bios_date: {}; bios_release: {}; bios_vendor: {}; bios_version: {}; board_name: {}; board_vendor: {}; board_version: {}; chassis_type: {}; chassis_vendor: {}; chassis_version: {}; sys_vendor: {}
+--kernel-format Sysname: {}; Release: {}; Version: {}
+--uptime-format Days: {}; Hours: {}; Minutes: {}; Seconds: {}
+--processes-format Count: {}
+--packages-format All: {}; pacman: {}; pacman branch: {}; dpkg: {}; rpm: {}; emerge: {}; xbps: {}; apk: {}; flatpak: {}; snap: {}; brew: {}
+--shell-format Process name: {}; Process path: {}; Process exe: {}; Process version: {}; User path: {}; User exe: {}; User version: {}
+--resolution-format Width: {}; Height: {}; Refresh rate: {}
+--de-format Process name: {}; Pretty name: {}; Version: {}
+--wm-format Process name: {}; Pretty name: {}; Protocol: {}
+--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 Font1: {}; Font2: {}; Font3: {}; Font4: {}
+--cursor-format Theme: {}; Size: {}
+--terminal-format Process: {}; Path: {}; Exe: {}
+--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: {}; 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: {}
+--vulkan-format driver: {}; Api Version: {}; Conformance Version: {}
+--opengl-format version: {}; renderer: {}; vendor: {}
+--opencl-format version: {}; device: {}; vendor: {}
@@ -1,11 +1,22 @@
-#!/bin/env sh
+#!/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,11 +4,15 @@
 #include "common/printing.h"

 #include <stdlib.h>
+#include <string.h>
+
+#define FF_CACHE_VERSION_NAME "cacheversion"
+#define FF_CACHE_VERSION_EXTENSION "ffv"

 #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)
 {
@@ -44,9 +48,11 @@ void ffCacheValidate(FFinstance* instance)
 {
    FFstrbuf content;
    ffStrbufInit(&content);
-    readCacheFile(instance, "cacheversion", "ffv", &content);
+    readCacheFile(instance, FF_CACHE_VERSION_NAME, FF_CACHE_VERSION_EXTENSION, &content);

-    bool isSameVersion = ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0;
+    const char exactVersion[] = FASTFETCH_PROJECT_VERSION FASTFETCH_PROJECT_VERSION_TWEAK;
+
+    bool isSameVersion = ffStrbufCompS(&content, exactVersion) == 0;
    ffStrbufDestroy(&content);
    if(isSameVersion)
        return;
@@ -54,9 +60,9 @@ void ffCacheValidate(FFinstance* instance)
    instance->config.recache = true;

    FFstrbuf version;
-    ffStrbufInitA(&version, sizeof(FASTFETCH_PROJECT_VERSION));
-    ffStrbufAppendS(&version, FASTFETCH_PROJECT_VERSION);
-    writeCacheFile(instance, "cacheversion", "ffv", &version);
+    ffStrbufInitA(&version, sizeof(exactVersion));
+    ffStrbufAppendS(&version, exactVersion);
+    writeCacheFile(instance, FF_CACHE_VERSION_NAME, FF_CACHE_VERSION_EXTENSION, &version);
    ffStrbufDestroy(&version);
 }

@@ -206,24 +212,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
@@ -1,5 +1,6 @@
 #include "fastfetch.h"
 #include "common/format.h"
+#include "common/parsing.h"

 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
 {
@@ -54,20 +55,21 @@ 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)
 {
    return arg->value != NULL && (
-        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value == *(double*)arg->value) || //NaN
+        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0.0) || //Also is false for NaN
        (arg->type == FF_FORMAT_ARG_TYPE_INT && *(int*)arg->value > 0) ||
        (arg->type == FF_FORMAT_ARG_TYPE_STRBUF && ((FFstrbuf*)arg->value)->length > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_STRING && *(const char*)arg->value != '\0') ||
+        (arg->type == FF_FORMAT_ARG_TYPE_STRING && ffStrSet(arg->value)) ||
        (arg->type == FF_FORMAT_ARG_TYPE_UINT8 && *(uint8_t*)arg->value > 0) ||
        (arg->type == FF_FORMAT_ARG_TYPE_UINT16 && *(uint16_t*)arg->value > 0) ||
        (arg->type == FF_FORMAT_ARG_TYPE_UINT && *(uint32_t*)arg->value > 0)
@@ -3,7 +3,7 @@
 #include "common/parsing.h"
 #include "detection/qt.h"
 #include "detection/gtk.h"
-#include "detection/displayserver.h"
+#include "detection/displayserver/displayserver.h"

 #include <stdlib.h>
 #include <unistd.h>
@@ -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
@@ -110,7 +114,10 @@ static void initState(FFstate* state)
    state->keysHeight = 0;
    state->passwd = getpwuid(getuid());
    uname(&state->utsname);
-    sysinfo(&state->sysinfo);
+
+    #if FF_HAVE_SYSINFO_H
+        sysinfo(&state->sysinfo);
+    #endif

    initConfigDirs(state);
    initCacheDir(state);
@@ -125,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]);
@@ -135,7 +142,9 @@ static void defaultConfig(FFinstance* instance)
    instance->config.logo.paddingRight = 4;
    instance->config.logo.printRemaining = true;

-    ffStrbufInit(&instance->config.mainColor);
+    ffStrbufInit(&instance->config.colorKeys);
+    ffStrbufInit(&instance->config.colorTitle);
+
    ffStrbufInit(&instance->config.separator);
    ffStrbufAppendS(&instance->config.separator, ": ");

@@ -146,6 +155,7 @@ static void defaultConfig(FFinstance* instance)
    instance->config.disableLinewrap = true;
    instance->config.hideCursor = true;
    instance->config.escapeBedrock = true;
+    instance->config.binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
    instance->config.glType = FF_GL_TYPE_AUTO;
    instance->config.pipe = false;
    instance->config.multithreading = true;
@@ -171,11 +181,14 @@ static void defaultConfig(FFinstance* instance)
    initModuleArg(&instance->config.cpuUsage);
    initModuleArg(&instance->config.gpu);
    initModuleArg(&instance->config.memory);
+    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);
@@ -184,6 +197,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);
@@ -205,10 +219,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);

@@ -217,8 +238,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);

@@ -231,37 +257,41 @@ void ffInitInstance(FFinstance* instance)
    defaultConfig(instance);
 }

-static inline void* detectPlasmaThreadMain(void* instance)
-{
-    ffDetectQt((FFinstance*)instance);
-    return NULL;
-}
+#if !defined(__ANDROID__)

-static inline void* detectGTK2ThreadMain(void* instance)
-{
-    ffDetectGTK2((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK3ThreadMain(void* instance)
-{
-    ffDetectGTK3((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* detectGTK4ThreadMain(void* instance)
-{
-    ffDetectGTK4((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* connectDisplayServerThreadMain(void* instance)
+static void* connectDisplayServerThreadMain(void* instance)
 {
    ffConnectDisplayServer((FFinstance*)instance);
    return NULL;
 }

-static inline void* startThreadsThreadMain(void* instance)
+#if !defined(__APPLE__)
+
+static void* detectPlasmaThreadMain(void* instance)
+{
+    ffDetectQt((FFinstance*)instance);
+    return NULL;
+}
+
+static void* detectGTK2ThreadMain(void* instance)
+{
+    ffDetectGTK2((FFinstance*)instance);
+    return NULL;
+}
+
+static void* detectGTK3ThreadMain(void* instance)
+{
+    ffDetectGTK3((FFinstance*)instance);
+    return NULL;
+}
+
+static void* detectGTK4ThreadMain(void* instance)
+{
+    ffDetectGTK4((FFinstance*)instance);
+    return NULL;
+}
+
+static void* startThreadsThreadMain(void* instance)
 {
    pthread_t dsThread;
    pthread_create(&dsThread, NULL, connectDisplayServerThreadMain, instance);
@@ -288,18 +318,27 @@ static inline void* startThreadsThreadMain(void* instance)

 void startDetectionThreads(FFinstance* instance)
 {
-    //Android needs none of the things that are detected here
-    //And using gsettings sometimes hangs the program in android for some unknown reason,
-    //and since we don't need it we just never call it.
-    #ifdef __ANDROID__
-        return;
-    #endif
-
    pthread_t startThreadsThread;
    pthread_create(&startThreadsThread, NULL, startThreadsThreadMain, instance);
    pthread_detach(startThreadsThread);
 }

+#else // !__APPLE__
+void startDetectionThreads(FFinstance* instance)
+{
+    pthread_t startThreadsThread;
+    pthread_create(&startThreadsThread, NULL, connectDisplayServerThreadMain, instance);
+    pthread_detach(startThreadsThread);
+}
+#endif // __APPLE__
+
+#else // !__ANDROID__
+void startDetectionThreads(FFinstance* instance)
+{
+    FF_UNUSED(instance);
+}
+#endif // __ANDROID__
+
 static volatile bool ffDisableLinewrap = true;
 static volatile bool ffHideCursor = true;

@@ -359,6 +398,109 @@ 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.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()
 {
@@ -426,6 +568,12 @@ void ffListFeatures()
        #ifdef FF_HAVE_OPENCL
            "opencl\n"
        #endif
+        #ifdef FF_HAVE_LIBCJSON
+            "libcjson\n"
+        #endif
+        #ifdef FF_HAVE_FREETYPE
+            "freetype"
+        #endif
        ""
    , stdout);
 }
@@ -23,7 +23,6 @@ static void createSubfolders(const char* fileName)
    ffStrbufDestroy(&path);
 }

-
 bool ffWriteFDBuffer(int fd, const FFstrbuf* content)
 {
    return write(fd, content->chars, content->length) != -1;
@@ -19,6 +19,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,10 +3,23 @@

 #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);
-    if(result != NULL)
+    void* result = dlopen(path, FF_DLOPEN_FLAGS);
+    if(result != NULL || maxVersion < 0)
        return result;

    FFstrbuf pathbuf;
@@ -19,7 +32,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;

@@ -32,8 +45,8 @@ static void* libraryLoad(const char* path, int maxVersion)

 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,15 +5,21 @@

 #include <dlfcn.h>

+#ifdef __APPLE__
+    #define FF_LIBRARY_EXTENSION ".dylib"
+#else
+    #define FF_LIBRARY_EXTENSION ".so"
+#endif
+
 #define FF_LIBRARY_SYMBOL(symbolName) \
    __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;

-#define FF_LIBRARY_LOAD_SYMBOL_ADRESS(library, symbolMapping, symbolName, returnValue) \
+#define FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, symbolMapping, symbolName, returnValue) \
    symbolMapping = dlsym(library, #symbolName); \
    if(symbolMapping == NULL) \
    { \
@@ -22,7 +28,19 @@
    }

 #define FF_LIBRARY_LOAD_SYMBOL(library, symbolName, returnValue) \
-    __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADRESS(library, ff ## symbolName, symbolName, returnValue);
+    __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, ff ## symbolName, symbolName, returnValue);
+
+#define FF_LIBRARY_LOAD_SYMBOL_MESSAGE(library, symbolName) \
+    __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_VAR(library, varName, symbolName, returnValue) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName.ff ## symbolName, symbolName, returnValue);
+
+#define FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(library, varName, symbolName) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName.ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_PTR(library, varName, symbolName, returnValue) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, varName->ff ## symbolName, symbolName, returnValue);

 void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);

@@ -6,37 +6,38 @@
 #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)
    {
        struct timeval timev;
        timev.tv_sec = 0;
-        timev.tv_usec = timeout * 1000; //milliseconds to microseconds
-        setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
+        timev.tv_usec = (__typeof__(timev.tv_usec)) (timeout * 1000); //milliseconds to microseconds
+        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
@@ -1,18 +1,17 @@
 #include "fastfetch.h"
 #include "common/parsing.h"
+#include <ctype.h>
+#include <inttypes.h>

 bool ffStrSet(const char* str)
 {
    if(str == NULL)
        return false;

-    while(*str != '\0')
-    {
-        if(*str != ' ' && *str != '\t' && *str != '\n' && *str != '\r')
-            return true;
-    }
+    while(isspace(*str))
+        str++;

-    return false;
+    return *str != '\0';
 }

 void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch)
@@ -66,6 +65,37 @@ void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty)
        ffStrbufAppendF(pretty, ".%u", version->patch);
 }

+static void parseSize(FFstrbuf* result, uint64_t bytes, uint32_t base, uint8_t prefixesLength, const char** prefixes)
+{
+    long double size = (long double) bytes;
+    uint8_t counter = 0;
+
+    while(size > base && counter < prefixesLength - 1)
+    {
+        size /= base;
+        counter++;
+    }
+
+    if(counter == 0)
+        ffStrbufAppendF(result, "%"PRIu64" %s", bytes, prefixes[0]);
+    else if(counter < 3 || (counter == 3 && size < 100.0))
+        ffStrbufAppendF(result, "%.2Lf %s", size, prefixes[counter]);
+    else
+        ffStrbufAppendF(result, "%.0Lf %s", size, prefixes[counter]);
+}
+
+void ffParseSize(uint64_t bytes, FFBinaryPrefixType binaryPrefix, FFstrbuf* result)
+{
+    if(binaryPrefix == FF_BINARY_PREFIX_TYPE_IEC)
+        parseSize(result, bytes, 1024, 5, (const char*[]) {"B", "KiB", "MiB", "GiB", "TiB"});
+    else if(binaryPrefix == FF_BINARY_PREFIX_TYPE_SI)
+        parseSize(result, bytes, 1000, 5, (const char*[]) {"B", "kB", "MB", "GB", "TB"});
+    else if(binaryPrefix == FF_BINARY_PREFIX_TYPE_JEDEC)
+        parseSize(result, bytes, 1024, 5, (const char*[]) {"B", "KB", "MB", "GB", "TB"});
+    else
+        parseSize(result, bytes, 1024, 1, (const char*[]) {"B"});
+}
+
 void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
 {
    if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)
@@ -21,4 +21,6 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
 void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty);
 int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2);

+void ffParseSize(uint64_t bytes, FFBinaryPrefixType binaryPrefix, FFstrbuf* result);
+
 #endif
@@ -12,7 +12,7 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
    if(!instance->config.pipe)
    {
        fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-        ffPrintColor(&instance->config.mainColor);
+        ffPrintColor(&instance->config.colorKeys);
    }

    //NULL check is required for modules with custom keys, e.g. disk with the folder path
@@ -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);
@@ -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;
 }
@@ -5,6 +5,6 @@

 #include "util/FFstrbuf.h"

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

 #endif
@@ -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;
@@ -352,10 +352,9 @@ int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, cons

 #ifdef __ANDROID__
 #include <sys/system_properties.h>
-bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
-    uint32_t originalLength = result->length;
+void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {
    ffStrbufEnsureFree(result, PROP_VALUE_MAX);
    result->length += (uint32_t) __system_property_get(propName, result->chars + result->length);
-    return result->length > originalLength;
+    result->chars[result->length] = '\0';
 }
-#endif
+#endif //__ANDROID__
@@ -25,15 +25,15 @@ 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);

 #ifdef __ANDROID__
-bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
+void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
 #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
@@ -1,12 +1,12 @@
 # Fastfetch system configuration
-# This file sets the defaults for all users of the system.
+# This file sets the default config for all users of the system.

-# For more information about configuration files work,
-# see the file ~/.config/fastfetch/config.conf, generated during first
+# For more information about how configuration files work,
+# see ~/.config/fastfetch/config.conf, generated during first run.
 # All options that can be put there (or passed as argument) can be put here too.

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

 # User config option
 # Sets if fastfetch should load user provided configuration.
@@ -113,12 +113,25 @@
 # Default is true.
 #--logo-print-remaining true

-# Color option:
+# Color keys option:
 # Sets the color of the keys.
 # Must be linux console color codes or the name of a color.
-# Default is the primary color of the logo.
+# Default is the key color of the logo.
 # Use "fastfetch --help color" to learn more and see examples.
-#--color magenta
+#--color-keys magenta
+
+# Color title option:
+# Sets the color of the title.
+# Must be linux console color codes or the name of a color.
+# Default is the title color of the logo.
+# Use "fastfetch --help color" to learn more and see examples.
+#--color-title magenta
+
+# Binary prefix option:
+# Sets the binary prefix to use.
+# Must be a IEC, SI or JEDEC.
+# Default is IEC.
+#--binary-prefix IEC

 # Title FQDN option:
 # Sets if the title should use the fully qualified domain name.
@@ -138,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.
@@ -193,17 +224,21 @@
 #--cpu-usage-key CPU Usage
 #--gpu-key GPU {1}
 #--memory-key Memory
+#--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.
@@ -231,17 +266,21 @@
 #--cpu-usage-format
 #--gpu-format
 #--memory-format
+#--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
@@ -269,17 +308,21 @@
 #--cpu-usage-error
 #--gpu-error
 #--memory-error
+#--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.
@@ -304,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
@@ -40,13 +40,16 @@ Logo options:

 Display options:
    -s,--structure <structure>:  sets the structure of the fetch. Must be a colon separated list of keys. Use "fastfetch --list-modules" to see the ones available.
-    -c,--color <color>:          sets the color of the keys. Must be a linux console color code or the name of a color (+)
+    --color-keys <color>:        sers the color of the keys
+    --color-title <color>:       sets the color of the title
+    -c,--color <color>:          sets the color of both the keys and the title
    --separator <str>:           sets the separator between key and value. Default is a colon with a space
    --set <key=value>:           hard set the value of a key
    --set-keyless <key=value>:   hard set the value of a key, but don't print the key or the separator
    --show-errors <?value>:      print occuring errors
    --disable-linewrap <?value>: weather to disable linewrap during the run
    --hide-cursor <?value>:      weather to hide the cursor during the run
+    --binary-prefix <value>:     sets the binary prefix to used. Must be IEC, SI or JEDEC. Default is IEC

 General module options:
    --<module>-format <format>: Sets the format string to use for each specific module.
@@ -81,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-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

@@ -15,6 +15,7 @@ Icons
 Kernel
 Locale
 LocalIP
+Media
 Memory
 OS
 OpenCL
@@ -23,10 +24,11 @@ Packages
 Player
 Processes
 PublicIP
+PowerAdapter
 Resolution
 Separator
 Shell
-Song
+Swap
 Terminal
 TerminalFont
 Theme
@@ -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,10 @@
+#include "fastfetch.h"
+#include "common/io.h"
+#include "battery.h"
+
+#include <dirent.h>
+
+const char* ffDetectBatteryImpl(FFinstance* instance, FFlist* results) {
+    FF_UNUSED(instance, results)
+    return "Unimplemented";
+}
@@ -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,52 @@
+#include "cpu.h"
+#include "common/caching.h"
+#include "detection/internal.h"
+
+#define FF_CPU_CACHE_NAME "cpu"
+
+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,
+        detectCPU(instance, &result);
+    );
+}
@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_cpu_cpu
+#define FF_INCLUDED_detection_cpu_cpu
+
+#include "fastfetch.h"
+
+#define FF_CPU_TEMP_UNSET (0/0.0)
+
+typedef struct FFCPUResult
+{
+    FFstrbuf name;
+    FFstrbuf vendor;
+
+    uint16_t coresPhysical;
+    uint16_t coresLogical;
+    uint16_t coresOnline;
+
+    double frequencyMin;
+    double frequencyMax;
+
+    double temperature;
+} FFCPUResult;
+
+const FFCPUResult* ffDetectCPU(const FFinstance* instance);
+
+#endif
@@ -0,0 +1,76 @@
+#include "cpu.h"
+#include "common/sysctl.h"
+#include "detection/temps/temps_apple.h"
+
+static double getFrequency(const char* propName)
+{
+    double herz = (double) ffSysctlGetInt64(propName, 0);
+    if(herz <= 0.0)
+        return herz;
+
+    herz /= 1000.0; //to KHz
+    herz /= 1000.0; //to MHz
+    return herz / 1000.0; //to GHz
+}
+
+static double detectCpuTemp(const FFstrbuf* cpuName)
+{
+    FFlist temps;
+    ffListInit(&temps, sizeof(FFTempValue));
+
+    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);
+
+    if(temps.length == 0)
+        return 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;
+}
@@ -0,0 +1,111 @@
+#include "cpu.h"
+#include "common/io.h"
+#include "common/properties.h"
+#include "detection/temps/temps_linux.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+
+static void parseCpuInfo(FFCPUResult* cpu, FFstrbuf* physicalCoresBuffer)
+{
+    FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
+    if(cpuinfo == NULL)
+        return;
+
+    char* line = NULL;
+    size_t len = 0;
+
+    while(getline(&line, &len, cpuinfo) != -1)
+    {
+        //Stop after the first CPU
+        if(cpu->name.length > 0 && (*line == '\0' || *line == '\n'))
+            break;
+
+        (void)(
+            ffParsePropLine(line, "model name :", &cpu->name) ||
+            ffParsePropLine(line, "vendor_id :", &cpu->vendor) ||
+            ffParsePropLine(line, "cpu cores :", physicalCoresBuffer) ||
+            (cpu->name.length == 0 && ffParsePropLine(line, "Hardware :", &cpu->name)) //For Android devices
+        );
+    }
+
+    if(line != NULL)
+        free(line);
+
+    fclose(cpuinfo);
+}
+
+static double getGHz(const char* file)
+{
+    FFstrbuf content;
+    ffStrbufInit(&content);
+    ffReadFileBuffer(file, &content);
+    double herz = ffStrbufToDouble(&content);
+    ffStrbufDestroy(&content);
+
+    //ffStrbufToDouble failed
+    if(herz != herz)
+        return 0;
+
+    herz /= 1000.0; //to MHz
+    return herz / 1000.0; //to GHz
+}
+
+static double getFrequency(const char* info, const char* scaling)
+{
+    double frequency = getGHz(info);
+    if(frequency > 0.0)
+        return frequency;
+
+    return getGHz(scaling);
+}
+
+static double detectCPUTemp(const FFinstance* instance)
+{
+    const FFTempsResult* temps = ffDetectTemps(instance);
+
+    for(uint32_t i = 0; i < temps->values.length; i++)
+    {
+        FFTempValue* value = ffListGet(&temps->values, i);
+
+        if(
+            ffStrbufFirstIndexS(&value->name, "cpu") < value->name.length ||
+            ffStrbufCompS(&value->name, "k10temp") == 0 ||
+            ffStrbufCompS(&value->name, "coretemp") == 0
+        ) return value->value;
+    }
+
+    return FF_CPU_TEMP_UNSET;
+}
+
+void ffDetectCPUImpl(const FFinstance* instance, FFCPUResult* cpu, bool cached)
+{
+    if(instance->config.cpuTemp)
+        cpu->temperature = detectCPUTemp(instance);
+    else
+        cpu->temperature = FF_CPU_TEMP_UNSET;
+
+    if(cached)
+        return;
+
+    FFstrbuf physicalCoresBuffer;
+    ffStrbufInit(&physicalCoresBuffer);
+
+    parseCpuInfo(cpu, &physicalCoresBuffer);
+
+    cpu->coresPhysical = ffStrbufToUInt16(&physicalCoresBuffer, 1);
+
+    #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");
+
+    ffStrbufDestroy(&physicalCoresBuffer);
+}
@@ -0,0 +1,8 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_cpu_cpuUsage
+#define FF_INCLUDED_detection_cpu_cpuUsage
+
+const char* ffGetCpuUsageInfo(long* inUseAll, long* totalAll);
+
+#endif
@@ -0,0 +1,28 @@
+#include "fastfetch.h"
+#include "cpuUsage.h"
+
+#include <mach/processor_info.h>
+#include <mach/mach_host.h>
+
+const char* ffGetCpuUsageInfo(long* inUseAll, long* 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 += inUse;
+        *totalAll += total;
+    }
+    return NULL;
+}
@@ -0,0 +1,25 @@
+#include "fastfetch.h"
+#include "cpuUsage.h"
+
+#include <stdio.h>
+
+const char* ffGetCpuUsageInfo(long* inUseAll, long* totalAll)
+{
+    long user, nice, system, idle, iowait, irq, softirq;
+
+    FILE* procStat = fopen("/proc/stat", "r");
+    if(procStat == NULL)
+        return "fopen(\"""/proc/stat\", \"r\") == NULL";
+
+    if (fscanf(procStat, "cpu%ld%ld%ld%ld%ld%ld%ld", &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;
+}
@@ -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,10 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_disk_disk
+#define FF_INCLUDED_detection_disk_disk
+
+#include "fastfetch.h"
+
+const char* ffDiskAutodetectFolders(FFinstance* instance, FFlist* folders);
+
+#endif
@@ -0,0 +1,25 @@
+#include "disk.h"
+
+#import <Foundation/Foundation.h>
+
+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;
+
+        ffStrbufInitS((FFstrbuf *)ffListAdd(folders), [url.relativePath cStringUsingEncoding:NSUTF8StringEncoding]);
+    }
+
+    return NULL;
+}
@@ -0,0 +1,22 @@
+#include "disk.h"
+
+#include <sys/statvfs.h>
+
+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";
+
+    ffStrbufInitS((FFstrbuf *)ffListAdd(folders), FASTFETCH_TARGET_DIR_ROOT"/");
+
+    struct statvfs fsHome;
+    int homeRet = statvfs(FASTFETCH_TARGET_DIR_HOME, &fsHome);
+    if(homeRet == 0 && (fsRoot.f_fsid != fsHome.f_fsid))
+        ffStrbufInitS((FFstrbuf *)ffListAdd(folders), FASTFETCH_TARGET_DIR_HOME);
+
+    return NULL;
+}
@@ -1,133 +0,0 @@
-#include "displayServer.h"
-
-#include <pthread.h>
-#include <dirent.h>
-
-uint32_t ffdsParseRefreshRate(int32_t refreshRate)
-{
-    if(refreshRate <= 0)
-        return 0;
-
-    int remainder = refreshRate % 5;
-    if(remainder >= 3)
-        refreshRate += (5 - remainder);
-    else
-        refreshRate -= remainder;
-
-    //All other typicall refresh rates are dividable by 5
-    if(refreshRate == 145)
-        refreshRate = 144;
-
-    return (uint32_t) refreshRate;
-}
-
-bool ffdsAppendResolution(FFDisplayServerResult* result, uint32_t width, uint32_t height, uint32_t refreshRate)
-{
-    if(width == 0 || height == 0)
-        return false;
-
-    FFResolutionResult* resolution = ffListAdd(&result->resolutions);
-    resolution->width = width;
-    resolution->height = height;
-    resolution->refreshRate = refreshRate;
-
-    return true;
-}
-
-static void parseDRM(FFDisplayServerResult* result)
-{
-    const char* drmDirPath = "/sys/class/drm/";
-
-    DIR* dirp = opendir(drmDirPath);
-    if(dirp == NULL)
-        return;
-
-    FFstrbuf drmDir;
-    ffStrbufInitA(&drmDir, 64);
-    ffStrbufAppendS(&drmDir, drmDirPath);
-
-    uint32_t drmDirLength = drmDir.length;
-
-    struct dirent* entry;
-    while((entry = readdir(dirp)) != NULL)
-    {
-        ffStrbufAppendS(&drmDir, entry->d_name);
-        ffStrbufAppendS(&drmDir, "/modes");
-
-        FILE* modeFile = fopen(drmDir.chars, "r");
-        if(modeFile == NULL)
-        {
-            ffStrbufSubstrBefore(&drmDir, drmDirLength);
-            continue;
-        }
-
-        FFResolutionResult* resolution = ffListAdd(&result->resolutions);
-        resolution->width = 0;
-        resolution->height = 0;
-        resolution->refreshRate = 0;
-
-        int scanned = fscanf(modeFile, "%ix%i", &resolution->width, &resolution->height);
-        if(scanned < 2 || resolution->width == 0 || resolution->height == 0)
-            --result->resolutions.length;
-
-        fclose(modeFile);
-        ffStrbufSubstrBefore(&drmDir, drmDirLength);
-    }
-
-    closedir(dirp);
-    ffStrbufDestroy(&drmDir);
-}
-
-const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance)
-{
-    static FFDisplayServerResult result;
-
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-    init = true;
-
-    ffStrbufInit(&result.wmProcessName);
-    ffStrbufInit(&result.wmPrettyName);
-    ffStrbufInit(&result.wmProtocolName);
-    ffStrbufInit(&result.deProcessName);
-    ffStrbufInit(&result.dePrettyName);
-    ffStrbufInit(&result.deVersion);
-    ffListInitA(&result.resolutions, sizeof(FFResolutionResult), 4);
-
-    //We try wayland as our prefered display server, as it supports the most features.
-    //This method can't detect the name of our WM / DE
-    ffdsConnectWayland(instance, &result);
-
-    //Try the x11 libs, from most feature rich to least.
-    //We use the resolution list to detect if a connection is needed.
-    //They respect wmProtocolName, and only detect resolution if it is set.
-
-    if(result.resolutions.length == 0)
-        ffdsConnectXcbRandr(instance, &result);
-
-    if(result.resolutions.length == 0)
-        ffdsConnectXrandr(instance, &result);
-
-    if(result.resolutions.length == 0)
-        ffdsConnectXcb(instance, &result);
-
-    if(result.resolutions.length == 0)
-        ffdsConnectXlib(instance, &result);
-
-    //This resolution detection method is display server independent.
-    //Use it if all connections failed
-    if(result.resolutions.length == 0)
-        parseDRM(&result);
-
-    //This fills in missing information about WM / DE by using env vars and iterating processes
-    ffdsDetectWMDE(instance, &result);
-
-    pthread_mutex_unlock(&mutex);
-    return &result;
-}
@@ -0,0 +1,42 @@
+#include "displayserver.h"
+#include "detection/internal.h"
+
+uint32_t ffdsParseRefreshRate(int32_t refreshRate)
+{
+    if(refreshRate <= 0)
+        return 0;
+
+    int remainder = refreshRate % 5;
+    if(remainder >= 3)
+        refreshRate += (5 - remainder);
+    else
+        refreshRate -= remainder;
+
+    //All other typicall refresh rates are dividable by 5
+    if(refreshRate == 145)
+        refreshRate = 144;
+
+    return (uint32_t) refreshRate;
+}
+
+bool ffdsAppendResolution(FFDisplayServerResult* result, uint32_t width, uint32_t height, uint32_t refreshRate)
+{
+    if(width == 0 || height == 0)
+        return false;
+
+    FFResolutionResult* resolution = ffListAdd(&result->resolutions);
+    resolution->width = width;
+    resolution->height = height;
+    resolution->refreshRate = refreshRate;
+
+    return true;
+}
+
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance);
+
+const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance)
+{
+    FF_DETECTION_INTERNAL_GUARD(FFDisplayServerResult,
+        ffConnectDisplayServerImpl(&result, instance);
+    );
+}
@@ -25,5 +25,8 @@ typedef struct FFDisplayServerResult

 const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance);

-#endif
+//Used internal
+uint32_t ffdsParseRefreshRate(int32_t refreshRate);
+bool ffdsAppendResolution(FFDisplayServerResult* result, uint32_t width, uint32_t height, uint32_t refreshRate);

+#endif
@@ -0,0 +1,14 @@
+#include "displayserver.h"
+
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+{
+    FF_UNUSED(instance);
+
+    ffStrbufInitA(&ds->wmProcessName, 0);
+    ffStrbufInitA(&ds->wmPrettyName, 0);
+    ffStrbufInitA(&ds->wmProtocolName, 0);
+    ffStrbufInitA(&ds->deProcessName, 0);
+    ffStrbufInitA(&ds->dePrettyName, 0);
+    ffStrbufInitA(&ds->deVersion, 0);
+    ffListInitA(&ds->resolutions, sizeof(FFResolutionResult), 0);
+}
@@ -0,0 +1,110 @@
+#include "displayserver.h"
+#include "common/sysctl.h"
+
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <ApplicationServices/ApplicationServices.h>
+
+//Resolution code heavily inspired by displayplacer <3
+
+typedef union
+{
+    uint8_t rawData[0xDC];
+    struct
+    {
+        uint32_t mode;
+        uint32_t flags;		// 0x4
+        uint32_t width;		// 0x8
+        uint32_t height;	// 0xC
+        uint32_t depth;		// 0x10
+        uint32_t dc2[42];
+        uint16_t dc3;
+        uint16_t freq;		// 0xBC
+        uint32_t dc4[4];
+        float density;		// 0xD0
+    } derived;
+} modes_D4;
+
+void CGSGetCurrentDisplayMode(CGDirectDisplayID display, int* modeNum);
+void CGSGetDisplayModeDescriptionOfLength(CGDirectDisplayID display, int idx, modes_D4* mode, int length);
+
+static void detectResolution(FFDisplayServerResult* ds)
+{
+    CGDisplayCount screenCount;
+    CGGetOnlineDisplayList(INT_MAX, NULL, &screenCount);
+    if(screenCount == 0)
+        return;
+
+    CGDirectDisplayID* screens = malloc(screenCount * sizeof(CGDirectDisplayID));
+    CGGetOnlineDisplayList(INT_MAX, screens, &screenCount);
+
+    for(uint32_t i = 0; i < screenCount; i++)
+    {
+        int modeID;
+        CGSGetCurrentDisplayMode(screens[i], &modeID);
+        modes_D4 mode;
+        CGSGetDisplayModeDescriptionOfLength(screens[i], modeID, &mode, 0xD4);
+
+        uint32_t refreshRate = ffdsParseRefreshRate(mode.derived.freq);
+        ffdsAppendResolution(ds, mode.derived.width, mode.derived.height, refreshRate);
+    }
+
+    free(screens);
+}
+
+static void detectWM(FFDisplayServerResult* ds)
+{
+    int request[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
+    u_int requestLength = sizeof(request) / sizeof(*request);
+
+    size_t length = 0;
+    struct kinfo_proc* processes = ffSysctlGetData(request, requestLength, &length);
+    if(processes == NULL)
+        return;
+
+    for(size_t i = 0; i < length / sizeof(struct kinfo_proc); i++)
+    {
+        const char* comm = processes[i].kp_proc.p_comm;
+
+        if(
+            strcasecmp(comm, "spectacle") != 0 &&
+            strcasecmp(comm, "amethyst") != 0 &&
+            strcasecmp(comm, "kwm") != 0 &&
+            strcasecmp(comm, "chunkwm") != 0 &&
+            strcasecmp(comm, "yabai") != 0 &&
+            strcasecmp(comm, "rectangle") != 0
+        ) continue;
+
+        ffStrbufAppendS(&ds->wmProcessName, comm);
+        ffStrbufAppendS(&ds->wmPrettyName, comm);
+        ds->wmPrettyName.chars[0] = (char) toupper(ds->wmPrettyName.chars[0]);
+        break;
+    }
+
+    free(processes);
+}
+
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+{
+    FF_UNUSED(instance);
+
+    ffStrbufInit(&ds->wmProcessName);
+    ffStrbufInit(&ds->wmPrettyName);
+    ffStrbufInitA(&ds->wmProtocolName, 0);
+    detectWM(ds);
+    if(ds->wmProcessName.length == 0)
+    {
+        ffStrbufAppendS(&ds->wmProcessName, "quartz");
+        ffStrbufAppendS(&ds->wmPrettyName, "Quartz Compositor");
+    }
+
+    ffStrbufInit(&ds->deProcessName);
+    ffStrbufInit(&ds->dePrettyName);
+    ffStrbufInitA(&ds->deVersion, 0);
+    ffStrbufAppendS(&ds->deProcessName, "aqua");
+    ffStrbufAppendS(&ds->dePrettyName, "Aqua");
+
+    ffListInitA(&ds->resolutions, sizeof(FFResolutionResult), 4);
+    detectResolution(ds);
+}
@@ -0,0 +1,86 @@
+#include "displayserver_linux.h"
+
+#include <dirent.h>
+
+static void parseDRM(FFDisplayServerResult* result)
+{
+    const char* drmDirPath = "/sys/class/drm/";
+
+    DIR* dirp = opendir(drmDirPath);
+    if(dirp == NULL)
+        return;
+
+    FFstrbuf drmDir;
+    ffStrbufInitA(&drmDir, 64);
+    ffStrbufAppendS(&drmDir, drmDirPath);
+
+    uint32_t drmDirLength = drmDir.length;
+
+    struct dirent* entry;
+    while((entry = readdir(dirp)) != NULL)
+    {
+        ffStrbufAppendS(&drmDir, entry->d_name);
+        ffStrbufAppendS(&drmDir, "/modes");
+
+        FILE* modeFile = fopen(drmDir.chars, "r");
+        if(modeFile == NULL)
+        {
+            ffStrbufSubstrBefore(&drmDir, drmDirLength);
+            continue;
+        }
+
+        FFResolutionResult* resolution = ffListAdd(&result->resolutions);
+        resolution->width = 0;
+        resolution->height = 0;
+        resolution->refreshRate = 0;
+
+        int scanned = fscanf(modeFile, "%ux%u", &resolution->width, &resolution->height);
+        if(scanned < 2 || resolution->width == 0 || resolution->height == 0)
+            --result->resolutions.length;
+
+        fclose(modeFile);
+        ffStrbufSubstrBefore(&drmDir, drmDirLength);
+    }
+
+    closedir(dirp);
+    ffStrbufDestroy(&drmDir);
+}
+
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+{
+    ffStrbufInit(&ds->wmProcessName);
+    ffStrbufInit(&ds->wmPrettyName);
+    ffStrbufInit(&ds->wmProtocolName);
+    ffStrbufInit(&ds->deProcessName);
+    ffStrbufInit(&ds->dePrettyName);
+    ffStrbufInit(&ds->deVersion);
+    ffListInitA(&ds->resolutions, sizeof(FFResolutionResult), 4);
+
+    //We try wayland as our prefered display server, as it supports the most features.
+    //This method can't detect the name of our WM / DE
+    ffdsConnectWayland(instance, ds);
+
+    //Try the x11 libs, from most feature rich to least.
+    //We use the resolution list to detect if a connection is needed.
+    //They respect wmProtocolName, and only detect resolution if it is set.
+
+    if(ds->resolutions.length == 0)
+        ffdsConnectXcbRandr(instance, ds);
+
+    if(ds->resolutions.length == 0)
+        ffdsConnectXrandr(instance, ds);
+
+    if(ds->resolutions.length == 0)
+        ffdsConnectXcb(instance, ds);
+
+    if(ds->resolutions.length == 0)
+        ffdsConnectXlib(instance, ds);
+
+    //This resolution detection method is display server independent.
+    //Use it if all connections failed
+    if(ds->resolutions.length == 0)
+        parseDRM(ds);
+
+    //This fills in missing information about WM / DE by using env vars and iterating processes
+    ffdsDetectWMDE(instance, ds);
+}
@@ -3,16 +3,12 @@
 #ifndef FASTFETCH_INCLUDED_DISPLAYSERVER
 #define FASTFETCH_INCLUDED_DISPLAYSERVER

-#include "fastfetch.h"
-#include "detection/displayserver.h"
+#include "detection/displayserver/displayserver.h"

 #define FF_DISPLAYSERVER_PROTOCOL_WAYLAND "Wayland"
 #define FF_DISPLAYSERVER_PROTOCOL_X11 "X11"
 #define FF_DISPLAYSERVER_PROTOCOL_TTY "TTY"

-uint32_t ffdsParseRefreshRate(int32_t refreshRate);
-bool ffdsAppendResolution(FFDisplayServerResult* result, uint32_t width, uint32_t height, uint32_t refreshRate);
-
 void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result);

 void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* result);
@@ -1,6 +1,4 @@
-#define _GNU_SOURCE //required for struct ucred
-
-#include "displayServer.h"
+#include "displayserver_linux.h"

 #include <stdlib.h>
 #include <string.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)
@@ -108,9 +114,10 @@ bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)

    WaylandData data;

-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_marshal_constructor_versioned, wl_proxy_marshal_constructor_versioned, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_add_listener, wl_proxy_add_listener, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_output_interface, wl_output_interface, false)
+    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);
    if(display == 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.
@@ -1,4 +1,4 @@
-#include "displayServer.h"
+#include "displayserver_linux.h"
 #include "common/io.h"
 #include "common/properties.h"
 #include "common/parsing.h"
@@ -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"));
 }
@@ -1,4 +1,4 @@
-#include "displayServer.h"
+#include "displayserver_linux.h"

 #ifdef FF_HAVE_XCB
 #include "common/library.h"
@@ -18,12 +18,12 @@ typedef struct XcbPropertyData

 static bool xcbInitPropertyData(void* libraryHandle, XcbPropertyData* propertyData)
 {
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffxcb_intern_atom, xcb_intern_atom, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffxcb_intern_atom_reply, xcb_intern_atom_reply, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffxcb_get_property, xcb_get_property, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffxcb_get_property_reply, xcb_get_property_reply, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffxcb_get_property_value, xcb_get_property_value, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffxcb_get_property_value_length, xcb_get_property_value_length, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, xcb_intern_atom, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, xcb_intern_atom_reply, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, xcb_get_property, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, xcb_get_property_reply, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, xcb_get_property_value, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, xcb_get_property_value_length, false)

    return true;
 }
@@ -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,)
@@ -335,23 +335,23 @@ void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* resu

    XcbRandrData data;

-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_screen_resources, xcb_randr_get_screen_resources,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_screen_resources_reply, xcb_randr_get_screen_resources_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_screen_resources_modes_iterator, xcb_randr_get_screen_resources_modes_iterator,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_screen_info, xcb_randr_get_screen_info,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_screen_info_reply, xcb_randr_get_screen_info_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_mode_info_next, xcb_randr_mode_info_next,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_monitors, xcb_randr_get_monitors,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_monitors_reply, xcb_randr_get_monitors_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_monitors_monitors_iterator, xcb_randr_get_monitors_monitors_iterator,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_monitor_info_next, xcb_randr_monitor_info_next,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_monitor_info_outputs_length, xcb_randr_monitor_info_outputs_length,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_monitor_info_outputs, xcb_randr_monitor_info_outputs,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_output_next, xcb_randr_output_next,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_output_info, xcb_randr_get_output_info,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_output_info_reply, xcb_randr_get_output_info_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_crtc_info, xcb_randr_get_crtc_info,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xcbRandr, data.ffxcb_randr_get_crtc_info_reply, xcb_randr_get_crtc_info_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_resources,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_resources_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_resources_modes_iterator,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_info,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_screen_info_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_mode_info_next,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_monitors,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_monitors_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_monitors_monitors_iterator,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_monitor_info_next,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_monitor_info_outputs_length,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_monitor_info_outputs,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_output_next,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_info,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_output_info_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_crtc_info,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xcbRandr, data, xcb_randr_get_crtc_info_reply,)

    XcbPropertyData propertyData;
    bool propertyDataInitialized = xcbInitPropertyData(xcbRandr, &propertyData);
@@ -1,4 +1,4 @@
-#include "displayServer.h"
+#include "displayserver_linux.h"

 #ifdef FF_HAVE_X11
 #include "common/library.h"
@@ -13,8 +13,8 @@ typedef struct X11PropertyData

 static bool x11InitPropertyData(void* libraryHandle, X11PropertyData* propertyData)
 {
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffXInternAtom, XInternAtom, false)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(libraryHandle, propertyData->ffXGetWindowProperty, XGetWindowProperty, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, XInternAtom, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(libraryHandle, propertyData, XGetWindowProperty, false)

    return true;
 }
@@ -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,24 +259,24 @@ 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,)

    XrandrData data;

-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRGetScreenInfo, XRRGetScreenInfo,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRConfigCurrentRate, XRRConfigCurrentRate,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRGetMonitors, XRRGetMonitors,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRGetScreenResources, XRRGetScreenResources,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRGetOutputInfo, XRRGetOutputInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRGetCrtcInfo, XRRGetCrtcInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRFreeCrtcInfo, XRRFreeCrtcInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRFreeOutputInfo, XRRFreeOutputInfo,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRFreeScreenResources, XRRFreeScreenResources,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRFreeMonitors, XRRFreeMonitors,);
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(xrandr, data.ffXRRFreeScreenConfigInfo, XRRFreeScreenConfigInfo,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetScreenInfo,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRConfigCurrentRate,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetMonitors,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetScreenResources,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetOutputInfo,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRGetCrtcInfo,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeCrtcInfo,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeOutputInfo,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeScreenResources,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeMonitors,);
+    FF_LIBRARY_LOAD_SYMBOL_VAR(xrandr, data, XRRFreeScreenConfigInfo,);

    X11PropertyData propertyData;
    bool propertyDataInitialized = x11InitPropertyData(xrandr, &propertyData);
@@ -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,24 @@
+#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
+     * Other:       Unset,  Unset, Unset,     Unset
+     */
+    FFstrbuf fonts[FF_DETECT_FONT_NUM_FONTS];
+} FFFontResult;
+
+const FFFontResult* ffDetectFont(const FFinstance* instance);
+
+#endif
@@ -0,0 +1,8 @@
+#include "fastfetch.h"
+#include "font.h"
+
+void ffDetectFontImpl(const FFinstance* instance, FFFontResult* result)
+{
+    FF_UNUSED(instance);
+    ffStrbufAppendS(&result->error, "Not implemented");
+}
@@ -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,19 @@
+#include "gpu.h"
+#include "detection/internal.h"
+#include "detection/vulkan.h"
+
+void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance);
+
+const FFlist* ffDetectGPU(const FFinstance* instance)
+{
+    FF_DETECTION_INTERNAL_GUARD(FFlist,
+        ffListInit(&result, sizeof(FFGPUResult));
+        ffDetectGPUImpl(&result, instance);
+
+        if(result.length == 0)
+        {
+            const FFVulkanResult* vulkan = ffDetectVulkan(instance);
+            result = vulkan->gpus;
+        }
+    );
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_gpu_gpu
+#define FF_INCLUDED_detection_gpu_gpu
+
+#include "fastfetch.h"
+
+#define FF_GPU_TEMP_UNSET (0/0.0)
+#define FF_GPU_CORE_COUNT_UNSET -1
+
+typedef struct FFGPUResult
+{
+    FFstrbuf vendor;
+    FFstrbuf name;
+    FFstrbuf driver;
+    double temperature;
+    int coreCount;
+} FFGPUResult;
+
+const FFlist* ffDetectGPU(const FFinstance* instance);
+
+#endif
@@ -0,0 +1,7 @@
+#include "gpu.h"
+
+const char* ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+{
+    FF_UNUSED(gpus, instance);
+    return "Unimplemented";
+}
@@ -0,0 +1,100 @@
+#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 <IOKit/graphics/IOGraphicsLib.h>
+
+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);
+
+    CFMutableDictionaryRef matchDict = IOServiceMatching(kIOAcceleratorClassName);
+    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;
+        }
+
+        FFGPUResult* gpu = ffListAdd(gpus);
+
+        ffStrbufInitA(&gpu->vendor, 0);
+
+        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;
+}
@@ -0,0 +1,251 @@
+#include "gpu.h"
+#include "detection/vulkan.h"
+
+#define FF_GPU_VENDOR_NAME_AMD "AMD"
+#define FF_GPU_VENDOR_NAME_INTEL "Intel"
+#define FF_GPU_VENDOR_NAME_NVIDIA "NVIDIA"
+
+#ifdef FF_HAVE_LIBPCI
+#include "common/library.h"
+#include "common/properties.h"
+#include "common/parsing.h"
+#include "detection/temps/temps_linux.h"
+#include <string.h>
+#include <unistd.h>
+#include <pci/pci.h>
+
+typedef struct PCIData
+{
+    struct pci_access* access;
+    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)
+{
+    while(*ids != 0)
+    {
+        if(*ids == searched)
+            return true;
+        ids++;
+    }
+    return false;
+}
+
+static void pciDetectVendorName(FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
+{
+    if(pciIDsContains(device->vendor_id, (const u16[]) {0x1002, 0x1022, 0}))
+        ffStrbufAppendS(&gpu->vendor, FF_GPU_VENDOR_NAME_AMD);
+    else if(pciIDsContains(device->vendor_id, (const u16[]) {0x03e7, 0x8086, 0x8087, 0}))
+        ffStrbufAppendS(&gpu->vendor, FF_GPU_VENDOR_NAME_INTEL);
+    else if(pciIDsContains(device->vendor_id, (const u16[]) {0x0955, 0x10de, 0x12d2, 0}))
+        ffStrbufAppendS(&gpu->vendor, FF_GPU_VENDOR_NAME_NVIDIA);
+
+    if(gpu->vendor.length > 0)
+        return;
+
+    ffStrbufEnsureFree(&gpu->vendor, 255);
+    pci->ffpci_lookup_name(pci->access, gpu->vendor.chars, (int) gpu->vendor.allocated, PCI_LOOKUP_VENDOR, device->vendor_id);
+    ffStrbufRecalculateLength(&gpu->vendor);
+
+    if(ffStrbufFirstIndexS(&gpu->vendor, "AMD") < gpu->vendor.length || ffStrbufFirstIndexS(&gpu->vendor, "ATI") < gpu->vendor.length)
+        ffStrbufSetS(&gpu->vendor, FF_GPU_VENDOR_NAME_AMD);
+    else if(ffStrbufFirstIndexS(&gpu->vendor, "Intel") < gpu->vendor.length)
+        ffStrbufSetS(&gpu->vendor, FF_GPU_VENDOR_NAME_INTEL);
+    else if(ffStrbufFirstIndexS(&gpu->vendor, "NVIDIA") < gpu->vendor.length)
+        ffStrbufSetS(&gpu->vendor, FF_GPU_VENDOR_NAME_NVIDIA);
+}
+
+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, revId);
+
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/libdrm/amdgpu.ids", query.chars, &gpu->name);
+
+    ffStrbufDestroy(&query);
+
+    const char* removeStrings[] = {
+        "AMD ", "ATI ",
+        " (TM)", "(TM)",
+        " Graphics Adapter", " Graphics", " Series", " Edition"
+    };
+    ffStrbufRemoveStringsA(&gpu->name, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
+}
+
+static void pciDetectDeviceName(FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
+{
+    if(ffStrbufCompS(&gpu->vendor, FF_GPU_VENDOR_NAME_AMD) == 0)
+    {
+        drmDetectDeviceName(gpu, pci, device);
+        if(gpu->name.length > 0)
+            return;
+    }
+
+    ffStrbufEnsureFree(&gpu->name, 255);
+    pci->ffpci_lookup_name(pci->access, gpu->name.chars, (int) gpu->name.allocated, PCI_LOOKUP_DEVICE, device->vendor_id, device->device_id);
+    ffStrbufRecalculateLength(&gpu->name);
+
+    uint32_t openingBracket = ffStrbufFirstIndexC(&gpu->name, '[');
+    uint32_t closingBracket = ffStrbufNextIndexC(&gpu->name, openingBracket, ']');
+    if(closingBracket < gpu->name.length)
+    {
+        ffStrbufSubstrBefore(&gpu->name, closingBracket);
+        ffStrbufSubstrAfter(&gpu->name, openingBracket);
+    }
+}
+
+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;
+
+    FFstrbuf path;
+    ffStrbufInitA(&path, 64);
+    ffStrbufAppendF(&path, "%s/devices/%04x:%02x:%02x.%d/driver", base, device->domain, device->bus, device->dev, device->func);
+
+    ffStrbufEnsureFree(&gpu->driver, 1023);
+    ssize_t resultLength = readlink(path.chars, gpu->driver.chars, gpu->driver.allocated - 1); //-1 for null terminator
+    if(resultLength > 0)
+    {
+        gpu->driver.length = (uint32_t) resultLength;
+        gpu->driver.chars[resultLength] = '\0';
+        ffStrbufSubstrAfterLastC(&gpu->driver, '/');
+    }
+
+    ffStrbufDestroy(&path);
+}
+
+static void pciDetectTemperatur(const FFinstance* instance, FFGPUResult* gpu, struct pci_dev* device)
+{
+    const FFTempsResult* tempsResult = ffDetectTemps(instance);
+
+    for(uint32_t i = 0; i < tempsResult->values.length; i++)
+    {
+        FFTempValue* tempValue = ffListGet(&tempsResult->values, i);
+
+        uint32_t tempClass;
+        if(sscanf(tempValue->deviceClass.chars, "%x", &tempClass) != 1)
+            continue;
+
+        //The kernel exposes the device class multiplied by 256 for some reason
+        if(tempClass == device->device_class * 256)
+        {
+            gpu->temperature = tempValue->value;
+            return;
+        }
+    }
+}
+
+static void pciHandleDevice(const FFinstance* instance, FFlist* results, PCIData* pci, struct pci_dev* 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);
+
+    if(
+        strcasecmp("VGA compatible controller", class) != 0 &&
+        strcasecmp("3D controller", class)             != 0 &&
+        strcasecmp("Display controller", class)        != 0
+    ) return;
+
+    pci->ffpci_fill_info(device, PCI_FILL_IDENT);
+
+    FFGPUResult* gpu = ffListAdd(results);
+
+    ffStrbufInit(&gpu->vendor);
+    pciDetectVendorName(gpu, pci, device);
+
+    ffStrbufInit(&gpu->name);
+    pciDetectDeviceName(gpu, pci, device);
+
+    ffStrbufInit(&gpu->driver);
+    pciDetectDriverName(gpu, pci, device);
+
+    gpu->coreCount = FF_GPU_CORE_COUNT_UNSET;
+
+    gpu->temperature = FF_GPU_TEMP_UNSET;
+    if(instance->config.gpuTemp)
+        pciDetectTemperatur(instance, gpu, device);
+}
+
+static const char* pciDetectGPUs(const FFinstance* instance, FFlist* gpus)
+{
+    PCIData pci;
+
+    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_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);
+    ffpci_scan_bus(pci.access);
+
+    struct pci_dev* device = pci.access->devices;
+    while(device != NULL)
+    {
+        pciHandleDevice(instance, gpus, &pci, device);
+        device = device->next;
+    }
+
+    ffpci_cleanup(pci.access);
+    dlclose(libpci);
+    return NULL;
+}
+
+#endif
+
+void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+{
+    #ifdef FF_HAVE_LIBPCI
+        pciDetectGPUs(instance, gpus);
+    #else
+        FF_UNUSED(gpus, instance);
+    #endif
+}
@@ -2,7 +2,7 @@
 #include "detection/gtk.h"
 #include "common/properties.h"
 #include "common/settings.h"
-#include "detection/displayserver.h"
+#include "detection/displayserver/displayserver.h"

 #include <pthread.h>

@@ -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
@@ -0,0 +1,11 @@
+#include "host.h"
+#include "detection/internal.h"
+
+void ffDetectHostImpl(FFHostResult* host);
+
+const FFHostResult* ffDetectHost()
+{
+    FF_DETECTION_INTERNAL_GUARD(FFHostResult,
+        ffDetectHostImpl(&result)
+    );
+}
@@ -0,0 +1,31 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_host_host
+#define FF_INCLUDED_detection_host_host
+
+#include "fastfetch.h"
+
+#define FF_HOST_PRODUCT_NAME_WSL "Windows Subsystem for Linux"
+
+typedef struct FFHostResult
+{
+    FFstrbuf productFamily;
+    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;
+} FFHostResult;
+
+const FFHostResult* ffDetectHost();
+
+#endif
@@ -0,0 +1,45 @@
+#include "host.h"
+#include "common/settings.h"
+#include <ctype.h>
+
+void ffDetectHostImpl(FFHostResult* host)
+{
+    //Family
+
+    ffStrbufInit(&host->productFamily);
+    ffSettingsGetAndroidProperty("ro.product.device", &host->productFamily);
+
+    //Name
+
+    ffStrbufInit(&host->productName);
+
+    ffSettingsGetAndroidProperty("ro.product.brand", &host->productName);
+    if(host->productName.length > 0){
+        host->productName.chars[0] = (char) toupper(host->productName.chars[0]);
+        ffStrbufAppendC(&host->productName, ' ');
+    }
+
+    ffSettingsGetAndroidProperty("ro.product.model", &host->productName);
+
+    ffStrbufTrimRight(&host->productName, ' ');
+
+    //Sys vendor
+
+    ffStrbufInit(&host->sysVendor);
+    ffSettingsGetAndroidProperty("ro.product.manufacturer", &host->sysVendor);
+
+    //Not implemented
+
+    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);
+}
@@ -0,0 +1,134 @@
+#include "host.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->productFamily);
+
+    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);
+
+    ffSysctlGetString("hw.model", &host->productFamily);
+    ffStrbufAppendS(&host->productName, getProductName(&host->productFamily));
+}
--- a/Show More
+++ b/Show More