Release 1.7.1

second try

.github/ISSUE_TEMPLATE/bug_report.md

@@ -25,6 +25,9 @@ Output of `fastfetch --load-config devinfo`:
 ```
 
 Output of `fastfetch --load-config devinfo-verbose`:
+<!--
+Note that this output will contain you public IP. If it is not relevant for the issue, feel free to remove it before uploading.
+-->
 ```
 //paste here
 ```
@@ -38,4 +41,3 @@ Output of `fastfetch --list-features`:
 If you get the following error: `Error: couldn't find config: [...]`, copy the files in [presets](../../presets/) to `/usr/share/fastfetch/presets/` or `~/.local/share/fastfetch/presets/`.
 If this isn't possible (or too much work) for you, post the output of `fastfetch --show-errors --recache --multithreading false --disable-linewrap false`. 
 -->
-

.github/ISSUE_TEMPLATE/logo_request.md

@@ -0,0 +1,18 @@
+---
+name: Logo request
+about: Request a new logo
+title: ''
+labels: logo request
+assignees: ''
+
+---
+
+# OS
+```
+paste content of /etc/os-release here. If this file doesn't exist, describe a way to identify the distro.
+```
+
+# Ascii
+```
+paste ascii art here. If you leave this empty, i will try to find the logo myself.
+```

.github/workflows/pull_request.yml

@@ -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

.github/workflows/push.yml

@@ -1,36 +1,40 @@
 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
+    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
 
       - 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 .
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
 
       - name: build project
         run: cmake --build . -j$(nproc) --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 +42,69 @@ 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
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v3
+
+      - name: install required packages
+        run: brew install vulkan-loader
+
+      - 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 . -j$(sysctl -n hw.logicalcpu) --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-*.*
+
+  release:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - linux
+      - macos
+    permissions:
+      contents: write
+    steps:
+      - name: download artifacts
+        uses: actions/download-artifact@v3
 
       - name: get latest release version
         id: get_version_release
@@ -52,9 +113,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/*

.gitignore

@@ -2,8 +2,7 @@
 **/.vscode/
 **/.cache/
 **/.kdev4/
+**/.DS_Store
 cscope.*
 tags
 fastfetch.kdev4
-**/*.deb
-packaging/deb/fastfetch

CHANGELOG.md

@@ -0,0 +1,110 @@
+# 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!
+
+Features:
+* --set-keyless option (#215)
+* Replace `\n`, `\t`, `\e` and `\\` in user provided strings, just like c would do it (#215)
+* APK (Alpine Package Keeper) support (@mxkrsv, #216)
+
+Logos:
+* Alma Linux (@jonathanspw, #214)
+
+Bugfixes:
+* replace deprecated gethostbyname call with getaddrinfo (#217)
+
+# 1.6.3
+
+Fixes installing presets in their own directory (@ceamac, #212)
+
+# 1.6.2
+
+Releasing this, so void linux can package fastfetch.
+
+Logos:
+* Rosa linux (#206)
+* KISS linux (@draumaz, #207)
+* LangitKetujuh (@hervyqa, #208)
+
+Bugfixes:
+* Using musl as libc does work now (#210)
+* XBPS packages are once again printed (#209)
+* configured target dirs are applied to install directories too
+* empty XDG_* env vars don't cause a crash anymore
+
+# 1.6.1
+
+Fixes build on android (#205)
+
+# 1.6.0
+
+Features:
+* Detect QT on more DEs than just KDE Plasma. The [Plasma] category was therefore renamed to [QT]
+* Alacritty font detection
+* Load `/etc/fastfetch/config.conf` before user config
+* Disk: print one decimal point if size < 100GB
+* `--title-fqdn` option, to print fully qualified domain name instead of host name in title
+ 
+Logos:
+* updated old NixOS logo
+
+Bugfixes:
+* Correctly detect GTK on DEs that store their settings in dconf
+* Correctly detect NixOS packages
+* Mutter WM detected once again
+* Show full NixOS version in OS output
+* Don't segfault if an invalid structure is given
+* WSL doesn't output GPU anymore, as the name is always meaningless

CMakeLists.txt

@@ -1,51 +1,92 @@
-cmake_minimum_required(VERSION 3.1.0) # Threads::Threads
+cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url
 
 project(fastfetch
-    VERSION 1.5.1
+    VERSION 1.7.1
     LANGUAGES C
+    DESCRIPTION "Fast system information tool"
+    HOMEPAGE_URL "https://github.com/LinusDierheimer/fastfetch"
 )
 
+###################
+# Target Platform #
+###################
+
+if(APPLE OR ANDROID)
+    set(LINUX FALSE CACHE BOOL "..." FORCE) # Linux true means we have full linux userland, not just the kernel
+elseif(UNIX)
+    set(LINUX TRUE CACHE BOOL "..." FORCE)
+else()
+    message(FATAL_ERROR "Unsupported platform")
+endif()
+
+#####################
+# Configure options #
+#####################
+
+include(CMakeDependentOption)
+
+cmake_dependent_option(ENABLE_LIBPCI "Enable libpci" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE" OFF)
+cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_XCB "Enable xcb" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_X11 "Enable x11" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_RPM "Enable rpm" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_CHAFA "Enable chafa" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
+cmake_dependent_option(ENABLE_ZLIB "Enable zlib" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
+cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX" OFF)
+
+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 #
+#############################
+
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 
 find_package(PkgConfig REQUIRED)
 
-# This is set to off by github actions for release builds
-OPTION(SET_TWEAK "Add tweak to project version" ON)
+include(CheckIncludeFile)
 
-# Also create test executables
-OPTION(BUILD_TESTS "Build tests" OFF)
-
-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)
+####################
+# Compiler options #
+####################
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
 endif()
 
+set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wconversion")
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "-Wl,-O3")
+if(APPLE AND DEFINED ENV{HOMEBREW_PREFIX})
+    # Used for dlopen finding dylibs installed by homebrew, reversed for future usage
+    # `/opt/homebrew/lib` is not on dlopen search path by default
+    set(CMAKE_EXE_LINKER_FLAGS "-Wl,-rpath,$ENV{HOMEBREW_PREFIX}/lib")
+endif()
+
+include(CheckIPOSupported)
+check_ipo_supported(RESULT IPO_SUPPORTED)
+if(IPO_SUPPORTED)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+endif()
+
+#######################
+# Target FS structure #
+#######################
 
-# These variables are mainly here for android, which has a different root fs structure.
 if(NOT TARGET_DIR_ROOT)
     if(NOT ANDROID)
         set(TARGET_DIR_ROOT "")
@@ -63,22 +104,19 @@ 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()
 
-function(fastfetch_load_text FILENAME OUTVAR)
-    file(READ "${FILENAME}" TEMP)
-    string(REPLACE "\n" "\\n" TEMP "${TEMP}")
-    string(REPLACE "\"" "\\\"" TEMP "${TEMP}")
-    string(REPLACE "$\\" "" TEMP "${TEMP}")
-    set("${OUTVAR}" "${TEMP}" PARENT_SCOPE)
-endfunction(fastfetch_load_text)
+#################
+# Tweak version #
+#################
 
-# Track commits between version bumps for output in --version
 if (SET_TWEAK AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
     execute_process(
         COMMAND git describe --tags
@@ -89,24 +127,42 @@ if (SET_TWEAK AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
     string(REGEX MATCH "-[0-9]+" PROJECT_VERSION_TWEAK "${PROJECT_VERSION_TWEAK}")
 endif()
 
+#############
+# Text data #
+#############
+
+function(fastfetch_load_text FILENAME OUTVAR)
+    file(READ "${FILENAME}" TEMP)
+    string(REPLACE "\n" "\\n" TEMP "${TEMP}")
+    string(REPLACE "\"" "\\\"" TEMP "${TEMP}")
+    string(REPLACE "$\\" "" TEMP "${TEMP}")
+    set("${OUTVAR}" "${TEMP}" PARENT_SCOPE)
+endfunction(fastfetch_load_text)
+
 fastfetch_load_text(src/data/structure.txt DATATEXT_STRUCTURE)
-fastfetch_load_text(src/data/config.txt DATATEXT_CONFIG)
+fastfetch_load_text(src/data/config_system.txt DATATEXT_CONFIG_SYSTEM)
+fastfetch_load_text(src/data/config_user.txt DATATEXT_CONFIG_USER)
 fastfetch_load_text(src/data/modules.txt DATATEXT_MODULES)
 fastfetch_load_text(src/data/help.txt DATATEXT_HELP)
 fastfetch_load_text(src/data/help_color.txt DATATEXT_HELP_COLOR)
 fastfetch_load_text(src/data/help_format.txt DATATEXT_HELP_FORMAT)
 fastfetch_load_text(src/data/help_config.txt DATATEXT_HELP_CONFIG)
 
+######################
+# Configure config.h #
+######################
+
 configure_file(src/fastfetch_config.h.in fastfetch_config.h)
 
-# Init CMake targets
+#######################
+# libfastfetch target #
+#######################
 
-add_library(libfastfetch STATIC
+set(LIBFASTFETCH_SRC
     src/util/FFstrbuf.c
     src/util/FFlist.c
     src/util/FFvaluestore.c
     src/common/init.c
-    src/common/threading.c
     src/common/io.c
     src/common/printing.c
     src/common/caching.c
@@ -123,18 +179,20 @@ add_library(libfastfetch STATIC
     src/logo/image/image.c
     src/logo/image/im7.c
     src/logo/image/im6.c
-    src/detection/os.c
-    src/detection/plasma.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/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/temps.c
+    src/detection/title.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/displayserver/displayserver.c
     src/modules/break.c
     src/modules/custom.c
     src/modules/title.c
@@ -176,245 +234,102 @@ add_library(libfastfetch STATIC
     src/modules/opencl.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(APPLE)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/host/host_apple.c
+        src/detection/os/os_apple.c
+        src/detection/cpu/cpu_apple.c
+        src/detection/gpu/gpu_apple.c
+        src/detection/memory/memory_apple.c
+        src/detection/displayserver/displayserver_apple.c
+    )
+elseif(ANDROID)
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/host/host_android.c
+        src/detection/os/os_android.c
+        src/detection/cpu/cpu_linux.c
+        src/detection/gpu/gpu_android.c
+        src/detection/memory/memory_linux.c
+        src/detection/displayserver/displayserver_android.c
+    )
+else()
+    list(APPEND LIBFASTFETCH_SRC
+        src/detection/host/host_linux.c
+        src/detection/os/os_linux.c
+        src/detection/cpu/cpu_linux.c
+        src/detection/gpu/gpu_linux.c
+        src/detection/memory/memory_linux.c
+        src/detection/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
+    )
 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()
+add_library(libfastfetch OBJECT
+    ${LIBFASTFETCH_SRC}
+)
+
+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_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()
-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()
-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()
-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()
-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()
-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()
-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()
-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)
-    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()
-
-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(LIBNAME ${ARGN})
+        pkg_check_modules(${VARNAME} ${LIBNAME})
+        if(${VARNAME}_FOUND)
+            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_${VARNAME}=1)
+            target_include_directories(libfastfetch PRIVATE ${${VARNAME}_INCLUDE_DIRS})
+            target_link_directories(libfastfetch PRIVATE ${${VARNAME}_LIBRARY_DIRS})
+            return()
         endif()
-    else()
-        message(WARNING "Chafa not enabled, because neither ImageMagick6 nor ImageMagick7 were found. Building without support.")
-    endif()
-endif()
+    endforeach()
 
-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()
+    message(WARNING "Package ${ARGV1} not found, building without support.")
+endfunction()
 
-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()
+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 /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16HDRI.pc /usr/lib/imagemagick7/pkgconfig/MagickCore-7.Q16.pc)
+ff_lib_enable(IMAGEMAGICK6 MagickCore-6.Q16HDRI MagickCore-6.Q16 /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16HDRI.pc /usr/lib/imagemagick6/pkgconfig/MagickCore-6.Q16.pc)
+ff_lib_enable(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)
 
-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"
+    )
 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
@@ -422,7 +337,9 @@ target_link_libraries(libfastfetch
     PRIVATE Threads::Threads
 )
 
-set_target_properties(libfastfetch PROPERTIES OUTPUT_NAME "fastfetch")
+######################
+# Executable targets #
+######################
 
 add_executable(fastfetch
     src/fastfetch.c
@@ -438,16 +355,11 @@ target_link_libraries(flashfetch
     PRIVATE libfastfetch
 )
 
-# Testing
+###################
+# Testing targets #
+###################
 
 if (BUILD_TESTS)
-    add_executable(fastfetch-test-performance
-        tests/performance.c
-    )
-    target_link_libraries(fastfetch-test-performance
-        PRIVATE libfastfetch
-    )
-
     add_executable(fastfetch-test-strbuf
         tests/strbuf.c
     )
@@ -459,67 +371,74 @@ if (BUILD_TESTS)
     add_test(NAME test-strbuf COMMAND fastfetch-test-strbuf)
 endif()
 
-# Installation
+##################
+# install target #
+##################
+
+#https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.html
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set(CMAKE_INSTALL_PREFIX "${TARGET_DIR_USR}" CACHE PATH "..." FORCE)
+endif()
+
+if(NOT CMAKE_INSTALL_SYSCONFDIR)
+    set(CMAKE_INSTALL_SYSCONFDIR "${TARGET_DIR_ROOT}/etc" CACHE PATH "..." FORCE)
+endif()
 
 include(GNUInstallDirs)
 
 install(
-    TARGETS fastfetch
-    DESTINATION ${CMAKE_INSTALL_BINDIR}
+    TARGETS fastfetch flashfetch
+    DESTINATION "${CMAKE_INSTALL_BINDIR}"
 )
 
 install(
-    TARGETS flashfetch
-    DESTINATION ${CMAKE_INSTALL_BINDIR}
+    FILES "${CMAKE_SOURCE_DIR}/src/data/config_system.txt"
+    DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/${CMAKE_PROJECT_NAME}"
+    RENAME "config.conf"
 )
 
 install(
-    FILES completions/bash
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions
-    RENAME ${CMAKE_PROJECT_NAME}
+    FILES "${CMAKE_SOURCE_DIR}/completions/bash"
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions"
+    RENAME "${CMAKE_PROJECT_NAME}"
 )
 
 install(
-    DIRECTORY presets
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}
+    DIRECTORY "${CMAKE_SOURCE_DIR}/presets"
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}"
 )
 
 install(
-    FILES ./LICENSE
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}
+    FILES "${CMAKE_SOURCE_DIR}/LICENSE"
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}"
 )
 
-# Packaging
+##################
+# 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)
+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_DEBIAN_PACKAGE_RECOMMENDS "\
-libpci3, \
-libvulkan1, \
-libwayland-client0, \
-libxcb-randr0, \
-xcb, \
-libxrandr2, \
-libx11-6, \
-libdconf1, \
-libglib2.0-0, \
-libdbus-1-3, \
-libxfconf-0-3, \
-libmagickcore-6.q16hdri-6, \
-zlib1g \
-")
-
-set(CPACK_RPM_PACKAGE_LICENSE "MIT")
 
 include(CPack)

DEVELOPMENT.md

@@ -12,8 +12,6 @@ Here i just add things that are easy to forget.
   - `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.
-- [ ] Expose temperatures to CPU format string
-- [ ] Expose temperatures to GPU format string
 - [ ] 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

README.md

@@ -1,9 +1,14 @@
-# fastfetch
+# <center> Fastfetch </center>
 
-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 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
 
@@ -45,12 +50,12 @@ All categories not listed here should work without needing a specific implementa
 
 ##### 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, Player, Media, Vulkan, OpenGL, OpenCL, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
 ```
 
 ##### Logos
 ```
-Android, Arch, Arco, Artix, Bedrock, CachyOS, CentOS, Debian, Devuan, Deepin, Endeavour, Fedora, Garuda, Gentoo, KDE Neon, Kubuntu, Linux, Manjaro, Mint, NixOS, OpenSUSE, OpenSUSE Tumbleweed, OpenSUSE LEAP, Pop!_OS, RebornOS, RedstarOS, Rocky, Ubuntu, Void, Zorin
+AlmaLinux, Alpine, Android, Arch, Arco, Artix, Bedrock, CachyOS, CentOS, Debian, Devuan, Deepin, Endeavour, Fedora, Garuda, Gentoo, KDE Neon, KISS, Kubuntu, LangitKetujuh, Linux, MacOS, Manjaro, Mint, MSYS2, NixOS, OpenSUSE, OpenSUSE Tumbleweed, OpenSUSE LEAP, Pop!_OS, RebornOS, RedstarOS, Rocky, Rosa, Slackware, Ubuntu, Void, Zorin
 ```
 * 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.
@@ -60,7 +65,7 @@ Android, Arch, Arco, Artix, Bedrock, CachyOS, CentOS, Debian, Devuan, Deepin, En
 
 ##### Package managers
 ```
-Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap
+Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap, apk, brew
 ```
 
 ##### WM themes
@@ -75,7 +80,7 @@ KDE Plasma, Gnome, Cinnamon, Mate, XFCE4, LXQt
 
 ##### Terminal fonts
 ```
-konsole, gnome-terminal-server, tilix, xfce4-terminal, lxterminal, TTY
+konsole, gnome-terminal-server, tilix, xfce4-terminal, alacritty, lxterminal, TTY
 ```
 
 ## Building
@@ -85,20 +90,21 @@ fastfetch uses [`cmake`](https://cmake.org/) and [`pkg-config`](https://www.free
 mkdir -p build
 cd build
 cmake ..
-cmake --build . -j$(nproc) --target fastfetch --target flashfetch
+cmake --build . --target fastfetch --target flashfetch
 ```
 
 If pkg-config fails to find the headers for a library listed in [dependencies](#dependencies), fastfetch will simply build without support for that specific feature. This means, it won't look for it at runtime and just act like it isn't available.
 
 ## Packaging
 
-* [AUR](https://aur.archlinux.org/packages/fastfetch-git/): Packaged by me. Will install the fastfetch binary, bash completion and the presets. Git version
-* [Manjaro Repositories](https://gitlab.manjaro.org/packages/community/fastfetch): Packaged by a manjaro maintainer. Usually a bit outdated.
-* [Gentoo (Guru)](https://github.com/gentoo/guru/tree/master/app-misc/fastfetch): Packed by some other guy. May be out of date some times.
-* DEB / RPM: Run `cmake -B build && cmake --build build --target package` to build the packages in build.
-* Manually:
-    * Build: Follow the [build instructions](#building).
-    * Install: `sudo cmake --install build --prefix /usr/local`
+### Repositories
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/fastfetch.svg?header=)](https://repology.org/project/fastfetch/versions)
+
+### Manual
+
+* DEB / RPM package: `cmake --build . --target package`
+* Install directly: `cmake --install . --prefix /usr/local`
 
 ## FAQ
 

completions/bash

@@ -9,28 +9,38 @@ __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"
         "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 +67,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 +109,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
@@ -108,7 +156,8 @@ __fastfetch_completion()
         "--list-presets"
         "--list-features"
         "--print-logos"
-        "--print-config"
+        "--print-config-system"
+        "--print-config-user"
         "--print-structure"
     )
 
@@ -132,6 +181,8 @@ __fastfetch_completion()
         "--localip-show-loop"
         "--escape-bedrock"
         "--pipe"
+        "--title-fqdn"
+        "--escape-bedrock"
     )
 
     local FF_OPTIONS_STRING=(
@@ -147,99 +198,141 @@ __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"
-        "--gl"
-        "--os-format"
+        "--set-keyless"
+        "--player-name"
+        "--public-ip-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"
         "--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"
         "--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"
+        "--opencl-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"
@@ -250,7 +343,6 @@ __fastfetch_completion()
         "--lib-osmesa"
         "--lib-opencl"
         "--battery-dir"
-        "--load-config"
     )
 
     local FF_OPTIONS_LOGO=(
@@ -258,6 +350,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
@@ -274,9 +378,14 @@ __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
-}
 
 complete -F __fastfetch_completion fastfetch

presets/all

@@ -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:Player:Song:PublicIP:LocalIP:DateTime:Locale:Vulkan:OpenGL:OpenCL:Break:Colors

presets/devinfo

@@ -1,4 +1,4 @@
 --disable-linewrap false
 --multithreading false
---show-errors true
+--show-errors
 --recache

presets/devinfo-verbose

@@ -1,2 +1,3 @@
---load-config verbose
 --load-config devinfo
+--load-config all
+--load-config verbose

presets/examples/1

@@ -0,0 +1 @@
+# Load with --load-config examples/1

presets/examples/2

@@ -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 "  "

presets/examples/3

@@ -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

presets/examples/4

@@ -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

presets/examples/5

@@ -0,0 +1,12 @@
+# 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
+--font-format {21}
+--cursor-key C

presets/verbose

@@ -1,31 +1,29 @@
---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: {}; Name: {}; Version: {}"
---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: {}; bios: {}; scaling max: {}; scaling min: {}; info max: {}; info min: {}; cpuinfo: {}; frequency: {}"
---cpu-usage-format "Percentage: {}"
---gpu-format "Vendor: {}; Vendor pretty: {}; Name: {}; Name pretty: {}; Driver: {}"
---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 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: {}, Vendor: {}, CoresPhysical: {}, CoresLogical: {}, CoresOnline: {}, FrequencyMin: {}, FrequencyMax: {}, Temperature: {}
+--cpu-usage-format Percentage: {}
+--gpu-format Vendor: {}; Name: {}; Driver: {}; Temperature: {}
+--memory-format Used: {}; Total: {}; Percentage: {}
+--disk-format Used: {}; Total: {}; Files: {}; Percentage: {}
+--battery-format Manufactor: {}; Model: {}; Technology: {}; Capacity: {}; Status: {}
+--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: {}

run.sh

@@ -1,4 +1,9 @@
-#!/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 ..

src/common/caching.c

@@ -1,9 +1,19 @@
 #include "fastfetch.h"
+#include "common/caching.h"
+#include "common/io.h"
+#include "common/printing.h"
+
+#include <stdlib.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"
 
-static void getCacheFilePath(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
+#define FF_CACHE_EXTENSION_DATA "ffcd"
+
+static void getCacheFilePath(const FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
 {
     ffStrbufAppend(buffer, &instance->state.cacheDir);
     ffStrbufAppendS(buffer, moduleName);
@@ -20,7 +30,7 @@ static void readCacheFile(FFinstance* instance, const char* moduleName, const ch
     FFstrbuf path;
     ffStrbufInitA(&path, 64);
     getCacheFilePath(instance, moduleName, extension, &path);
-    ffAppendFileContent(path.chars, buffer);
+    ffAppendFileBuffer(path.chars, buffer);
     ffStrbufDestroy(&path);
 }
 
@@ -29,7 +39,7 @@ static void writeCacheFile(FFinstance* instance, const char* moduleName, const c
     FFstrbuf path;
     ffStrbufInitA(&path, 64);
     getCacheFilePath(instance, moduleName, extension, &path);
-    ffWriteFileContent(path.chars, content);
+    ffWriteFileBuffer(path.chars, content);
     ffStrbufDestroy(&path);
 }
 
@@ -37,9 +47,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;
@@ -47,9 +59,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);
 }
 
@@ -77,7 +89,7 @@ void ffCacheClose(FFcache* cache)
         fclose(cache->split);
 }
 
-static bool printCachedValue(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat)
+static bool printCachedValue(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs)
 {
     FFstrbuf content;
     ffStrbufInitA(&content, 512);
@@ -95,7 +107,7 @@ static bool printCachedValue(FFinstance* instance, const char* moduleName, const
     {
         uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
         uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, &moduleArgs->key);
         puts(content.chars + startIndex);
         startIndex = nullByteIndex + 1;
         ++moduleCounter;
@@ -106,7 +118,7 @@ static bool printCachedValue(FFinstance* instance, const char* moduleName, const
     return moduleCounter > 1;
 }
 
-static bool printCachedFormat(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
+static bool printCachedFormat(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, uint32_t numArgs)
 {
     FFstrbuf content;
     ffStrbufInitA(&content, 512);
@@ -134,7 +146,7 @@ static bool printCachedFormat(FFinstance* instance, const char* moduleName, cons
         if(argumentCounter == numArgs)
         {
             uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-            ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
+            ffPrintFormat(instance, moduleName, moduleIndex, moduleArgs, numArgs, arguments);
             ++moduleCounter;
             argumentCounter = 0;
         }
@@ -148,27 +160,27 @@ static bool printCachedFormat(FFinstance* instance, const char* moduleName, cons
     return moduleCounter > 1;
 }
 
-bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
+bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, uint32_t numArgs)
 {
     if(instance->config.recache)
         return false;
 
-    if(formatString == NULL || formatString->length == 0)
-        return printCachedValue(instance, moduleName, customKeyFormat);
+    if(moduleArgs->outputFormat.length == 0)
+        return printCachedValue(instance, moduleName, moduleArgs);
     else
-        return printCachedFormat(instance, moduleName, customKeyFormat, formatString, numArgs);
+        return printCachedFormat(instance, moduleName, moduleArgs, numArgs);
 }
 
-void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, FFcache* cache, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFcache* cache, const FFstrbuf* value, uint32_t numArgs, const FFformatarg* arguments)
 {
-    if(formatString == NULL || formatString->length == 0)
+    if(moduleArgs->outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, &moduleArgs->key);
         ffStrbufPutTo(value, stdout);
     }
     else
     {
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
+        ffPrintFormat(instance, moduleName, moduleIndex, moduleArgs, numArgs, arguments);
     }
 
     if(cache->value != NULL)
@@ -191,10 +203,32 @@ void ffPrintAndAppendToCache(FFinstance* instance, const char* moduleName, uint8
     }
 }
 
-void ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, 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)
 {
     FFcache cache;
     ffCacheOpenWrite(instance, moduleName, &cache);
-    ffPrintAndAppendToCache(instance, moduleName, 0, customKeyFormat, &cache, value, formatString, numArgs, arguments);
+    ffPrintAndAppendToCache(instance, moduleName, 0, moduleArgs, &cache, value, numArgs, arguments);
     ffCacheClose(&cache);
 }
+
+void ffCachingWriteData(const FFinstance* instance, const char* moduleName, size_t dataSize, const void* data)
+{
+    FFstrbuf path;
+    ffStrbufInitA(&path, 128);
+    getCacheFilePath(instance, moduleName, FF_CACHE_EXTENSION_DATA, &path);
+    ffWriteFileData(path.chars, dataSize, data);
+    ffStrbufDestroy(&path);
+}
+
+bool ffCachingReadData(const FFinstance* instance, const char* moduleName, size_t dataSize, void* data)
+{
+    if(instance->config.recache)
+        return false;
+
+    FFstrbuf path;
+    ffStrbufInitA(&path, 128);
+    getCacheFilePath(instance, moduleName, FF_CACHE_EXTENSION_DATA, &path);
+    ssize_t result = ffReadFileData(path.chars, dataSize, data);
+    ffStrbufDestroy(&path);
+    return result > 0 && (size_t) result == dataSize;
+}

src/common/caching.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_caching
+#define FF_INCLUDED_common_caching
+
+#include "fastfetch.h"
+#include "common/format.h"
+
+typedef struct FFcache
+{
+    FILE* value;
+    FILE* split;
+} FFcache;
+
+void ffCacheValidate(FFinstance* instance);
+
+void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache);
+void ffCacheClose(FFcache* cache);
+
+bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs, uint32_t numArgs);
+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);
+
+#endif

src/common/font.c

@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "common/font.h"
 
 #include <string.h>
 
@@ -188,13 +189,21 @@ void ffFontInitPango(FFfont* font, const char* data)
     fontInitPretty(font);
 }
 
-void ffFontInitCopy(FFfont* font, const char* name)
+void ffFontInitValues(FFfont* font, const char* name, const char* size)
 {
     fontInit(font);
+
     ffStrbufAppendS(&font->name, name);
+    ffStrbufAppendS(&font->size, size);
+
     fontInitPretty(font);
 }
 
+void ffFontInitCopy(FFfont* font, const char* name)
+{
+    ffFontInitValues(font, name, NULL);
+}
+
 void ffFontDestroy(FFfont* font)
 {
     ffStrbufDestroy(&font->pretty);

src/common/font.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_font
+#define FF_INCLUDED_common_font
+
+#include "util/FFstrbuf.h"
+#include "util/FFlist.h"
+
+typedef struct FFfont
+{
+    FFstrbuf pretty;
+    FFstrbuf name;
+    FFstrbuf size;
+    FFlist styles;
+} FFfont;
+
+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 ffFontDestroy(FFfont* font);
+
+#endif

src/common/format.c

@@ -1,4 +1,6 @@
 #include "fastfetch.h"
+#include "common/format.h"
+#include "common/parsing.h"
 
 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
 {
@@ -32,15 +34,6 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
     }
 }
 
-static inline bool placeholderValueIsForError(const FFstrbuf* placeholderValue)
-{
-    return
-        ffStrbufIgnCaseCompS(placeholderValue, "e") == 0 ||
-        ffStrbufIgnCaseCompS(placeholderValue, "error") == 0 ||
-        ffStrbufIgnCaseCompS(placeholderValue, "0") == 0
-    ;
-}
-
 static inline uint32_t getArgumentIndex(const FFstrbuf* placeholderValue)
 {
     uint32_t result = UINT32_MAX;
@@ -71,17 +64,17 @@ static inline void appendEmptyPlaceholder(FFstrbuf* buffer, const char* placehol
 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 > 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)
     );
 }
 
-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments)
+void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments)
 {
     uint32_t argCounter = 0;
 
@@ -128,13 +121,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         while(i < formatstr->length && formatstr->chars[i] != '}')
             ffStrbufAppendC(&placeholderValue, formatstr->chars[i++]);
 
-        // test for error, if so print it
-        if(placeholderValueIsForError(&placeholderValue)) {
-            ffStrbufAppend(buffer, error);
-            ffStrbufDestroy(&placeholderValue);
-            continue;
-        }
-
          // test if for stop, if so break the loop
         if(placeholderValue.length == 1 && placeholderValue.chars[0] == '-')
         {
@@ -186,14 +172,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            // continue if an error is set
-            if(placeholderValueIsForError(&placeholderValue) && error != NULL && error->length > 0)
-            {
-                ++numOpenIfs;
-                ffStrbufDestroy(&placeholderValue);
-                continue;
-            }
-
             uint32_t index = getArgumentIndex(&placeholderValue);
 
             // testing for an invalid index
@@ -223,14 +201,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
         {
             ffStrbufSubstrAfter(&placeholderValue, 0);
 
-            //continue if an error os not set
-            if(placeholderValueIsForError(&placeholderValue) && (error == NULL || error->length == 0))
-            {
-                ++numOpenNotIfs;
-                ffStrbufDestroy(&placeholderValue);
-                continue;
-            }
-
             uint32_t index = getArgumentIndex(&placeholderValue);
 
             // testing for an invalid index

src/common/format.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_format
+#define FF_INCLUDED_common_format
+
+typedef enum FFformatargtype
+{
+    FF_FORMAT_ARG_TYPE_NULL = 0,
+    FF_FORMAT_ARG_TYPE_UINT,
+    FF_FORMAT_ARG_TYPE_UINT16,
+    FF_FORMAT_ARG_TYPE_UINT8,
+    FF_FORMAT_ARG_TYPE_INT,
+    FF_FORMAT_ARG_TYPE_STRING,
+    FF_FORMAT_ARG_TYPE_STRBUF,
+    FF_FORMAT_ARG_TYPE_DOUBLE,
+    FF_FORMAT_ARG_TYPE_LIST
+} FFformatargtype;
+
+typedef struct FFformatarg
+{
+    FFformatargtype type;
+    const void* value;
+} FFformatarg;
+
+void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
+void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments);
+
+#endif

src/common/init.c

@@ -1,8 +1,15 @@
 #include "fastfetch.h"
+#include "common/caching.h"
+#include "common/parsing.h"
+#include "detection/qt.h"
+#include "detection/gtk.h"
+#include "detection/displayserver/displayserver.h"
 
+#include <stdlib.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <signal.h>
+#include <pthread.h>
 
 static bool strbufEqualsAdapter(const void* first, const void* second)
 {
@@ -14,18 +21,14 @@ static void initConfigDirs(FFstate* state)
     ffListInit(&state->configDirs, sizeof(FFstrbuf));
 
     const char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
-    if(xdgConfigHome != NULL)
+    if(ffStrSet(xdgConfigHome))
     {
         FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
         ffStrbufInitA(buffer, 64);
         ffStrbufAppendS(buffer, xdgConfigHome);
-        ffStrbufTrimRight(buffer, '/');
+        ffStrbufEnsureEndsWithC(buffer, '/');
     }
 
-    FFstrbuf xdgConfigDirs;
-    ffStrbufInitA(&xdgConfigDirs, 64);
-    ffStrbufAppendS(&xdgConfigDirs, getenv("XDG_CONFIG_DIRS"));
-
     #define FF_ENSURE_ONLY_ONCE_IN_LIST(element) \
         if(ffListFirstIndexComp(&state->configDirs, element, strbufEqualsAdapter) < state->configDirs.length - 1) \
             --state->configDirs.length;
@@ -33,24 +36,35 @@ static void initConfigDirs(FFstate* state)
     FFstrbuf* userConfigHome = ffListAdd(&state->configDirs);
     ffStrbufInitA(userConfigHome, 64);
     ffStrbufAppendS(userConfigHome, state->passwd->pw_dir);
-    ffStrbufAppendS(userConfigHome, "/.config");
+    ffStrbufAppendS(userConfigHome, "/.config/");
     FF_ENSURE_ONLY_ONCE_IN_LIST(userConfigHome)
 
     FFstrbuf* userHome = ffListAdd(&state->configDirs);
     ffStrbufInitA(userHome, 64);
     ffStrbufAppendS(userHome, state->passwd->pw_dir);
+    ffStrbufEnsureEndsWithC(userHome, '/');
     FF_ENSURE_ONLY_ONCE_IN_LIST(userHome)
 
+    FFstrbuf xdgConfigDirs;
+    ffStrbufInitA(&xdgConfigDirs, 64);
+    ffStrbufAppendS(&xdgConfigDirs, getenv("XDG_CONFIG_DIRS"));
+
     uint32_t startIndex = 0;
     while (startIndex < xdgConfigDirs.length)
     {
         uint32_t colonIndex = ffStrbufNextIndexC(&xdgConfigDirs, startIndex, ':');
         xdgConfigDirs.chars[colonIndex] = '\0';
 
+        if(!ffStrSet(xdgConfigDirs.chars + startIndex))
+        {
+            startIndex = colonIndex + 1;
+            continue;
+        }
+
         FFstrbuf* buffer = (FFstrbuf*) ffListAdd(&state->configDirs);
         ffStrbufInitA(buffer, 64);
         ffStrbufAppendS(buffer, xdgConfigDirs.chars + startIndex);
-        ffStrbufTrimRight(buffer, '/');
+        ffStrbufEnsureEndsWithC(buffer, '/');
         FF_ENSURE_ONLY_ONCE_IN_LIST(buffer);
 
         startIndex = colonIndex + 1;
@@ -58,12 +72,12 @@ static void initConfigDirs(FFstate* state)
 
     FFstrbuf* systemConfigHome = ffListAdd(&state->configDirs);
     ffStrbufInitA(systemConfigHome, 64);
-    ffStrbufAppendS(systemConfigHome, FASTFETCH_TARGET_DIR_ROOT"/etc/xdg");
+    ffStrbufAppendS(systemConfigHome, FASTFETCH_TARGET_DIR_ROOT"/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_ROOT"/etc/");
     FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfig)
 
     #undef FF_ENSURE_ONLY_ONCE_IN_LIST
@@ -80,8 +94,8 @@ static void initCacheDir(FFstate* state)
         ffStrbufAppendS(&state->cacheDir, state->passwd->pw_dir);
         ffStrbufAppendS(&state->cacheDir, "/.cache/");
     }
-    else if(!ffStrbufEndsWithC(&state->cacheDir, '/'))
-        ffStrbufAppendC(&state->cacheDir, '/');
+    else
+        ffStrbufEnsureEndsWithC(&state->cacheDir, '/');
 
     mkdir(state->cacheDir.chars, S_IRWXU | S_IXGRP | S_IRGRP | S_IXOTH | S_IROTH); //I hope everybody has a cache folder, but who knows
 
@@ -96,25 +110,37 @@ 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);
 }
 
+static void initModuleArg(FFModuleArgs* args)
+{
+    ffStrbufInitA(&args->key, 0);
+    ffStrbufInitA(&args->outputFormat, 0);
+    ffStrbufInitA(&args->errorFormat, 0);
+}
+
 static void defaultConfig(FFinstance* instance)
 {
-    ffStrbufInit(&instance->config.logoSource);
-    instance->config.logoType = FF_LOGO_TYPE_AUTO;
+    ffStrbufInit(&instance->config.logo.source);
+    instance->config.logo.type = FF_LOGO_TYPE_AUTO;
     for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
-        ffStrbufInit(&instance->config.logoColors[i]);
-    instance->config.logoWidth = 0;
-    instance->config.logoHeight = 0; //preserve aspect ratio
-    instance->config.logoPaddingLeft = 0;
-    instance->config.logoPaddingRight = 4;
-    instance->config.logoPrintRemaining = true;
+        ffStrbufInit(&instance->config.logo.colors[i]);
+    instance->config.logo.width = 0;
+    instance->config.logo.height = 0; //preserve aspect ratio
+    instance->config.logo.paddingLeft = 0;
+    instance->config.logo.paddingRight = 4;
+    instance->config.logo.printRemaining = true;
+
+    ffStrbufInit(&instance->config.colorKeys);
+    ffStrbufInit(&instance->config.colorTitle);
 
-    ffStrbufInit(&instance->config.mainColor);
     ffStrbufInit(&instance->config.separator);
     ffStrbufAppendS(&instance->config.separator, ": ");
 
@@ -125,77 +151,46 @@ 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;
 
-    ffStrbufInitA(&instance->config.osFormat, 0);
-    ffStrbufInitA(&instance->config.osKey, 0);
-    ffStrbufInitA(&instance->config.hostFormat, 0);
-    ffStrbufInitA(&instance->config.hostKey, 0);
-    ffStrbufInitA(&instance->config.kernelFormat, 0);
-    ffStrbufInitA(&instance->config.kernelKey, 0);
-    ffStrbufInitA(&instance->config.uptimeFormat, 0);
-    ffStrbufInitA(&instance->config.uptimeKey, 0);
-    ffStrbufInitA(&instance->config.processesFormat, 0);
-    ffStrbufInitA(&instance->config.processesKey, 0);
-    ffStrbufInitA(&instance->config.packagesFormat, 0);
-    ffStrbufInitA(&instance->config.packagesKey, 0);
-    ffStrbufInitA(&instance->config.shellFormat, 0);
-    ffStrbufInitA(&instance->config.shellKey, 0);
-    ffStrbufInitA(&instance->config.resolutionFormat, 0);
-    ffStrbufInitA(&instance->config.resolutionKey, 0);
-    ffStrbufInitA(&instance->config.deFormat, 0);
-    ffStrbufInitA(&instance->config.deKey, 0);
-    ffStrbufInitA(&instance->config.wmFormat, 0);
-    ffStrbufInitA(&instance->config.wmKey, 0);
-    ffStrbufInitA(&instance->config.wmThemeFormat, 0);
-    ffStrbufInitA(&instance->config.wmThemeKey, 0);
-    ffStrbufInitA(&instance->config.themeFormat, 0);
-    ffStrbufInitA(&instance->config.themeKey, 0);
-    ffStrbufInitA(&instance->config.iconsFormat, 0);
-    ffStrbufInitA(&instance->config.iconsKey, 0);
-    ffStrbufInitA(&instance->config.fontFormat, 0);
-    ffStrbufInitA(&instance->config.fontKey, 0);
-    ffStrbufInitA(&instance->config.cursorKey, 0);
-    ffStrbufInitA(&instance->config.cursorFormat, 0);
-    ffStrbufInitA(&instance->config.terminalFormat, 0);
-    ffStrbufInitA(&instance->config.terminalKey, 0);
-    ffStrbufInitA(&instance->config.termFontFormat, 0);
-    ffStrbufInitA(&instance->config.termFontKey, 0);
-    ffStrbufInitA(&instance->config.cpuFormat, 0);
-    ffStrbufInitA(&instance->config.cpuKey, 0);
-    ffStrbufInitA(&instance->config.cpuUsageFormat, 0);
-    ffStrbufInitA(&instance->config.cpuUsageKey, 0);
-    ffStrbufInitA(&instance->config.gpuFormat, 0);
-    ffStrbufInitA(&instance->config.gpuKey, 0);
-    ffStrbufInitA(&instance->config.memoryFormat, 0);
-    ffStrbufInitA(&instance->config.memoryKey, 0);
-    ffStrbufInitA(&instance->config.diskFormat, 0);
-    ffStrbufInitA(&instance->config.diskKey, 0);
-    ffStrbufInitA(&instance->config.batteryFormat, 0);
-    ffStrbufInitA(&instance->config.batteryKey, 0);
-    ffStrbufInitA(&instance->config.localeFormat, 0);
-    ffStrbufInitA(&instance->config.localeKey, 0);
-    ffStrbufInitA(&instance->config.localIpKey, 0);
-    ffStrbufInitA(&instance->config.localIpFormat, 0);
-    ffStrbufInitA(&instance->config.publicIpKey, 0);
-    ffStrbufInitA(&instance->config.publicIpFormat, 0);
-    ffStrbufInitA(&instance->config.playerKey, 0);
-    ffStrbufInitA(&instance->config.playerFormat, 0);
-    ffStrbufInitA(&instance->config.songKey, 0);
-    ffStrbufInitA(&instance->config.songFormat, 0);
-    ffStrbufInitA(&instance->config.dateTimeKey, 0);
-    ffStrbufInitA(&instance->config.dateTimeFormat, 0);
-    ffStrbufInitA(&instance->config.dateKey, 0);
-    ffStrbufInitA(&instance->config.dateFormat, 0);
-    ffStrbufInitA(&instance->config.timeKey, 0);
-    ffStrbufInitA(&instance->config.timeFormat, 0);
-    ffStrbufInitA(&instance->config.vulkanKey, 0);
-    ffStrbufInitA(&instance->config.vulkanFormat, 0);
-    ffStrbufInitA(&instance->config.openGLKey, 0);
-    ffStrbufInitA(&instance->config.openGLFormat, 0);
-    ffStrbufInitA(&instance->config.openCLKey, 0);
-    ffStrbufInitA(&instance->config.openCLFormat, 0);
+    initModuleArg(&instance->config.os);
+    initModuleArg(&instance->config.host);
+    initModuleArg(&instance->config.kernel);
+    initModuleArg(&instance->config.uptime);
+    initModuleArg(&instance->config.processes);
+    initModuleArg(&instance->config.packages);
+    initModuleArg(&instance->config.shell);
+    initModuleArg(&instance->config.resolution);
+    initModuleArg(&instance->config.de);
+    initModuleArg(&instance->config.wm);
+    initModuleArg(&instance->config.wmTheme);
+    initModuleArg(&instance->config.theme);
+    initModuleArg(&instance->config.icons);
+    initModuleArg(&instance->config.font);
+    initModuleArg(&instance->config.cursor);
+    initModuleArg(&instance->config.terminal);
+    initModuleArg(&instance->config.terminalFont);
+    initModuleArg(&instance->config.cpu);
+    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.locale);
+    initModuleArg(&instance->config.localIP);
+    initModuleArg(&instance->config.publicIP);
+    initModuleArg(&instance->config.player);
+    initModuleArg(&instance->config.song);
+    initModuleArg(&instance->config.dateTime);
+    initModuleArg(&instance->config.date);
+    initModuleArg(&instance->config.time);
+    initModuleArg(&instance->config.vulkan);
+    initModuleArg(&instance->config.openGL);
+    initModuleArg(&instance->config.openCL);
 
     ffStrbufInitA(&instance->config.libPCI, 0);
     ffStrbufInitA(&instance->config.libVulkan, 0);
@@ -218,6 +213,8 @@ static void defaultConfig(FFinstance* instance)
     ffStrbufInitA(&instance->config.libOSMesa, 0);
     ffStrbufInitA(&instance->config.libOpenCL, 0);
 
+    instance->config.titleFQDN = false;
+
     ffStrbufInitA(&instance->config.diskFolders, 0);
 
     ffStrbufInitA(&instance->config.batteryDir, 0);
@@ -241,6 +238,88 @@ void ffInitInstance(FFinstance* instance)
     defaultConfig(instance);
 }
 
+#if !defined(__ANDROID__)
+
+static void* connectDisplayServerThreadMain(void* instance)
+{
+    ffConnectDisplayServer((FFinstance*)instance);
+    return NULL;
+}
+
+#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);
+    pthread_detach(dsThread);
+
+    pthread_t gtk2Thread;
+    pthread_create(&gtk2Thread, NULL, detectGTK2ThreadMain, instance);
+    pthread_detach(gtk2Thread);
+
+    pthread_t gtk3Thread;
+    pthread_create(&gtk3Thread, NULL, detectGTK3ThreadMain, instance);
+    pthread_detach(gtk3Thread);
+
+    pthread_t gtk4Thread;
+    pthread_create(&gtk4Thread, NULL, detectGTK4ThreadMain, instance);
+    pthread_detach(gtk4Thread);
+
+    pthread_t plasmaThread;
+    pthread_create(&plasmaThread, NULL, detectPlasmaThreadMain, instance);
+    pthread_detach(plasmaThread);
+
+    return NULL;
+}
+
+void startDetectionThreads(FFinstance* instance)
+{
+    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;
 
@@ -262,6 +341,9 @@ static void exitSignalHandler(int signal)
 
 void ffStart(FFinstance* instance)
 {
+    if(instance->config.multithreading)
+        startDetectionThreads(instance);
+
     ffDisableLinewrap = instance->config.disableLinewrap && !instance->config.pipe;
     ffHideCursor = instance->config.hideCursor && !instance->config.pipe;
 
@@ -291,7 +373,7 @@ void ffStart(FFinstance* instance)
 
 void ffFinish(FFinstance* instance)
 {
-    if(instance->config.logoPrintRemaining)
+    if(instance->config.logo.printRemaining)
         ffLogoPrintRemaining(instance);
 
     resetConsole();

src/common/io.c

@@ -1,17 +1,12 @@
 #include "fastfetch.h"
+#include "common/io.h"
 
-#include <stdio.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <fcntl.h>
-#include <stdarg.h>
 #include <termios.h>
 #include <poll.h>
 
-bool ffWriteFDContent(int fd, const FFstrbuf* content)
-{
-    return write(fd, content->chars, content->length) != -1;
-}
-
 static void createSubfolders(const char* fileName)
 {
     FFstrbuf path;
@@ -28,7 +23,12 @@ static void createSubfolders(const char* fileName)
     ffStrbufDestroy(&path);
 }
 
-bool ffWriteFileContent(const char* fileName, const FFstrbuf* content)
+bool ffWriteFDBuffer(int fd, const FFstrbuf* content)
+{
+    return write(fd, content->chars, content->length) != -1;
+}
+
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data)
 {
     int openFlagsModes = O_WRONLY | O_CREAT | O_TRUNC;
     int openFlagsRights = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
@@ -42,14 +42,19 @@ bool ffWriteFileContent(const char* fileName, const FFstrbuf* content)
             return false;
     }
 
-    bool ret = ffWriteFDContent(fd, content);
+    bool ret = write(fd, data, dataSize) != -1;
 
     close(fd);
 
     return ret;
 }
 
-void ffAppendFDContent(int fd, FFstrbuf* buffer)
+bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer)
+{
+    return ffWriteFileData(fileName, buffer->length, buffer->chars);
+}
+
+bool ffAppendFDBuffer(int fd, FFstrbuf* buffer)
 {
     ssize_t readed = 0;
 
@@ -61,7 +66,7 @@ void ffAppendFDContent(int fd, FFstrbuf* buffer)
         (uint32_t) readed == free
     ) {
         buffer->length += (uint32_t) readed;
-        ffStrbufEnsureCapacity(buffer, (buffer->allocated * 2) - 1); // -1 for null terminator
+        ffStrbufEnsureFree(buffer, buffer->allocated - 1); // Doubles capacity every round. -1 for the null byte.
         free = ffStrbufGetFree(buffer);
     }
 
@@ -73,24 +78,40 @@ void ffAppendFDContent(int fd, FFstrbuf* buffer)
 
     ffStrbufTrimRight(buffer, '\n');
     ffStrbufTrimRight(buffer, ' ');
+
+    return readed >= 0;
 }
 
-bool ffAppendFileContent(const char* fileName, FFstrbuf* buffer)
+ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data)
+{
+    int fd = open(fileName, O_RDONLY);
+    if(fd == -1)
+        return -1;
+
+    ssize_t readed = read(fd, data, dataSize);
+
+    close(fd);
+
+    return readed;
+}
+
+bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer)
 {
     int fd = open(fileName, O_RDONLY);
     if(fd == -1)
         return false;
 
-    ffAppendFDContent(fd, buffer);
+    bool ret = ffAppendFDBuffer(fd, buffer);
 
     close(fd);
-    return true;
+
+    return ret;
 }
 
-bool ffGetFileContent(const char* fileName, FFstrbuf* buffer)
+bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer)
 {
     ffStrbufClear(buffer);
-    return ffAppendFileContent(fileName, buffer);
+    return ffAppendFileBuffer(fileName, buffer);
 }
 
 // Not thread safe!

src/common/io.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_io
+#define FF_INCLUDED_common_io
+
+#include <sys/types.h> //mode_t
+
+bool ffWriteFDBuffer(int fd, const FFstrbuf* content);
+bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data);
+bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer);
+
+bool ffAppendFDBuffer(int fd, FFstrbuf* buffer);
+ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data);
+bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer);
+bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer);
+
+bool ffFileExists(const char* fileName, mode_t mode);
+
+// Not thread safe!
+void ffSuppressIO(bool suppress);
+
+void ffGetTerminalResponse(const char* request, const char* format, ...);
+
+#endif

src/common/library.c

@@ -1,11 +1,12 @@
 #include "fastfetch.h"
+#include "common/library.h"
 
 #include <stdarg.h>
 
 static void* libraryLoad(const char* path, int maxVersion)
 {
     void* result = dlopen(path, RTLD_LAZY);
-    if(result != NULL)
+    if(result != NULL || maxVersion < 0)
         return result;
 
     FFstrbuf pathbuf;

src/common/library.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_library
+#define FF_INCLUDED_common_library
+
+#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);\
+    if(libraryObjectName == NULL) \
+        return returnValue;
+
+#define FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, symbolMapping, symbolName, returnValue) \
+    symbolMapping = dlsym(library, #symbolName); \
+    if(symbolMapping == NULL) \
+    { \
+        dlclose(library); \
+        return returnValue; \
+    }
+
+#define FF_LIBRARY_LOAD_SYMBOL(library, 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, ...);
+
+#endif

src/common/networking.c

@@ -1,7 +1,8 @@
 #include "fastfetch.h"
+#include "common/networking.h"
 
-#include <sys/types.h>
 #include <unistd.h>
+#include <sys/time.h>
 #include <sys/socket.h>
 #include <netdb.h>
 
@@ -10,7 +11,6 @@ void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, F
     struct addrinfo hints = {0};
     hints.ai_family = AF_INET;
     hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = 0;
 
     struct addrinfo* addr;
 
@@ -28,7 +28,7 @@ void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, F
     {
         struct timeval timev;
         timev.tv_sec = 0;
-        timev.tv_usec = timeout * 1000; //milliseconds to microseconds
+        timev.tv_usec = (__typeof__(timev.tv_usec)) (timeout * 1000); //milliseconds to microseconds
         setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
     }
 

src/common/networking.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_networking
+#define FF_INCLUDED_common_networking
+
+#include "util/FFstrbuf.h"
+
+void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, FFstrbuf* buffer);
+
+#endif

src/common/parsing.c

@@ -1,17 +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)
@@ -65,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)

src/common/parsing.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#ifndef FF_INCLUDED_parsing_h
+#define FF_INCLUDED_parsing_h
+
+#include <stdint.h>
+
+typedef struct FFVersion
+{
+    uint32_t major;
+    uint32_t minor;
+    uint32_t patch;
+} FFVersion;
+
+#define FF_VERSION_INIT ((FFVersion) {0})
+
+bool ffStrSet(const char* str);
+void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch);
+void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4);
+
+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

src/common/printing.c

@@ -1,15 +1,21 @@
 #include "fastfetch.h"
+#include "common/printing.h"
 
 void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
 {
     ffLogoPrintLine(instance);
 
+    //This is used by --set-keyless, in this case we wan't neither the module name nor the separator
+    if(moduleName == NULL)
+        return;
+
     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
     if(customKeyFormat == NULL || customKeyFormat->length == 0)
     {
         fputs(moduleName, stdout);
@@ -21,10 +27,10 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
     {
         FFstrbuf key;
         ffStrbufInit(&key);
-        ffParseFormatString(&key, customKeyFormat, NULL, 1, (FFformatarg[]){
+        ffParseFormatString(&key, customKeyFormat, 1, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
         });
-        ffStrbufWriteTo(&key, stdout);
+        ffPrintUserString(key.chars);
         ffStrbufDestroy(&key);
     }
 
@@ -37,54 +43,76 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 }
 
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numFormatArgs, const char* message, ...)
-{
-    if(!instance->config.showErrors)
-        return;
-
-    va_list arguments;
-    va_start(arguments, message);
-
-    if(formatString == NULL || formatString->length == 0)
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
-        vprintf(message, arguments);
-        puts(FASTFETCH_TEXT_MODIFIER_RESET);
-    }
-    else
-    {
-        FF_STRBUF_CREATE(error);
-        ffStrbufAppendVF(&error, message, arguments);
-
-        // calloc sets all to 0 and FF_FORMAT_ARG_TYPE_NULL also has value 0 so we don't need to explictly set it
-        FFformatarg* nullArgs = calloc(numFormatArgs, sizeof(FFformatarg));
-
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, &error, numFormatArgs, nullArgs);
-
-        free(nullArgs);
-        ffStrbufDestroy(&error);
-    }
-
-    va_end(arguments);
-}
-
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
 {
     FFstrbuf buffer;
     ffStrbufInitA(&buffer, 256);
 
-    ffParseFormatString(&buffer, formatString, error, numArgs, arguments);
+    ffParseFormatString(&buffer, format, numArgs, arguments);
 
     if(buffer.length > 0)
     {
         ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffStrbufPutTo(&buffer, stdout);
+        ffPrintUserString(buffer.chars);
+        putchar('\n');
     }
 
     ffStrbufDestroy(&buffer);
 }
 
+void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
+{
+    ffPrintFormatString(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->outputFormat, numArgs, arguments);
+}
+
+static void printError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, va_list arguments)
+{
+    bool hasCustomErrorFormat = customErrorFormat != NULL && customErrorFormat->length > 0;
+    if(!hasCustomErrorFormat && !instance->config.showErrors)
+        return;
+
+    if(hasCustomErrorFormat)
+    {
+        FFstrbuf error;
+        ffStrbufInit(&error);
+        ffStrbufAppendVF(&error, message, arguments);
+
+        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, 1, (FFformatarg[]) {
+            {FF_FORMAT_ARG_TYPE_STRBUF, &error}
+        });
+
+        ffStrbufDestroy(&error);
+    }
+    else
+    {
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+
+        if(!instance->config.pipe)
+            fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
+
+        vprintf(message, arguments);
+
+        if(!instance->config.pipe)
+            puts(FASTFETCH_TEXT_MODIFIER_RESET);
+    }
+}
+
+void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customErrorFormat, const char* message, ...)
+{
+    va_list arguments;
+    va_start(arguments, message);
+    printError(instance, moduleName, moduleIndex, customKeyFormat, customErrorFormat, message, arguments);
+    va_end(arguments);
+}
+
+void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
+{
+    va_list arguments;
+    va_start(arguments, message);
+    printError(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->errorFormat, message, arguments);
+    va_end(arguments);
+}
+
 void ffPrintColor(const FFstrbuf* colorValue)
 {
     //If the color is not set, this would reset in \033[m, which resets everything.
@@ -102,3 +130,34 @@ void ffPrintCharTimes(char c, uint32_t times)
     for(uint32_t i = 0; i < times; i++)
         putchar(c);
 }
+
+void ffPrintUserString(const char* value)
+{
+    while(*value != '\0')
+    {
+        if(*value != '\\')
+        {
+            putchar(*value);
+            ++value;
+            continue;
+        }
+
+        ++value;
+
+        if(*value == 'n')
+            putchar('\n');
+        else if(*value == 't')
+            putchar('\t');
+        else if(*value == 'e')
+            putchar('\e');
+        else if(*value == '\\')
+            putchar('\\');
+        else
+        {
+            putchar('\\');
+            putchar(*value);
+        }
+
+        ++value;
+    }
+}

src/common/printing.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_printing
+#define FF_INCLUDED_common_printing
+
+#include "fastfetch.h"
+#include "common/format.h"
+
+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, ...);
+void ffPrintColor(const FFstrbuf* colorValue);
+void ffPrintCharTimes(char c, uint32_t times);
+void ffPrintUserString(const char* str);
+
+#endif

src/common/processing.c

@@ -1,6 +1,8 @@
 #include "fastfetch.h"
+#include "common/processing.h"
+#include "common/io.h"
 
-#include <sys/types.h>
+#include <stdlib.h>
 #include <unistd.h>
 #include <sys/wait.h>
 
@@ -29,6 +31,6 @@ void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
     //Parent
     close(pipes[1]);
     waitpid(childPid, NULL, 0);
-    ffAppendFDContent(pipes[0], buffer);
+    ffAppendFDBuffer(pipes[0], buffer);
     close(pipes[0]);
 }

src/common/processing.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_processing
+#define FF_INCLUDED_common_processing
+
+#include "util/FFstrbuf.h"
+
+void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
+
+#endif

src/common/properties.c

@@ -1,4 +1,7 @@
 #include "fastfetch.h"
+#include "common/properties.h"
+
+#include <stdlib.h>
 
 static bool parsePropLinePointer(const char** line, const char* start, FFstrbuf* buffer)
 {
@@ -86,10 +89,13 @@ bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer)
 // The following functions return true if the file was found, independently if start was found
 // Buffers which already contain content are not overwritten
 // The last occurence of start in the first file will be the one used
-// The *Values methods always return true, if all properties were already found before, without testing if the file exists
 
 bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries)
 {
+    FILE* file = fopen(filename, "r");
+    if(file == NULL)
+        return false;
+
     bool valueStorage[4];
     bool* unsetValues;
 
@@ -105,17 +111,8 @@ bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquer
             allSet = false;
     }
 
-    FILE* file = fopen(filename, "r");
-    if(file == NULL)
-        return false;
-
     if(allSet)
-    {
-        fclose(file);
-        if(unsetValues != valueStorage)
-            free(unsetValues);
-        return true;
-    }
+        goto done;
 
     char* line = NULL;
     size_t len = 0;
@@ -137,11 +134,10 @@ bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquer
     if(line != NULL)
         free(line);
 
+done:
     fclose(file);
-
     if(unsetValues != valueStorage)
         free(unsetValues);
-
     return true;
 }
 
@@ -174,21 +170,18 @@ bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativ
 {
     bool foundAFile = false;
 
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
+
     for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
     {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-        uint32_t baseDirLength = baseDir->length;
+        //We need to copy the config dir each time, because it used by multiple threads, so we can't directly write to it.
+        ffStrbufSet(&baseDir, ffListGet(&instance->state.configDirs, i));
+        ffStrbufAppendS(&baseDir, relativeFile);
 
-        if(*relativeFile != '/')
-            ffStrbufAppendC(baseDir, '/');
-
-        ffStrbufAppendS(baseDir, relativeFile);
-
-        if(ffParsePropFileValues(baseDir->chars, numQueries, queries))
+        if(ffParsePropFileValues(baseDir.chars, numQueries, queries))
             foundAFile = true;
 
-        ffStrbufSubstrBefore(baseDir, baseDirLength);
-
         bool allSet = true;
         for(uint32_t k = 0; k < numQueries; k++)
         {
@@ -203,6 +196,8 @@ bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativ
             break;
     }
 
+    ffStrbufDestroy(&baseDir);
+
     return foundAFile;
 }
 

src/common/properties.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_properties
+#define FF_INCLUDED_common_properties
+
+#include "util/FFstrbuf.h"
+
+typedef struct FFpropquery
+{
+    const char* start;
+    FFstrbuf* buffer;
+} FFpropquery;
+
+bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer);
+bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
+bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer);
+
+#endif

src/common/settings.c

@@ -1,8 +1,18 @@
 #include "fastfetch.h"
+#include "common/settings.h"
+#include "common/library.h"
+#include "common/io.h"
 
 #include <pthread.h>
 #include <string.h>
 
+typedef enum FFInitState
+{
+    FF_INITSTATE_UNINITIALIZED = 0,
+    FF_INITSTATE_SUCCESSFUL = 1,
+    FF_INITSTATE_FAILED = 2
+} FFInitState;
+
 #define FF_LIBRARY_DATA_LOAD_INIT(dataObject, userLibraryName, ...) \
     static dataObject data; \
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \
@@ -270,6 +280,7 @@ FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, con
 
 #ifdef FF_HAVE_SQLITE3
 #include <sqlite3.h>
+#include <sys/stat.h>
 
 typedef struct SQLiteData
 {
@@ -299,6 +310,9 @@ static const SQLiteData* getSQLiteData(const FFinstance* instance)
 
 int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
 {
+    if(!ffFileExists(dbPath, S_IFREG))
+        return 0;
+
     const SQLiteData* data = getSQLiteData(instance);
     if(data == NULL)
         return 0;
@@ -338,10 +352,44 @@ 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__
+
+#ifdef __APPLE__
+#include <sys/sysctl.h>
+void ffSettingsGetAppleProperty(const char* propName, FFstrbuf* result)
+{
+    size_t neededLength;
+    if(sysctlbyname(propName, NULL, &neededLength, NULL, 0) != 0 || neededLength == 0)
+        return;
+
+    ffStrbufEnsureFree(result, (uint32_t) neededLength);
+
+    if(sysctlbyname(propName, result->chars + result->length, &neededLength, NULL, 0) == 0)
+        result->length += (uint32_t) neededLength;
+
+    result->chars[result->length] = '\0';
+}
+
+int ffSettingsGetAppleInt(const char* propName, int defaultValue)
+{
+    int result;
+    size_t neededLength = sizeof(result);
+    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
+        return defaultValue;
+    return result;
+}
+
+int64_t ffSettingsGetAppleInt64(const char* propName, int64_t defaultValue)
+{
+    int64_t result;
+    size_t neededLength = sizeof(result);
+    if(sysctlbyname(propName, &result, &neededLength, NULL, 0) != 0)
+        return defaultValue;
+    return result;
+}
+#endif //__APPLE__

src/common/settings.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#ifndef FF_INCLUDED_common_settings
+#define FF_INCLUDED_common_settings
+
+#include "fastfetch.h"
+
+typedef enum FFvarianttype
+{
+    FF_VARIANT_TYPE_STRING,
+    FF_VARIANT_TYPE_BOOL,
+    FF_VARIANT_TYPE_INT
+} FFvarianttype;
+
+typedef union FFvariant
+{
+    const char* strValue;
+    int32_t intValue;
+    struct
+    {
+        bool boolValueSet;
+        bool boolValue;
+    };
+} 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);
+
+int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query);
+
+#ifdef __ANDROID__
+void ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
+#endif
+
+#ifdef __APPLE__
+void ffSettingsGetAppleProperty(const char* propName, FFstrbuf* result);
+int ffSettingsGetAppleInt(const char* propName, int defaultValue);
+int64_t ffSettingsGetAppleInt64(const char* propName, int64_t defaultValue);
+#endif
+
+#endif

src/common/threading.c

@@ -1,72 +0,0 @@
-#include "fastfetch.h"
-
-#include <pthread.h>
-
-static inline void* detectPlasmaThreadMain(void* instance)
-{
-    ffDetectPlasma((FFinstance*)instance);
-    return NULL;
-}
-
-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)
-{
-    ffConnectDisplayServer((FFinstance*)instance);
-    return NULL;
-}
-
-static inline void* startThreadsThreadMain(void* instance)
-{
-    pthread_t dsThread;
-    pthread_create(&dsThread, NULL, connectDisplayServerThreadMain, instance);
-    pthread_detach(dsThread);
-
-    pthread_t gtk2Thread;
-    pthread_create(&gtk2Thread, NULL, detectGTK2ThreadMain, instance);
-    pthread_detach(gtk2Thread);
-
-    pthread_t gtk3Thread;
-    pthread_create(&gtk3Thread, NULL, detectGTK3ThreadMain, instance);
-    pthread_detach(gtk3Thread);
-
-    pthread_t gtk4Thread;
-    pthread_create(&gtk4Thread, NULL, detectGTK4ThreadMain, instance);
-    pthread_detach(gtk4Thread);
-
-    pthread_t plasmaThread;
-    pthread_create(&plasmaThread, NULL, detectPlasmaThreadMain, instance);
-    pthread_detach(plasmaThread);
-
-    return NULL;
-}
-
-void ffStartDetectionThreads(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);
-}

src/data/config_system.txt

@@ -0,0 +1,16 @@
+# Fastfetch system configuration
+# This file sets the default config for all users of the system.
+
+# 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.
+
+# 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.
+# If this is off, fastfetch ignores the user config file and any passed arguments
+# Must be true or false
+# Default is true.
+#--load-user-config true

src/data/config_user.txt

@@ -6,7 +6,7 @@
 # Empty lines or lines starting with # are ignored.
 
 # This file was shipped with $"FASTFETCH_PROJECT_VERSION$".
-# Use fastfetch --print-config > ~/.config/fastfetch/config.conf to overwrite this with the current defaults
+# Use fastfetch --print-config-user > ~/.config/fastfetch/config.conf to overwrite this file with the current defaults
 
 # Below some often usefull options are listed. Uncomment and modify them so they take affect.
 # Note that there are a lot more options than the ones listed here, take a look at "fastfetch --help".
@@ -113,12 +113,31 @@
 # 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.
+# Must be true or false.
+# Default is false.
+#--title-fqdn false
 
 # Separator option:
 # Sets the string placed between a key and its value.
@@ -187,6 +206,7 @@
 #--cpu-usage-key CPU Usage
 #--gpu-key GPU {1}
 #--memory-key Memory
+#--swap-key Swap
 #--disk-key Disk ({1})
 #--battery-key Battery {1}
 #--locale-key Locale
@@ -225,6 +245,7 @@
 #--cpu-usage-format
 #--gpu-format
 #--memory-format
+#--swap-format
 #--disk-format
 #--battery-format
 #--locale-format
@@ -237,6 +258,45 @@
 #--opengl-format
 #--opencl-format
 
+# Error options:
+# Sets the format string to use if an error occured
+# For information on format strings, see "fastfetch --help format".
+# Each of them take the error as first and only argument.
+# If one of them is set, the module will appear, even if --show-errors is not given.
+#--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
+#--swap-error
+#--disk-error
+#--battery-error
+#--locale-error
+#--local-ip-error
+#--public-ip-error
+#--player-error
+#--song-error
+#--datetime-error
+#--vulkan-error
+#--opengl-error
+#--opencl-error
+
 # Library options:
 # Sets an user specific path to a library to load.
 # Must be a valid path to a library.
@@ -259,4 +319,4 @@
 #--lib-egl /usr/lib/libEGL.so
 #--lib-glx /usr/lib/libGLX.so
 #--lib-osmesa /usr/lib/libOSMesa.so
-#--lib-opencl /usr/lib/libOpenCL.so
+#--lib-opencl /usr/lib/libOpenCL.so

src/data/help.txt

@@ -1,16 +1,17 @@
 Usage: fastfetch <options>
 
 Informative options:
-    -h,--help:           shows this message and exits
-    -h,--help <command>: shows help for a specific command and exits
-    -v,--version:        prints the version of fastfetch and exits
-    --list-logos:        list available logos and exits
-    --list-modules:      lists available modules and exits
-    --list-presets:      list presets fastfetch knows about and exits. They can be loaded with --load-config. (+)
-    --list-features:     list the supported features fastfetch was compiled with and exits. Mainly for development.
-    --print-logos:       show available logos and exits
-    --print-config:      prints the default config and exits
-    --print-structure:   prints the default stucture and exits
+    -h,--help:             shows this message and exits
+    -h,--help <command>:   shows help for a specific command and exits
+    -v,--version:          prints the version of fastfetch and exits
+    --list-logos:          list available logos and exits
+    --list-modules:        lists available modules and exits
+    --list-presets:        list presets fastfetch knows about and exits. They can be loaded with --load-config. (+)
+    --list-features:       list the supported features fastfetch was compiled with and exits. Mainly for development.
+    --print-logos:         show available logos and exits
+    --print-config-system: prints the default system config and exits
+    --print-config-user:   prints the default user config and exits
+    --print-structure:     prints the default stucture and exits
 
 General options:
     -r,--recache <?value>:            generate new cached values
@@ -39,84 +40,28 @@ 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
 
-Format options: Provide the format string for custom output. Use fastfetch --help *-format for specific help.
-    --os-format <format>
-    --host-format <format>
-    --kernel-format <format>
-    --uptime-format <format>
-    --processes-format <format>
-    --packages-format <format>
-    --shell-format <format>
-    --resolution-format <format>
-    --de-format <format>
-    --wm-format <format>
-    --wm-theme-format <format>
-    --theme-format <format>
-    --icons-format <format>
-    --font-format <format>
-    --cursor-format <format>
-    --terminal-format <format>
-    --terminal-font-format <format>
-    --cpu-format <format>
-    --cpu-usage-format <format>
-    --gpu-format <format>
-    --memory-format <format>
-    --disk-format <format>
-    --battery-format <format>
-    --locale-format <format>
-    --local-ip-format <format>
-    --public-ip-format <format>
-    --player-format <format>
-    --song-format <format>
-    --datetime-format <format>
-    --time-format <format>
-    --date-format <format>
-    --vulkan-format <format>
-    --opengl-format <format>
-    --opencl-format <format>
+General module options:
+    --<module>-format <format>: Sets the format string to use for each specific module.
+                                To see how a format string works, use fastfetch --help format.
+                                To see help about a specific format string, use fastfetch --help <module>-format.
 
-Key options: Provide a custom key for an output
-    --os-key <key>
-    --host-key <key>
-    --kernel-key <key>
-    --uptime-key <key>
-    --processes-key <key>
-    --packages-key <key>
-    --shell-key <key>
-    --resolution-key <key>: takes the resolution index as argument
-    --de-key <key>
-    --wm-key <key>
-    --wm-theme-key <key>
-    --theme-key <key>
-    --icons-key <key>
-    --font-key <key>
-    --cursor-key <key>
-    --terminal-key <key>
-    --terminal-font-key <key>
-    --cpu-key <key>
-    --cpu-usage-key <key>
-    --gpu-key <key>: takes the gpu index as format argument
-    --memory-key <key>
-    --disk-key <key>: takes the mount path as format argument
-    --battery-key <key>: takes the battery index as format argument
-    --locale-key <key>
-    --local-ip-key <key>: takes the name of this network interface as format argument
-    --public-ip-key <key>
-    --player-key <key>
-    --song-key <key>
-    --datetime-key <key>
-    --time-key <key>
-    --date-key <key>
-    --vulkan-key <key>
-    --opengl-key <key>
-    --opencl-key <key>
+    --<module>-key <key>:       Sets the key to use for each specific module.
+                                For modules which print multiple lines, the string is parsed as a format string with the index as first character.
+
+    --<module>-error <format>:  Sets the error format string to use for each specific module.
+                                The error is given as the first and only argument.
+                                Setting this for a module will cause it to appear, even if --show-errors is not given.
 
 Library options: Set the path of a library to load
     --lib-PCI <path>
@@ -141,6 +86,7 @@ Library options: Set the path of a library to load
     --lib-opencl <path>
 
 Module specific options:
+    --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"

src/data/help_format.txt

@@ -19,24 +19,18 @@ If a "{?}" is found without an opener, it is printed as is.
 To only print something if a variable is not set, do the same as with if, just replace every '?' with a '!'.
 For example to print a fallback for a second value if it is not set, use "{?2}{2}{?}{/2}Second value fallback{/}"
 
-There is a special variable set if an error occured during detection. You can access it with "{e}", "{error}" o
-You can use ifs and not ifs with it like with an index. For example use "{?e}some text{?}", to print a text if an
-
 To stop formatting at any point in the format string, use "{-}".
-For example to print an error instead of the normal output if it occured, prefix the format string with "{?e}{e}{-
 
 To print something with color, start a placeholder with a '#' and then the linux terminal color encoding.
 "\\033[" at the start, and an 'm' at the end is automatically added, so don't do that.
 A "{#}" is equivalent to a "{#0}" and resets everything to normal.
 For example to print something pink and underline, use "{#4;35}...{#}".
-If not in a format string, fastfetch wraps errors with "{#1;31}error{#}", so you might want to do that to if you
 Information about what the numbers mean can be found here: https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Sele
 Which escape codes are supported and how they look is defined by your terminal.
 
 If a format string evaluates to an empty value, the whole line in the output will be discarded.
 You can therefore use --host-format " " to disable host output.
 Note that --host-format "" would evaluate as not set, and therefore use the built-in host format
-This can be used to print nothing if an error occured: prefix the format string with "{?e}{-}{?}...".
 
 Format string is also the way to go to set a fixed value - just use one without placeholders.
 For example when running in headless mode, you could use "--resolution-format "Preferred".

src/data/modules.txt

@@ -15,6 +15,7 @@ Icons
 Kernel
 Locale
 LocalIP
+Media
 Memory
 OS
 OpenCL
@@ -26,7 +27,7 @@ PublicIP
 Resolution
 Separator
 Shell
-Song
+Swap
 Terminal
 TerminalFont
 Theme

src/detection/cpu/cpu.c

@@ -0,0 +1,22 @@
+#include "cpu.h"
+#include "detection/internal.h"
+
+void ffDetectCPUImpl(FFCPUResult* cpu);
+
+const FFCPUResult* ffDetectCPU()
+{
+    FF_DETECTION_INTERNAL_GUARD(FFCPUResult,
+        ffDetectCPUImpl(&result);
+
+        const char* removeStrings[] = {
+            "(R)", "(r)", "(TM)", "(tm)",
+            " CPU", " FPU", " APU", " Processor",
+            " Dual-Core", " Quad-Core", " Six-Core", " Eight-Core", " Ten-Core",
+            " 2-Core", " 4-Core", " 6-Core", " 8-Core", " 10-Core", " 12-Core", " 14-Core", " 16-Core",
+            " with Radeon Graphics"
+        };
+        ffStrbufRemoveStringsA(&result.name, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
+        ffStrbufSubstrBeforeFirstC(&result.name, '@'); //Cut the speed output in the name as we append our own
+        ffStrbufTrimRight(&result.name, ' '); //If we removed the @ in previous step there was most likely a space before it
+    );
+}

src/detection/cpu/cpu.h

@@ -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();
+
+#endif

src/detection/cpu/cpu_apple.c

@@ -0,0 +1,42 @@
+#include "cpu.h"
+#include "common/settings.h"
+
+static double getFrequency(const char* propName)
+{
+    double herz = (double) ffSettingsGetAppleInt64(propName, 0);
+    if(herz <= 0.0)
+        return herz;
+
+    herz /= 1000.0; //to KHz
+    herz /= 1000.0; //to MHz
+    return herz / 1000.0; //to GHz
+}
+
+void ffDetectCPUImpl(FFCPUResult* cpu)
+{
+    ffStrbufInit(&cpu->name);
+    ffSettingsGetAppleProperty("machdep.cpu.brand_string", &cpu->name);
+
+    ffStrbufInit(&cpu->vendor);
+    ffSettingsGetAppleProperty("machdep.cpu.vendor", &cpu->vendor);
+
+    cpu->coresPhysical = (uint16_t) ffSettingsGetAppleInt("hw.physicalcpu_max", 1);
+    if(cpu->coresPhysical == 1)
+        cpu->coresPhysical = (uint16_t) ffSettingsGetAppleInt("hw.physicalcpu", 1);
+
+    cpu->coresLogical = (uint16_t) ffSettingsGetAppleInt("hw.logicalcpu_max", 1);
+    if(cpu->coresLogical == 1)
+        cpu->coresLogical = (uint16_t) ffSettingsGetAppleInt("hw.ncpu", 1);
+
+    cpu->coresOnline = (uint16_t) ffSettingsGetAppleInt("hw.logicalcpu", 1);
+    if(cpu->coresOnline == 1)
+        cpu->coresOnline = (uint16_t) ffSettingsGetAppleInt("hw.activecpu", 1);
+
+    cpu->frequencyMin = getFrequency("hw.cpufrequency_min");
+    cpu->frequencyMax = getFrequency("hw.cpufrequency_max");
+    if(cpu->frequencyMax == 0.0)
+        cpu->frequencyMax = getFrequency("hw.cpufrequency");
+
+    //TODO find a way to detect this
+    cpu->temperature = FF_CPU_TEMP_UNSET;
+}

src/detection/cpu/cpu_linux.c

@@ -0,0 +1,102 @@
+#include "cpu.h"
+#include "common/io.h"
+#include "common/properties.h"
+#include "detection/temps.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 FFTempsResult *temps = ffDetectTemps();
+
+    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(FFCPUResult* cpu)
+{
+    ffStrbufInit(&cpu->name);
+    ffStrbufInit(&cpu->vendor);
+
+    FFstrbuf physicalCoresBuffer;
+    ffStrbufInit(&physicalCoresBuffer);
+
+    parseCpuInfo(cpu, &physicalCoresBuffer);
+
+    cpu->coresPhysical = ffStrbufToUInt16(&physicalCoresBuffer, 1);
+    cpu->coresLogical = (uint16_t) get_nprocs_conf();
+    cpu->coresOnline = (uint16_t) get_nprocs();
+
+    #define BP "/sys/devices/system/cpu/cpufreq/policy0/"
+    cpu->frequencyMin = getFrequency(BP"cpuinfo_min_freq", BP"scaling_min_freq");
+    cpu->frequencyMax = getFrequency(BP"cpuinfo_max_freq", BP"scaling_max_freq");
+
+    cpu->temperature = detectCPUTemp();
+
+    ffStrbufDestroy(&physicalCoresBuffer);
+}

src/detection/datetime.c

@@ -1,7 +1,7 @@
 #include "fastfetch.h"
+#include "detection/datetime.h"
 
 #include <time.h>
-
 #include <pthread.h>
 
 const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance)

src/detection/datetime.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_datetime
+#define FF_INCLUDED_detection_datetime
+
+#include "fastfetch.h"
+
+typedef struct FFDateTimeResult
+{
+    //Examples for 21.02.2022 - 15:18:37
+    uint16_t year; //2022
+    uint8_t yearShort; //22
+    uint8_t month; //2
+    FFstrbuf monthPretty; //02
+    FFstrbuf monthName; //February
+    FFstrbuf monthNameShort; //Feb
+    uint8_t week; //8
+    FFstrbuf weekday; //Monday
+    FFstrbuf weekdayShort; //Mon
+    uint16_t dayInYear; //52
+    uint8_t dayInMonth; //21
+    uint8_t dayInWeek; //1
+    uint8_t hour; //15
+    FFstrbuf hourPretty; //15
+    uint8_t hour12; //3
+    FFstrbuf hour12Pretty; //03
+    uint8_t minute; //18
+    FFstrbuf minutePretty; //18
+    uint8_t second; //37
+    FFstrbuf secondPretty; //37
+} FFDateTimeResult;
+
+const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance);
+
+#endif

src/detection/displayserver/displayServer.c

@@ -1,132 +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;
-}

src/detection/displayserver/displayserver.c

@@ -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);
+    );
+}

src/detection/displayserver/displayserver.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_displayserver
+#define FF_INCLUDED_detection_displayserver
+
+#include "fastfetch.h"
+
+typedef struct FFResolutionResult
+{
+    uint32_t width;
+    uint32_t height;
+    uint32_t refreshRate;
+} FFResolutionResult;
+
+typedef struct FFDisplayServerResult
+{
+    FFstrbuf wmProcessName;
+    FFstrbuf wmPrettyName;
+    FFstrbuf wmProtocolName;
+    FFstrbuf deProcessName;
+    FFstrbuf dePrettyName;
+    FFstrbuf deVersion;
+    FFlist resolutions; //List of FFResolutionResult
+} FFDisplayServerResult;
+
+const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance);
+
+//Used internal
+uint32_t ffdsParseRefreshRate(int32_t refreshRate);
+bool ffdsAppendResolution(FFDisplayServerResult* result, uint32_t width, uint32_t height, uint32_t refreshRate);
+
+#endif

src/detection/displayserver/displayserver_android.c

@@ -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);
+}

src/detection/displayserver/displayserver_apple.c

@@ -0,0 +1,120 @@
+#include "displayserver.h"
+#include "common/library.h"
+
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <sys/sysctl.h>
+#include <ApplicationServices/ApplicationServices.h>
+
+//Resolution code heavily inspired by displayplacer <3
+
+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;
+    if(sysctl(request, requestLength, NULL, &length, NULL, 0) != 0)
+        return;
+
+    struct kinfo_proc* processes = malloc(length);
+    if(processes == NULL)
+        return;
+
+    if(sysctl(request, requestLength, processes, &length, NULL, 0) != 0)
+    {
+        free(processes);
+        return;
+    }
+
+    for(size_t i = 0; i < length / sizeof(struct kinfo_proc); i++)
+    {
+        const char* comm = processes[i].kp_proc.p_comm;
+
+        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);
+}

src/detection/displayserver/linux/displayserver_linux.c

@@ -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, "%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);
+}
+
+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);
+}

src/detection/displayserver/linux/displayserver_linux.h

@@ -3,15 +3,12 @@
 #ifndef FASTFETCH_INCLUDED_DISPLAYSERVER
 #define FASTFETCH_INCLUDED_DISPLAYSERVER
 
-#include "fastfetch.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);

src/detection/displayserver/linux/wayland.c

@@ -0,0 +1,181 @@
+#define _GNU_SOURCE //required for struct ucred
+
+#include "displayserver_linux.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef FF_HAVE_WAYLAND
+#include "common/library.h"
+#include "common/io.h"
+#include <pthread.h>
+#include <wayland-client.h>
+#include <sys/socket.h>
+
+typedef struct WaylandData
+{
+    FFlist* results;
+    FF_LIBRARY_SYMBOL(wl_proxy_marshal_constructor_versioned)
+    FF_LIBRARY_SYMBOL(wl_proxy_add_listener)
+    const struct wl_interface* ffwl_output_interface;
+} WaylandData;
+
+static void waylandDetectWM(int fd, FFDisplayServerResult* result)
+{
+    struct ucred ucred;
+    socklen_t len = sizeof(struct ucred);
+    if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == -1)
+        return;
+
+    FFstrbuf procPath;
+    ffStrbufInit(&procPath);
+    ffStrbufAppendF(&procPath, "/proc/%d/cmdline", ucred.pid); //We check the cmdline for the process name, because it is not trimmed.
+    ffReadFileBuffer(procPath.chars, &result->wmProcessName);
+    ffStrbufSubstrBeforeFirstC(&result->wmProcessName, '\0'); //Trim the arguments
+    ffStrbufSubstrAfterLastC(&result->wmProcessName, '/'); //Trim the path
+    ffStrbufDestroy(&procPath);
+}
+
+static void stubListener(void* data, ...)
+{
+    (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;
+
+    if(!(flags & WL_OUTPUT_MODE_CURRENT) || width <= 0 || height <= 0)
+        return;
+
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    pthread_mutex_lock(&mutex);
+
+    FFResolutionResult* result = ffListAdd(wldata->results);
+
+    pthread_mutex_unlock(&mutex);
+
+    result->width = (uint32_t) width;
+    result->height = (uint32_t) height;
+    result->refreshRate = ffdsParseRefreshRate(refreshRate / 1000);
+}
+
+static void waylandGlobalAddListener(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
+{
+    WaylandData* wldata = data;
+
+    if(strcmp(interface, wldata->ffwl_output_interface->name) == 0)
+    {
+        struct wl_proxy* output = wldata->ffwl_proxy_marshal_constructor_versioned((struct wl_proxy*) registry, WL_REGISTRY_BIND, wldata->ffwl_output_interface, version, name, wldata->ffwl_output_interface->name, version, NULL);
+        if(output == NULL)
+            return;
+
+        //Needs to be static, because the scope of the function will already be lost when calling the listener
+        static struct wl_output_listener outputListener = {
+            .mode = waylandOutputModeListener,
+            .geometry = (void*) stubListener,
+
+            //https://lists.freedesktop.org/archives/wayland-devel/2013-July/010278.html
+            #if WAYLAND_VERSION_MINOR >= 2
+                .done = (void*) stubListener,
+                .scale = (void*) stubListener,
+            #endif
+
+            //https://lists.freedesktop.org/archives/wayland-devel/2021-December/042064.html
+            #if WAYLAND_VERSION_MINOR >= 20
+                .name = (void*) stubListener,
+                .description = (void*) stubListener,
+            #endif
+        };
+
+        wldata->ffwl_proxy_add_listener(output, (void(**)(void)) &outputListener, data);
+    }
+}
+
+bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)
+{
+    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)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_dispatch, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_roundtrip, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_proxy_marshal_constructor, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_disconnect, false)
+    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_registry_interface, false)
+
+    WaylandData data;
+
+    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_output_interface, false)
+
+    struct wl_display* display = ffwl_display_connect(NULL);
+    if(display == NULL)
+    {
+        dlclose(wayland);
+        return false;
+    }
+
+    waylandDetectWM(ffwl_display_get_fd(display), result);
+
+    struct wl_proxy* registry = ffwl_proxy_marshal_constructor((struct wl_proxy*) display, WL_DISPLAY_GET_REGISTRY, ffwl_registry_interface, NULL);
+    if(registry == NULL)
+    {
+        ffwl_display_disconnect(display);
+        dlclose(wayland);
+        return false;
+    }
+
+    data.results = &result->resolutions;
+
+    struct wl_registry_listener registry_listener = {
+        .global = waylandGlobalAddListener,
+        .global_remove = (void*) stubListener
+    };
+
+    data.ffwl_proxy_add_listener(registry, (void(**)(void)) &registry_listener, &data);
+    ffwl_display_dispatch(display);
+    ffwl_display_roundtrip(display);
+
+    ffwl_display_disconnect(display); //This will also destroy our wl_registry and wl_output proxies
+    dlclose(wayland);
+
+    //We successfully connected to wayland and detected the resolution.
+    //So we can set set the session type to wayland.
+    //This is used as an indicator that we are running wayland by the x11 backends.
+    ffStrbufSetS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND);
+    return true;
+}
+#endif
+
+void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result)
+{
+    //Wayland requires this to be set
+    if(getenv("XDG_RUNTIME_DIR") == NULL)
+        return;
+
+    #ifdef FF_HAVE_WAYLAND
+        if(detectWayland(instance, result))
+            return;
+    #else
+        FF_UNUSED(instance);
+    #endif
+
+    const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
+
+    //If XDG_SESSION_TYPE is set, and doesn't contain "wayland", we are probably not running in a wayland session.
+    if(xdgSessionType != NULL && strcasecmp(xdgSessionType, "wayland") != 0)
+        return;
+
+    //If XDG_SESSION_TYPE is not set, check if WAYLAND_DISPLAY or WAYLAND_SOCKET is set.
+    //If not, there is no indicator for a wayland session
+    if(xdgSessionType == NULL && getenv("WAYLAND_DISPLAY") == NULL && getenv("WAYLAND_SOCKET") == NULL)
+        return;
+
+    //We are probably running a wayland compositor at this point,
+    //but fastfetch was compiled without the required library, or loading the library failed.
+    ffStrbufSetS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND);
+}

src/detection/displayserver/linux/wmde.c

@@ -1,8 +1,15 @@
-#include "displayServer.h"
-#include <dirent.h>
+#include "displayserver_linux.h"
+#include "common/io.h"
+#include "common/properties.h"
+#include "common/parsing.h"
+#include "common/processing.h"
+
+#include <stdlib.h>
+#include <ctype.h>
 #include <string.h>
 #include <unistd.h>
-#include <ctype.h>
+#include <dirent.h>
+#include <sys/stat.h>
 
 static const char* parseEnv()
 {
@@ -40,6 +47,11 @@ static const char* parseEnv()
     if(getenv("TDE_FULL_SESSION") != NULL)
         return "Trinity";
 
+    if(
+        getenv("WAYLAND_DISPLAY") != NULL &&
+        ffFileExists("/mnt/wslg/", S_IFDIR)
+    ) return "WSLg";
+
     return NULL;
 }
 
@@ -48,8 +60,23 @@ static void applyPrettyNameIfWM(FFDisplayServerResult* result, const char* proce
     if(!ffStrSet(processName))
         return;
 
-    if(strcasecmp(processName, "kwin_wayland") == 0 || strcasecmp(processName, "kwin_x11") == 0 || strcasecmp(processName, "kwin") == 0)
-        ffStrbufSetS(&result->wmPrettyName, "KWin");
+    if(
+        strcasecmp(processName, "kwin_wayland") == 0 ||
+        strcasecmp(processName, "kwin_wayland_wrapper") == 0 ||
+        strcasecmp(processName, "kwin_x11") == 0 ||
+        strcasecmp(processName, "kwin_x11_wrapper") == 0 ||
+        strcasecmp(processName, "kwin") == 0
+    ) ffStrbufSetS(&result->wmPrettyName, "KWin");
+    else if(
+        strcasecmp(processName, "gnome-shell") == 0 ||
+        strcasecmp(processName, "gnome shell") == 0 ||
+        strcasecmp(processName, "gnome-session-binary") == 0 ||
+        strcasecmp(processName, "Mutter") == 0
+    ) ffStrbufSetS(&result->wmPrettyName, "Mutter");
+    else if(
+        strcasecmp(processName, "cinnamon-session") == 0 ||
+        strcasecmp(processName, "Muffin") == 0
+    ) ffStrbufSetS(&result->wmPrettyName, "Muffin");
     else if(strcasecmp(processName, "sway") == 0)
         ffStrbufSetS(&result->wmPrettyName, "Sway");
     else if(strcasecmp(processName, "weston") == 0)
@@ -64,10 +91,6 @@ static void applyPrettyNameIfWM(FFDisplayServerResult* result, const char* proce
         ffStrbufSetS(&result->wmPrettyName, "Marco");
     else if(strcasecmp(processName, "xmonad") == 0)
         ffStrbufSetS(&result->wmPrettyName, "XMonad");
-    else if(strcasecmp(processName, "gnome-session-binary") == 0 || strcasecmp(processName, "Mutter") == 0)
-        ffStrbufSetS(&result->wmPrettyName, "Mutter");
-    else if(strcasecmp(processName, "cinnamon-session") == 0 || strcasecmp(processName, "Muffin") == 0)
-        ffStrbufSetS(&result->wmPrettyName, "Muffin");
     else if( // WMs where the pretty name matches the process name
         strcasecmp(processName, "dwm") == 0 ||
         strcasecmp(processName, "bspwm") == 0 ||
@@ -329,7 +352,7 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
 
         //Don't check for processes not owend by the current user.
         ffStrbufAppendS(&procPath, "/loginuid");
-        ffGetFileContent(procPath.chars, &loginuid);
+        ffReadFileBuffer(procPath.chars, &loginuid);
         if(ffStrbufComp(&userID, &loginuid) != 0)
         {
             ffStrbufSubstrBefore(&procPath, procPathLength);
@@ -340,7 +363,7 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
 
         //We check the cmdline for the process name, because it is not trimmed.
         ffStrbufAppendS(&procPath, "/cmdline");
-        ffGetFileContent(procPath.chars, &processName);
+        ffReadFileBuffer(procPath.chars, &processName);
         ffStrbufSubstrBeforeFirstC(&processName, '\0'); //Trim the arguments
         ffStrbufSubstrAfterLastC(&processName, '/');
 
@@ -371,7 +394,7 @@ void ffdsDetectWMDE(const FFinstance* instance, FFDisplayServerResult* result)
         getWMProtocolNameFromEnv(result);
 
     //We don't want to detect anything in TTY
-    //This can't happen if a X11 connection succeeded, so we don't need to clear wmProcessName
+    //This can't happen if a connection succeeded, so we don't need to clear wmProcessName
     if(ffStrbufIgnCaseCompS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_TTY) == 0)
         return;
 

src/detection/displayserver/linux/xcb.c

@@ -1,8 +1,10 @@
-#include "displayServer.h"
+#include "displayserver_linux.h"
 
 #ifdef FF_HAVE_XCB
-#include <xcb/xcb.h>
+#include "common/library.h"
+#include <stdlib.h>
 #include <string.h>
+#include <xcb/xcb.h>
 
 typedef struct XcbPropertyData
 {
@@ -16,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;
 }
@@ -60,7 +62,7 @@ static void* xcbGetProperty(XcbPropertyData* data, xcb_connection_t* connection,
 
 static void xcbDetectWMfromEWMH(XcbPropertyData* data, xcb_connection_t* connection, xcb_window_t rootWindow, FFDisplayServerResult* result)
 {
-    if(result->wmProcessName.length > 0)
+    if(result->wmProcessName.length > 0 || ffStrbufCompS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND) == 0)
         return;
 
     xcb_window_t* wmWindow = (xcb_window_t*) xcbGetProperty(data, connection, rootWindow, "_NET_SUPPORTING_WM_CHECK");
@@ -333,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);

src/detection/displayserver/linux/xlib.c

@@ -1,6 +1,8 @@
-#include "displayServer.h"
+#include "displayserver_linux.h"
 
 #ifdef FF_HAVE_X11
+#include "common/library.h"
+#include "common/parsing.h"
 #include <X11/Xlib.h>
 
 typedef struct X11PropertyData
@@ -11,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;
 }
@@ -34,7 +36,7 @@ static unsigned char* x11GetProperty(X11PropertyData* data, Display* display, Wi
 
 static void x11DetectWMFromEWMH(X11PropertyData* data, Display* display, FFDisplayServerResult* result)
 {
-    if(result->wmProcessName.length > 0)
+    if(result->wmProcessName.length > 0 || ffStrbufCompS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND) == 0)
         return;
 
     Window* wmWindow = (Window*) x11GetProperty(data, display, DefaultRootWindow(display), "_NET_SUPPORTING_WM_CHECK");
@@ -264,17 +266,17 @@ void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result
 
     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);

src/detection/displayserver/wayland.c

@@ -1,166 +0,0 @@
-#include "displayServer.h"
-#include <string.h>
-
-#ifdef FF_HAVE_WAYLAND
-#include <wayland-client.h>
-#include <pthread.h>
-
-typedef struct WaylandData
-{
-    const FFinstance* instance;
-    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;
-    struct wl_output_listener output_listener;
-} WaylandData;
-
-static void waylandGlobalRemoveListener(void* data, struct wl_registry* wl_registry, uint32_t name){
-    FF_UNUSED(data, wl_registry, name);
-}
-
-static void waylandOutputGeometryListener(void* data, struct wl_output* wl_output, int32_t x, int32_t y, int32_t physical_width, int32_t physical_height, int32_t subpixel, const char* make, const char* model, int32_t transform)
-{
-    FF_UNUSED(data, wl_output, x, y, physical_width, physical_height, subpixel, make, model, transform);
-}
-
-static void waylandOutputDoneListener(void* data, struct wl_output* wl_output)
-{
-    FF_UNUSED(data, wl_output);
-}
-
-static void waylandOutputScaleListener(void* data, struct wl_output* wl_output, int32_t factor)
-{
-    FF_UNUSED(data, wl_output, factor);
-}
-
-static void waylandOutputModeListener(void* data, struct wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refreshRate)
-{
-    if(!(flags & WL_OUTPUT_MODE_CURRENT))
-        return;
-
-    WaylandData* wldata = (WaylandData*) data;
-
-    wldata->ffwl_proxy_destroy((struct wl_proxy*) output);
-
-    if(width <= 0 || height <= 0)
-        return;
-
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    pthread_mutex_lock(&mutex);
-
-    FFResolutionResult* result = ffListAdd(wldata->results);
-
-    pthread_mutex_unlock(&mutex);
-
-    result->width = (uint32_t) width;
-    result->height = (uint32_t) height;
-    result->refreshRate = ffdsParseRefreshRate(refreshRate / 1000);
-}
-
-static void waylandGlobalAddListener(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
-{
-    if(strcmp(interface, "wl_output") == 0)
-    {
-        WaylandData* wldata = (WaylandData*) data;
-
-        struct wl_output* output = (struct wl_output*) wldata->ffwl_proxy_marshal_constructor_versioned((struct wl_proxy *) registry, WL_REGISTRY_BIND, wldata->ffwl_output_interface, version, name, wldata->ffwl_output_interface->name, version, NULL);
-        if(output == NULL)
-            return;
-
-        wldata->ffwl_proxy_add_listener((struct wl_proxy*) output, (void(**)(void)) &wldata->output_listener, data);
-    }
-}
-
-void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result)
-{
-    if(getenv("XDG_RUNTIME_DIR") == NULL)
-        return;
-
-    FF_LIBRARY_LOAD(wayland, instance->config.libWayland, , "libwayland-client.so", 1)
-
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_connect,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_dispatch,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_roundtrip,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_proxy_marshal_constructor,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_disconnect,)
-    FF_LIBRARY_LOAD_SYMBOL(wayland, wl_registry_interface,)
-
-    WaylandData data;
-
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_marshal_constructor_versioned, wl_proxy_marshal_constructor_versioned,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_add_listener, wl_proxy_add_listener,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_output_interface, wl_output_interface,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(wayland, data.ffwl_proxy_destroy, wl_proxy_destroy,)
-
-    struct wl_display* display = ffwl_display_connect(NULL);
-    if(display == NULL)
-    {
-        dlclose(wayland);
-        return;
-    }
-
-    struct wl_registry* registry = (struct wl_registry*) ffwl_proxy_marshal_constructor((struct wl_proxy*) display, WL_DISPLAY_GET_REGISTRY, ffwl_registry_interface, NULL);
-    if(registry == NULL)
-    {
-        ffwl_display_disconnect(display);
-        dlclose(wayland);
-        return;
-    }
-
-    data.instance = instance;
-    data.results = &result->resolutions;
-
-    struct wl_registry_listener regestry_listener;
-    regestry_listener.global = waylandGlobalAddListener;
-    regestry_listener.global_remove = waylandGlobalRemoveListener;
-
-    data.output_listener.geometry = waylandOutputGeometryListener;
-    data.output_listener.mode = waylandOutputModeListener;
-    data.output_listener.done = waylandOutputDoneListener;
-    data.output_listener.scale = waylandOutputScaleListener;
-
-    data.ffwl_proxy_add_listener((struct wl_proxy*) registry, (void(**)(void)) &regestry_listener, &data);
-    ffwl_display_dispatch(display);
-    ffwl_display_roundtrip(display);
-
-    data.ffwl_proxy_destroy((struct wl_proxy*) registry);
-    ffwl_display_disconnect(display);
-    dlclose(wayland);
-
-    //We successfully connected to wayland and detected the resolution.
-    //So we can set set the session type to wayland.
-    //This is used as an indicator that we are running wayland by the x11 backends.
-    ffStrbufSetS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND);
-}
-
-#else
-
-void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result)
-{
-    FF_UNUSED(instance);
-
-    //We try to detect wayland already here, so the x11 methods only to resolution detection.
-
-    //Wayland requires this to be set
-    if(getenv("XDG_RUNTIME_DIR") == NULL)
-        return;
-
-    const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
-
-    //If XDG_SESSION_TYPE is set, and doesn't contain "wayland", we are probably not running in a wayland session.
-    if(xdgSessionType != NULL && strcasecmp(xdgSessionType, "wayland") != 0)
-        return;
-
-    //If XDG_SESSION_TYPE is not set, check if WAYLAND_DISPLAY or WAYLAND_SOCKET is set.
-    //If not, there is no indicator for a wayland session
-    if(xdgSessionType == NULL && getenv("WAYLAND_DISPLAY") == NULL && getenv("WAYLAND_SOCKET") == NULL)
-        return;
-
-    //We are probably running a wayland compositor at this point, but fastfetch was compiled without the required library.
-    //Set the protocol name and use DRM for resolution detection.
-    ffStrbufSetS(&result->wmProtocolName, FF_DISPLAYSERVER_PROTOCOL_WAYLAND);
-}
-
-#endif

src/detection/gpu/gpu.c

@@ -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;
+        }
+    );
+}

src/detection/gpu/gpu.h

@@ -0,0 +1,20 @@
+#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)
+
+typedef struct FFGPUResult
+{
+    FFstrbuf vendor;
+    FFstrbuf name;
+    FFstrbuf driver;
+    double temperature;
+} FFGPUResult;
+
+const FFlist* ffDetectGPU(const FFinstance* instance);
+
+#endif

src/detection/gpu/gpu_android.c

@@ -0,0 +1,6 @@
+#include "gpu.h"
+
+void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+{
+    FF_UNUSED(gpus, instance);
+}

src/detection/gpu/gpu_apple.c

@@ -0,0 +1,68 @@
+#include "gpu.h"
+#include "common/library.h"
+#include "detection/cpu/cpu.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/graphics/IOGraphicsLib.h>
+
+void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+{
+    FF_UNUSED(instance);
+
+    const FFCPUResult* cpu = ffDetectCPU();
+    if(ffStrbufStartsWithIgnCaseS(&cpu->name, "Apple M"))
+    {
+        FFGPUResult* gpu = ffListAdd(gpus);
+
+        ffStrbufInit(&gpu->vendor);
+        ffStrbufAppendS(&gpu->vendor, "Apple");
+
+        ffStrbufInit(&gpu->name);
+        ffStrbufAppendS(&gpu->name, cpu->name.chars + 6); //Cut "Apple "
+
+        ffStrbufInitA(&gpu->driver, 0);
+        gpu->temperature = FF_GPU_TEMP_UNSET;
+    }
+
+    CFMutableDictionaryRef matchDict = IOServiceMatching("IOPCIDevice");
+    io_iterator_t iterator;
+    if(IOServiceGetMatchingServices(0, matchDict, &iterator) != kIOReturnSuccess)
+        return;
+
+    io_registry_entry_t registryEntry;
+    while((registryEntry = IOIteratorNext(iterator)) != 0)
+    {
+        CFMutableDictionaryRef properties;
+        if(IORegistryEntryCreateCFProperties(registryEntry, &properties, kCFAllocatorDefault, kNilOptions) != kIOReturnSuccess)
+        {
+            IOObjectRelease(registryEntry);
+            continue;
+        }
+
+        CFStringRef key = CFStringCreateWithCStringNoCopy(NULL, "model", kCFStringEncodingASCII, kCFAllocatorNull);
+        CFStringRef model = CFDictionaryGetValue(properties, key);
+        if(model == NULL || CFGetTypeID(model) != CFDataGetTypeID())
+        {
+            CFRelease(properties);
+            IOObjectRelease(registryEntry);
+            continue;
+        }
+
+        FFGPUResult* gpu = ffListAdd(gpus);
+
+        uint32_t modelLength = (uint32_t) CFStringGetLength(model);
+        ffStrbufInitA(&gpu->name, modelLength + 1);
+        CFStringGetCString(model, gpu->name.chars, modelLength + 1, kCFStringEncodingASCII);
+        gpu->name.length = modelLength;
+        gpu->name.chars[gpu->name.length] = '\0';
+
+        ffStrbufInitA(&gpu->vendor, 0);
+        ffStrbufInitA(&gpu->driver, 0);
+        gpu->temperature = FF_GPU_TEMP_UNSET;
+
+        CFRelease(properties);
+        IOObjectRelease(registryEntry);
+    }
+
+    IOObjectRelease(iterator);
+}

src/detection/gpu/gpu_linux.c

@@ -0,0 +1,212 @@
+#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.h"
+#include <string.h>
+#include <unistd.h>
+#include <pci/pci.h>
+
+typedef struct PCIData
+{
+    struct pci_access* access;
+    FF_LIBRARY_SYMBOL(pci_read_byte);
+    FF_LIBRARY_SYMBOL(pci_read_word);
+    FF_LIBRARY_SYMBOL(pci_lookup_name);
+    FF_LIBRARY_SYMBOL(pci_get_param);
+} 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)
+{
+    FFstrbuf query;
+    ffStrbufInit(&query);
+    ffStrbufAppendF(&query, "%X, %X,", device->device_id, pci->ffpci_read_byte(device, PCI_REVISION_ID));
+
+    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)
+{
+    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(FFGPUResult* gpu, struct pci_dev* device)
+{
+    const FFTempsResult* tempsResult = ffDetectTemps();
+
+    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(FFlist* results, PCIData* pci, struct pci_dev* device)
+{
+    device->device_class = pci->ffpci_read_word(device, PCI_CLASS_DEVICE);
+
+    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;
+
+    device->vendor_id = pci->ffpci_read_word(device, PCI_VENDOR_ID);
+    device->device_id = pci->ffpci_read_word(device, PCI_DEVICE_ID);
+
+    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->temperature = FF_GPU_TEMP_UNSET;
+    pciDetectTemperatur(gpu, device);
+}
+
+static void pciDetectGPUs(const FFinstance* instance, FFlist* gpus)
+{
+    PCIData pci;
+
+    FF_LIBRARY_LOAD(libpci, instance->config.libPCI, , "libpci.so", 4)
+    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_alloc, )
+    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_init, )
+    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_scan_bus, )
+    FF_LIBRARY_LOAD_SYMBOL(libpci, pci_cleanup, )
+
+    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_read_byte, )
+    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_read_word, )
+    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_lookup_name, )
+    FF_LIBRARY_LOAD_SYMBOL_VAR(libpci, pci, pci_get_param, )
+
+    pci.access = ffpci_alloc();
+    ffpci_init(pci.access);
+    ffpci_scan_bus(pci.access);
+
+    struct pci_dev* device = pci.access->devices;
+    while(device != NULL)
+    {
+        pciHandleDevice(gpus, &pci, device);
+        device = device->next;
+    }
+
+    ffpci_cleanup(pci.access);
+    dlclose(libpci);
+}
+
+#endif
+
+void ffDetectGPUImpl(FFlist* gpus, const FFinstance* instance)
+{
+    #ifdef FF_HAVE_LIBPCI
+        pciDetectGPUs(instance, gpus);
+    #endif
+}

src/detection/gtk.c

@@ -1,4 +1,8 @@
 #include "fastfetch.h"
+#include "detection/gtk.h"
+#include "common/properties.h"
+#include "common/settings.h"
+#include "detection/displayserver/displayserver.h"
 
 #include <pthread.h>
 
@@ -10,7 +14,7 @@ static inline bool allPropertiesSet(FFGTKResult* result)
         result->font.length > 0;
 }
 
-static inline void applyGTKDConfSettings(FFGTKResult* result, const char* themeName, const char* iconsName, const char* fontName, const char* cursorTheme, int cursorSize)
+static inline void applyGTKSettings(FFGTKResult* result, const char* themeName, const char* iconsName, const char* fontName, const char* cursorTheme, int cursorSize)
 {
     if(result->theme.length == 0)
         ffStrbufAppendS(&result->theme, themeName);
@@ -28,7 +32,7 @@ static inline void applyGTKDConfSettings(FFGTKResult* result, const char* themeN
         ffStrbufAppendF(&result->cursorSize, "%i", cursorSize);
 }
 
-static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
+static void detectGTKFromSettings(FFinstance* instance, FFGTKResult* result)
 {
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
@@ -45,7 +49,7 @@ static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
     if(init)
     {
         pthread_mutex_unlock(&mutex);
-        applyGTKDConfSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
+        applyGTKSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
         return;
     }
 
@@ -53,7 +57,15 @@ static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
 
     const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
 
-    if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Cinnamon") == 0)
+    if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Xfce") == 0 || ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Xfce4") == 0)
+    {
+        themeName = ffSettingsGetXFConf(instance, "xsettings", "/Net/ThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        iconsName = ffSettingsGetXFConf(instance, "xsettings", "/Net/IconThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        fontName = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/FontName", FF_VARIANT_TYPE_STRING).strValue;
+        cursorTheme = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/CursorThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        cursorSize = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/CursorThemeSize", FF_VARIANT_TYPE_INT).intValue;
+    }
+    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Cinnamon") == 0)
     {
         themeName = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/gtk-theme", "org.cinnamon.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
         iconsName = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/icon-theme", "org.cinnamon.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
@@ -69,7 +81,7 @@ static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
         cursorTheme = ffSettingsGet(instance, "/org/mate/peripherals-mouse/cursor-theme", "org.mate.peripherals-mouse", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
         cursorSize = ffSettingsGet(instance, "/org/mate/peripherals-mouse/cursor-size", "org.mate.peripherals-mouse", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
     }
-    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Gnome") == 0)
+    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Gnome") == 0 || ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Unity") == 0 || ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Budgie") == 0)
     {
         themeName = ffSettingsGet(instance, "/org/gnome/desktop/interface/gtk-theme", "org.gnome.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
         iconsName = ffSettingsGet(instance, "/org/gnome/desktop/interface/icon-theme", "org.gnome.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
@@ -79,7 +91,7 @@ static void detectGTKFromDConf(FFinstance* instance, FFGTKResult* result)
     }
 
     pthread_mutex_unlock(&mutex);
-    applyGTKDConfSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
+    applyGTKSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
 }
 
 static void detectGTKFromConfigFile(const char* filename, FFGTKResult* result)
@@ -95,15 +107,10 @@ static void detectGTKFromConfigFile(const char* filename, FFGTKResult* result)
 
 static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFGTKResult* result)
 {
-    //In case of an empty env variable
-    ffStrbufTrim(configDir, ' ');
-    if(configDir->length == 0)
-        return;
-
     uint32_t configDirLength = configDir->length;
 
     // <configdir>/gtk-<version>.0/settings.ini
-    ffStrbufAppendS(configDir, "/gtk-");
+    ffStrbufAppendS(configDir, "gtk-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0/settings.ini");
     detectGTKFromConfigFile(configDir->chars, result);
@@ -112,7 +119,7 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
         return;
 
     // <configdir>/gtk-<version>.0/gtkrc
-    ffStrbufAppendS(configDir, "/gtk-");
+    ffStrbufAppendS(configDir, "gtk-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0/gtkrc");
     detectGTKFromConfigFile(configDir->chars, result);
@@ -121,7 +128,7 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
         return;
 
     // <configdir>/gtkrc-<version>.0
-    ffStrbufAppendS(configDir, "/gtkrc-");
+    ffStrbufAppendS(configDir, "gtkrc-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0");
     detectGTKFromConfigFile(configDir->chars, result);
@@ -130,7 +137,7 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
         return;
 
     // <configdir>/.gtkrc-<version>.0
-    ffStrbufAppendS(configDir, "/.gtkrc-");
+    ffStrbufAppendS(configDir, ".gtkrc-");
     ffStrbufAppendS(configDir, version);
     ffStrbufAppendS(configDir, ".0");
     detectGTKFromConfigFile(configDir->chars, result);
@@ -139,27 +146,25 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
 
 static void detectGTK(FFinstance* instance, const char* version, FFGTKResult* result)
 {
+    //Mate, Cinnamon and Gnome use dconf to save theme config
+    //On other DEs, this will do nothing
+    detectGTKFromSettings(instance, result);
+    if(allPropertiesSet(result))
+        return;
+
     //We need to do this because we use multiple threads on configDirs
-    FFstrbuf baseDirCopy;
-    ffStrbufInitA(&baseDirCopy, 64);
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
 
     for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
     {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-        ffStrbufSet(&baseDirCopy, baseDir);
-        detectGTKFromConfigDir(&baseDirCopy, version, result);
+        ffStrbufSet(&baseDir, ffListGet(&instance->state.configDirs, i));
+        detectGTKFromConfigDir(&baseDir, version, result);
         if(allPropertiesSet(result))
-        {
-            ffStrbufDestroy(&baseDirCopy);
-            return;
-        }
+            break;
     }
 
-    ffStrbufDestroy(&baseDirCopy);
-
-    //Mate, Cinnamon and Gnome use dconf to save theme config
-    //On other DEs, this will do nothing
-    detectGTKFromDConf(instance, result);
+    ffStrbufDestroy(&baseDir);
 }
 
 #define FF_DETECT_GTK_IMPL(version) \

src/detection/gtk.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_gtk
+#define FF_INCLUDED_detection_gtk
+
+#include "fastfetch.h"
+
+typedef struct FFGTKResult
+{
+    FFstrbuf theme;
+    FFstrbuf icons;
+    FFstrbuf font;
+    FFstrbuf cursor;
+    FFstrbuf cursorSize;
+} FFGTKResult;
+
+const FFGTKResult* ffDetectGTK2(FFinstance* instance);
+const FFGTKResult* ffDetectGTK4(FFinstance* instance);
+const FFGTKResult* ffDetectGTK3(FFinstance* instance);
+
+#endif

src/detection/host/host.c

@@ -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)
+    );
+}

src/detection/host/host.h

@@ -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

src/detection/host/host_android.c

@@ -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);
+}

src/detection/host/host_apple.c

@@ -0,0 +1,24 @@
+#include "host.h"
+#include "common/settings.h"
+
+void ffDetectHostImpl(FFHostResult* host)
+{
+    ffStrbufInit(&host->productName);
+
+    ffStrbufInitA(&host->productFamily, 0);
+    ffStrbufInitA(&host->sysVendor, 0);
+    ffStrbufInitA(&host->productVersion, 0);
+    ffStrbufInitA(&host->productSku, 0);
+    ffStrbufInitA(&host->biosDate, 0);
+    ffStrbufInitA(&host->biosRelease, 0);
+    ffStrbufInitA(&host->biosVendor, 0);
+    ffStrbufInitA(&host->biosVersion, 0);
+    ffStrbufInitA(&host->boardName, 0);
+    ffStrbufInitA(&host->boardVendor, 0);
+    ffStrbufInitA(&host->boardVersion, 0);
+    ffStrbufInitA(&host->chassisType, 0);
+    ffStrbufInitA(&host->chassisVendor, 0);
+    ffStrbufInitA(&host->chassisVersion, 0);
+
+    ffSettingsGetAppleProperty("hw.model", &host->productName);
+}

src/detection/host/host_linux.c

@@ -0,0 +1,118 @@
+#include "host.h"
+#include "common/io.h"
+
+#include <stdlib.h>
+
+static bool hostValueSet(FFstrbuf* value)
+{
+    return
+        value->length > 0 &&
+        ffStrbufStartsWithIgnCaseS(value, "To be filled") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "To be set") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "OEM") != true &&
+        ffStrbufStartsWithIgnCaseS(value, "O.E.M.") != true &&
+        ffStrbufIgnCaseCompS(value, "None") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Product Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Name") != 0 &&
+        ffStrbufIgnCaseCompS(value, "System Version") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Default string") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Undefined") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Specified") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Not Applicable") != 0 &&
+        ffStrbufIgnCaseCompS(value, "INVALID") != 0 &&
+        ffStrbufIgnCaseCompS(value, "Type1ProductConfigId") != 0 &&
+        ffStrbufIgnCaseCompS(value, "All Series") != 0
+    ;
+}
+
+static void getHostValue(const char* devicesPath, const char* classPath, FFstrbuf* buffer)
+{
+    ffReadFileBuffer(devicesPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffReadFileBuffer(classPath, buffer);
+    if(hostValueSet(buffer))
+        return;
+
+    ffStrbufClear(buffer);
+}
+
+static void getHostProductName(FFstrbuf* name)
+{
+    getHostValue("/sys/devices/virtual/dmi/id/product_name", "/sys/class/dmi/id/product_name", name);
+    if(name->length > 0)
+        return;
+
+    ffReadFileBuffer("/sys/firmware/devicetree/base/model", name);
+    if(hostValueSet(name))
+        return;
+
+    //does a clear before the read
+    ffReadFileBuffer("/tmp/sysinfo/model", name);
+    if(hostValueSet(name))
+        return;
+
+    ffStrbufClear(name);
+}
+
+void ffDetectHostImpl(FFHostResult* host)
+{
+    ffStrbufInit(&host->productFamily);
+    getHostValue("/sys/devices/virtual/dmi/id/product_family", "/sys/class/dmi/id/product_family", &host->productFamily);
+
+    ffStrbufInit(&host->productName);
+    getHostProductName(&host->productName);
+
+    ffStrbufInit(&host->productVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/product_version", "/sys/class/dmi/id/product_version", &host->productVersion);
+
+    ffStrbufInit(&host->productSku);
+    getHostValue("/sys/devices/virtual/dmi/id/product_sku", "/sys/class/dmi/id/product_sku", &host->productSku);
+
+    ffStrbufInit(&host->biosDate);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_date", "/sys/class/dmi/id/bios_date", &host->biosDate);
+
+    ffStrbufInit(&host->biosRelease);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_release", "/sys/class/dmi/id/bios_release", &host->biosRelease);
+
+    ffStrbufInit(&host->biosVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_vendor", "/sys/class/dmi/id/bios_vendor", &host->biosVendor);
+
+    ffStrbufInit(&host->biosVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/bios_version", "/sys/class/dmi/id/bios_version", &host->biosVersion);
+
+    ffStrbufInit(&host->boardName);
+    getHostValue("/sys/devices/virtual/dmi/id/board_name", "/sys/class/dmi/id/board_name", &host->boardName);
+
+    ffStrbufInit(&host->boardVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/board_vendor", "/sys/class/dmi/id/board_vendor", &host->boardVendor);
+
+    ffStrbufInit(&host->boardVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/board_version", "/sys/class/dmi/id/board_version", &host->boardVersion);
+
+    ffStrbufInit(&host->chassisType);
+    getHostValue("/sys/devices/virtual/dmi/id/chassis_type", "/sys/class/dmi/id/chassis_type", &host->chassisType);
+
+    ffStrbufInit(&host->chassisVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/chassis_vendor", "/sys/class/dmi/id/chassis_vendor", &host->chassisVendor);
+
+    ffStrbufInit(&host->chassisVersion);
+    getHostValue("/sys/devices/virtual/dmi/id/chassis_version", "/sys/class/dmi/id/chassis_version", &host->chassisVersion);
+
+    ffStrbufInit(&host->sysVendor);
+    getHostValue("/sys/devices/virtual/dmi/id/sys_vendor", "/sys/class/dmi/id/sys_vendor", &host->sysVendor);
+
+    //KVM/Qemu virtual machine
+    if(ffStrbufStartsWithS(&host->productName, "Standard PC"))
+        ffStrbufPrependS(&host->productName, "KVM/QEMU ");
+
+    //On WSL, the real host can't be detected. Instead use WSL as host.
+    if(host->productFamily.length == 0 && host->productName.length == 0 && (
+        getenv("WSLENV") != NULL ||
+        getenv("WSL_DISTRO") != NULL ||
+        getenv("WSL_INTEROP") != NULL
+    )) ffStrbufAppendS(&host->productName, FF_HOST_PRODUCT_NAME_WSL);
+}

src/detection/internal.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_internal
+#define FF_INCLUDED_detection_internal
+
+#include "pthread.h"
+
+#define FF_DETECTION_INTERNAL_GUARD(ResultType, ...) \
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \
+    static ResultType result; \
+    static bool init = false; \
+    pthread_mutex_lock(&mutex); \
+    if(init) \
+    { \
+        pthread_mutex_unlock(&mutex); \
+        return &result; \
+    } \
+    init = true; \
+    __VA_ARGS__; \
+    pthread_mutex_unlock(&mutex); \
+    return &result; \
+
+#endif

src/detection/media.c

@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "detection/media.h"
 
 #include <string.h>
 #include <pthread.h>
@@ -7,6 +8,8 @@
 #define FF_DBUS_TIMEOUT_MILLISECONDS 35
 
 #ifdef FF_HAVE_DBUS
+#include "common/library.h"
+#include "common/parsing.h"
 #include <dbus/dbus.h>
 
 #define FF_DBUS_ITER_CONTINUE(iterator) \
@@ -200,7 +203,7 @@ static bool getBusProperties(const char* busName, FFMediaResult* result, DBusDat
         else if(strcmp(key, "xesam:url") == 0)
             getValue(&dictIterator, &result->url, data);
 
-        if(result->song.length > 0 && result->artist.length > 0 && result->album.length > 0)
+        if(result->song.length > 0 && result->artist.length > 0 && result->album.length > 0 && result->url.length > 0)
             break;
 
         FF_DBUS_ITER_CONTINUE(arrayIterator)
@@ -216,12 +219,15 @@ static bool getBusProperties(const char* busName, FFMediaResult* result, DBusDat
         return false;
     }
 
+    //Set short bus name
+    ffStrbufAppendS(&result->busNameShort, busName + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
+
     //We found a song, get the player name
-
     getPropertyString(busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2", "Identity", &result->player, data);
-
     if(result->player.length == 0)
         getPropertyString(busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2", "DesktopEntry", &result->player, data);
+    if(result->player.length == 0)
+        ffStrbufAppend(&result->player, &result->busNameShort);
 
     return true;
 }
@@ -230,13 +236,10 @@ static void getCustomBus(FFinstance* instance, FFMediaResult* result, DBusData*
 {
     if(ffStrbufStartsWithS(&instance->config.playerName, FF_DBUS_MPRIS_PREFIX))
     {
-        ffStrbufAppendS(&result->busNameShort, instance->config.playerName.chars + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
         getBusProperties(instance->config.playerName.chars, result, data);
         return;
     }
 
-    ffStrbufAppend(&result->busNameShort, &instance->config.playerName);
-
     FFstrbuf busName;
     ffStrbufInit(&busName);
     ffStrbufAppendS(&busName, FF_DBUS_MPRIS_PREFIX);
@@ -247,6 +250,12 @@ static void getCustomBus(FFinstance* instance, FFMediaResult* result, DBusData*
 
 static void getBestBus(FFMediaResult* result, DBusData* data)
 {
+    if(
+        getBusProperties(FF_DBUS_MPRIS_PREFIX"spotify", result, data) ||
+        getBusProperties(FF_DBUS_MPRIS_PREFIX"vlc", result, data) ||
+        getBusProperties(FF_DBUS_MPRIS_PREFIX"plasma-browser-integration", result, data)
+    ) return;
+
     DBusMessage* message = data->ffdbus_message_new_method_call("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames");
     if(message == NULL)
         return;
@@ -274,10 +283,7 @@ static void getBestBus(FFMediaResult* result, DBusData* data)
             FF_DBUS_ITER_CONTINUE(arrayIterator)
 
         if(getBusProperties(busName, result, data))
-        {
-            ffStrbufAppendS(&result->busNameShort, busName + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
             break;
-        }
 
         FF_DBUS_ITER_CONTINUE(arrayIterator)
     }
@@ -291,21 +297,21 @@ static void getMedia(FFinstance* instance, FFMediaResult* result)
 
     FF_LIBRARY_LOAD(dbus, instance->config.libDBus, , "libdbus-1.so", 4);
     FF_LIBRARY_LOAD_SYMBOL(dbus, dbus_bus_get,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_new_method_call, dbus_message_new_method_call,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_init, dbus_message_iter_init,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_init_append, dbus_message_iter_init_append,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_append_basic, dbus_message_iter_append_basic,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_get_arg_type, dbus_message_iter_get_arg_type,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_get_basic, dbus_message_iter_get_basic,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_recurse, dbus_message_iter_recurse,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_has_next, dbus_message_iter_has_next,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_iter_next, dbus_message_iter_next,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_message_unref, dbus_message_unref,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_connection_send_with_reply, dbus_connection_send_with_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_connection_flush, dbus_connection_flush,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_pending_call_block, dbus_pending_call_block,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_pending_call_steal_reply, dbus_pending_call_steal_reply,)
-    FF_LIBRARY_LOAD_SYMBOL_ADRESS(dbus, data.ffdbus_pending_call_unref, dbus_pending_call_unref,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_new_method_call,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_init,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_init_append,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_append_basic,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_get_arg_type,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_get_basic,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_recurse,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_has_next,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_iter_next,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_message_unref,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_connection_send_with_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_connection_flush,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_pending_call_block,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_pending_call_steal_reply,)
+    FF_LIBRARY_LOAD_SYMBOL_VAR(dbus, data, dbus_pending_call_unref,)
 
     data.connection = ffdbus_bus_get(DBUS_BUS_SESSION, NULL);
     if(data.connection == NULL)
@@ -349,19 +355,15 @@ const FFMediaResult* ffDetectMedia(FFinstance* instance)
         getMedia(instance, &result);
     #endif
 
-    //Set busNameShort if a custom player was given, but loading dbus failed
-    if(instance->config.playerName.length > 0 && result.busNameShort.length == 0)
+    //Set player if a custom player was given, but loading with dbus failed
+    if(instance->config.playerName.length > 0 && result.song.length == 0)
     {
         if(ffStrbufStartsWithS(&instance->config.playerName, FF_DBUS_MPRIS_PREFIX))
-            ffStrbufAppendS(&result.busNameShort, instance->config.playerName.chars + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
+            ffStrbufAppendS(&result.player, instance->config.playerName.chars + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
         else
-            ffStrbufAppend(&result.busNameShort, &instance->config.playerName);
+            ffStrbufAppend(&result.player, &instance->config.playerName);
     }
 
-    //Set player to busNameShort, if detection failed
-    if(result.player.length == 0)
-        ffStrbufAppend(&result.player, &result.busNameShort);
-
     pthread_mutex_unlock(&mutex);
     return &result;
 }

src/detection/media.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_media
+#define FF_INCLUDED_detection_media
+
+#include "fastfetch.h"
+
+typedef struct FFMediaResult
+{
+    FFstrbuf busNameShort; //e.g. plasma-browser-integration
+    FFstrbuf player; // e.g. Google Chrome
+    FFstrbuf song;
+    FFstrbuf artist;
+    FFstrbuf album;
+    FFstrbuf url;
+} FFMediaResult;
+
+const FFMediaResult* ffDetectMedia(FFinstance* instance);
+
+#endif

src/detection/memory/memory.c

@@ -0,0 +1,21 @@
+#include "memory.h"
+#include "detection/internal.h"
+
+void ffDetectMemoryImpl(FFMemoryResult* memory);
+
+static void calculatePercentage(FFMemoryStorage* storage)
+{
+    if(storage->bytesTotal == 0)
+        storage->percentage = 0;
+    else
+        storage->percentage = (uint8_t) ((storage->bytesUsed / (long double) storage->bytesTotal) * 100.0);
+}
+
+const FFMemoryResult* ffDetectMemory()
+{
+    FF_DETECTION_INTERNAL_GUARD(FFMemoryResult,
+        ffDetectMemoryImpl(&result);
+        calculatePercentage(&result.ram);
+        calculatePercentage(&result.swap);
+    );
+}

src/detection/memory/memory.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_memory_memory
+#define FF_INCLUDED_detection_memory_memory
+
+#include "fastfetch.h"
+
+typedef struct FFMemoryStorage
+{
+    uint64_t bytesUsed;
+    uint64_t bytesTotal;
+    uint8_t percentage;
+} FFMemoryStorage;
+
+typedef struct FFMemoryResult
+{
+    FFMemoryStorage ram;
+    FFMemoryStorage swap;
+} FFMemoryResult;
+
+const FFMemoryResult* ffDetectMemory();
+
+#endif

src/detection/memory/memory_apple.c

@@ -0,0 +1,24 @@
+#include "memory.h"
+#include "common/settings.h"
+
+
+#include <string.h>
+#include <mach/mach.h>
+
+void ffDetectMemoryImpl(FFMemoryResult* memory)
+{
+    memset(memory, 0, sizeof(FFMemoryResult));
+
+    memory->ram.bytesTotal = (uint64_t) ffSettingsGetAppleInt64("hw.memsize", 0);
+
+    uint32_t pagesize = (uint32_t) ffSettingsGetAppleInt("hw.pagesize", 0);
+    if(pagesize == 0)
+        return;
+
+    mach_msg_type_number_t count = HOST_VM_INFO_COUNT;
+    vm_statistics_data_t vmstat;
+    if(host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t) (&vmstat), &count) != KERN_SUCCESS)
+        return;
+
+    memory->ram.bytesUsed = ((uint64_t) vmstat.active_count + vmstat.wire_count) * pagesize;
+}

src/detection/memory/memory_linux.c

@@ -0,0 +1,48 @@
+#include "memory.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+void ffDetectMemoryImpl(FFMemoryResult* memory)
+{
+    memset(memory, 0, sizeof(FFMemoryResult));
+
+    FILE* meminfo = fopen("/proc/meminfo", "r");
+    if(meminfo == NULL)
+        return;
+
+    char* line = NULL;
+    size_t len = 0;
+
+    uint32_t memTotal = 0,
+             shmem = 0,
+             memFree = 0,
+             buffers = 0,
+             cached = 0,
+             sReclaimable = 0,
+             swapTotal = 0,
+             swapFree = 0;
+
+    while (getline(&line, &len, meminfo) != EOF)
+    {
+        sscanf(line, "MemTotal: %u", &memTotal);
+        sscanf(line, "Shmem: %u", &shmem);
+        sscanf(line, "MemFree: %u", &memFree);
+        sscanf(line, "Buffers: %u", &buffers);
+        sscanf(line, "Cached: %u", &cached);
+        sscanf(line, "SReclaimable: %u", &sReclaimable);
+        sscanf(line, "SwapTotal: %u", &swapTotal);
+        sscanf(line, "SwapFree: %u", &swapFree);
+    }
+
+    if(line != NULL)
+        free(line);
+
+    fclose(meminfo);
+
+    memory->ram.bytesTotal = memTotal * (uint64_t) 1024;
+    memory->ram.bytesUsed = (memTotal + shmem - memFree - buffers - cached - sReclaimable) * (uint64_t) 1024;
+
+    memory->swap.bytesTotal = swapTotal * (uint64_t) 1024;
+    memory->swap.bytesUsed = (swapTotal - swapFree) * (uint64_t) 1024;
+}

src/detection/os/os.c

@@ -0,0 +1,11 @@
+#include "os.h"
+#include "detection/internal.h"
+
+void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance);
+
+const FFOSResult* ffDetectOS(const FFinstance* instance)
+{
+    FF_DETECTION_INTERNAL_GUARD(FFOSResult,
+        ffDetectOSImpl(&result, instance)
+    );
+}

src/detection/os/os.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_os_os
+#define FF_INCLUDED_detection_os_os
+
+#include "fastfetch.h"
+
+typedef struct FFOSResult
+{
+    FFstrbuf name;
+    FFstrbuf prettyName;
+    FFstrbuf id;
+    FFstrbuf idLike;
+    FFstrbuf variant;
+    FFstrbuf variantID;
+    FFstrbuf version;
+    FFstrbuf versionID;
+    FFstrbuf codename;
+    FFstrbuf buildID;
+    FFstrbuf systemName;
+    FFstrbuf architecture;
+} FFOSResult;
+
+const FFOSResult* ffDetectOS(const FFinstance* instance);
+
+#endif

src/detection/os/os_android.c

@@ -0,0 +1,38 @@
+#include "os.h"
+#include "common/settings.h"
+
+void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
+{
+    FF_UNUSED(instance);
+
+    ffStrbufInit(&os->name);
+    ffStrbufSetS(&os->name, "Android");
+
+    ffStrbufInit(&os->prettyName);
+    ffStrbufSetS(&os->prettyName, "Android");
+
+    ffStrbufInit(&os->id);
+    ffStrbufSetS(&os->id, "android");
+
+    ffStrbufInit(&os->version);
+    ffSettingsGetAndroidProperty("ro.build.version.release", &os->version);
+
+    ffStrbufInit(&os->versionID);
+    ffSettingsGetAndroidProperty("ro.build.version.release", &os->versionID);
+
+    ffStrbufInit(&os->codename);
+    ffSettingsGetAndroidProperty("ro.build.version.codename", &os->codename);
+
+    ffStrbufInit(&os->buildID);
+    ffSettingsGetAndroidProperty("ro.build.id", &os->buildID);
+
+    ffStrbufInit(&os->systemName);
+    ffStrbufSetS(&os->systemName, instance->state.utsname.sysname);
+
+    ffStrbufInit(&os->architecture);
+    ffStrbufSetS(&os->architecture, instance->state.utsname.machine);
+
+    ffStrbufInitA(&os->idLike, 0);
+    ffStrbufInitA(&os->variant, 0);
+    ffStrbufInitA(&os->variantID, 0);
+}

src/detection/os/os_apple.c

@@ -0,0 +1,93 @@
+#include "os.h"
+#include "common/properties.h"
+#include "common/settings.h"
+
+#include <stdlib.h>
+#include <sys/sysctl.h>
+
+typedef enum PListKey
+{
+    PLIST_KEY_NAME,
+    PLIST_KEY_VERSION,
+    PLIST_KEY_BUILD,
+    PLIST_KEY_OTHER
+} PListKey;
+
+static void parseFile(FFOSResult* os)
+{
+    FILE* plist = fopen("/System/Library/CoreServices/SystemVersion.plist", "r");
+    if(plist == NULL)
+    return;
+
+    char* line = NULL;
+    size_t len = 0;
+    PListKey key = PLIST_KEY_OTHER;
+
+    FFstrbuf keyBuffer;
+    ffStrbufInit(&keyBuffer);
+
+    while(getline(&line, &len, plist) != EOF)
+    {
+        if(ffParsePropLine(line, "<key>", &keyBuffer))
+        {
+            if(ffStrbufIgnCaseCompS(&keyBuffer, "ProductName") == 0)
+                key = PLIST_KEY_NAME;
+            else if(ffStrbufIgnCaseCompS(&keyBuffer, "ProductUserVisibleVersion") == 0)
+                key = PLIST_KEY_VERSION;
+            else if(ffStrbufIgnCaseCompS(&keyBuffer, "ProductBuildVersion") == 0)
+                key = PLIST_KEY_BUILD;
+            else
+                key = PLIST_KEY_OTHER;
+
+            ffStrbufClear(&keyBuffer);
+            continue;
+        }
+
+        if(key == PLIST_KEY_NAME)
+            ffParsePropLine(line, "<string>", &os->name);
+        else if(key == PLIST_KEY_VERSION)
+            ffParsePropLine(line, "<string>", &os->version);
+        else if(key == PLIST_KEY_BUILD)
+            ffParsePropLine(line, "<string>", &os->buildID);
+    }
+
+    ffStrbufDestroy(&keyBuffer);
+
+    if(line != NULL)
+        free(line);
+
+    fclose(plist);
+}
+
+void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
+{
+    FF_UNUSED(instance);
+
+    ffStrbufInit(&os->name);
+    ffStrbufInit(&os->version);
+    ffStrbufInit(&os->buildID);
+    ffStrbufInit(&os->id);
+    ffStrbufInit(&os->prettyName);
+    ffStrbufInit(&os->versionID);
+    ffStrbufInit(&os->systemName);
+    ffStrbufInit(&os->architecture);
+
+    ffStrbufInitA(&os->codename, 0);
+    ffStrbufInitA(&os->idLike, 0);
+    ffStrbufInitA(&os->variant, 0);
+    ffStrbufInitA(&os->variantID, 0);
+
+    parseFile(os);
+
+    if(ffStrbufStartsWithIgnCaseS(&os->name, "MacOS"))
+        ffStrbufAppendS(&os->id, "macos");
+
+    if(os->version.length == 0)
+        ffSettingsGetAppleProperty("kern.osproductversion", &os->version);
+
+    //TODO map version to pretty name
+    ffStrbufAppend(&os->prettyName, &os->name);
+    ffStrbufAppend(&os->versionID, &os->version);
+    ffSettingsGetAppleProperty("kern.ostype", &os->systemName);
+    ffSettingsGetAppleProperty("hw.machine", &os->architecture);
+}

src/detection/os/os_linux.c

@@ -1,15 +1,20 @@
-#include "fastfetch.h"
+#include "os.h"
+#include "common/properties.h"
+#include "common/parsing.h"
 
 #include <string.h>
-#include <pthread.h>
+#include <stdlib.h>
 
-#if !defined(__ANDROID__)
+static inline bool allRelevantValuesSet(const FFOSResult* result)
+{
+    return result->id.length > 0
+        && result->name.length > 0
+        && result->prettyName.length > 0
+    ;
+}
 
 static bool parseFile(const char* fileName, FFOSResult* result)
 {
-    if(result->id.length > 0 && result->name.length > 0 && result->prettyName.length > 0)
-        return true;
-
     return ffParsePropFileValues(fileName, 13, (FFpropquery[]) {
         {"NAME =", &result->name},
         {"DISTRIB_DESCRIPTION =", &result->prettyName},
@@ -88,73 +93,59 @@ static void getUbuntuFlavour(FFOSResult* result)
     }
 }
 
-#endif
-
-const FFOSResult* ffDetectOS(const FFinstance* instance)
+static void detectOS(FFOSResult* os, const FFinstance* instance)
 {
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFOSResult result;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-    init = true;
-
-    ffStrbufInit(&result.systemName);
-    ffStrbufInit(&result.name);
-    ffStrbufInit(&result.prettyName);
-    ffStrbufInit(&result.id);
-    ffStrbufInit(&result.idLike);
-    ffStrbufInit(&result.variant);
-    ffStrbufInit(&result.variantID);
-    ffStrbufInit(&result.version);
-    ffStrbufInit(&result.versionID);
-    ffStrbufInit(&result.codename);
-    ffStrbufInit(&result.buildID);
-    ffStrbufInit(&result.architecture);
-
-    ffStrbufSetS(&result.systemName, instance->state.utsname.sysname);
-    ffStrbufSetS(&result.architecture, instance->state.utsname.machine);
-
-#if !__ANDROID__
     if(instance->config.osFile.length > 0)
     {
-        parseFile(instance->config.osFile.chars, &result);
+        parseFile(instance->config.osFile.chars, os);
+        return;
     }
-    else if(instance->config.escapeBedrock && parseFile(FASTFETCH_TARGET_DIR_ROOT"/bedrock/etc/bedrock-release", &result))
+
+    if(instance->config.escapeBedrock && parseFile(FASTFETCH_TARGET_DIR_ROOT"/bedrock/etc/bedrock-release", os))
     {
-        if(result.id.length == 0)
-            ffStrbufAppendS(&result.id, "bedrock");
+        if(os->id.length == 0)
+            ffStrbufAppendS(&os->id, "bedrock");
 
-        if(result.name.length == 0)
-            ffStrbufAppendS(&result.name, "Bedrock");
+        if(os->name.length == 0)
+            ffStrbufAppendS(&os->name, "Bedrock");
 
-        if(result.prettyName.length == 0)
-            ffStrbufAppendS(&result.prettyName, "Bedrock Linux");
-    }
-    else
-    {
-        parseFile(FASTFETCH_TARGET_DIR_ROOT"/etc/os-release", &result);
-        parseFile(FASTFETCH_TARGET_DIR_USR"/lib/os-release", &result);
-        parseFile(FASTFETCH_TARGET_DIR_ROOT"/etc/lsb-release", &result);
+        if(os->prettyName.length == 0)
+            ffStrbufAppendS(&os->prettyName, "Bedrock Linux");
+
+        return;
     }
 
-    if(ffStrbufIgnCaseCompS(&result.id, "ubuntu") == 0)
-        getUbuntuFlavour(&result);
+    parseFile(FASTFETCH_TARGET_DIR_ROOT"/etc/os-release", os);
+    if(allRelevantValuesSet(os))
+        return;
 
-#else
-    ffStrbufSetS(&result.name, "Android");
-    ffStrbufSetS(&result.id, "android");
-    ffSettingsGetAndroidProperty("ro.build.version.release", &result.versionID);
-    ffSettingsGetAndroidProperty("ro.build.version.release", &result.version);
-    ffSettingsGetAndroidProperty("ro.build.version.codename", &result.codename);
-    ffSettingsGetAndroidProperty("ro.build.id", &result.buildID);
-#endif
+    parseFile(FASTFETCH_TARGET_DIR_USR"/lib/os-release", os);
+    if(allRelevantValuesSet(os))
+        return;
 
-    pthread_mutex_unlock(&mutex);
-
-    return &result;
+    parseFile(FASTFETCH_TARGET_DIR_ROOT"/etc/lsb-release", os);
+}
+
+void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
+{
+    ffStrbufInit(&os->name);
+    ffStrbufInit(&os->prettyName);
+    ffStrbufInit(&os->id);
+    ffStrbufInit(&os->idLike);
+    ffStrbufInit(&os->variant);
+    ffStrbufInit(&os->variantID);
+    ffStrbufInit(&os->version);
+    ffStrbufInit(&os->versionID);
+    ffStrbufInit(&os->codename);
+    ffStrbufInit(&os->buildID);
+    ffStrbufInit(&os->systemName);
+    ffStrbufInit(&os->architecture);
+
+    ffStrbufSetS(&os->systemName, instance->state.utsname.sysname);
+    ffStrbufSetS(&os->architecture, instance->state.utsname.machine);
+
+    detectOS(os, instance);
+
+    if(ffStrbufIgnCaseCompS(&os->id, "ubuntu") == 0)
+        getUbuntuFlavour(os);
 }

src/detection/qt.c

@@ -1,8 +1,21 @@
 #include "fastfetch.h"
+#include "detection/qt.h"
+#include "common/properties.h"
+#include "detection/displayserver/displayserver.h"
 
+#include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
 
+static inline bool allValuesSet(const FFQtResult* result)
+{
+    return
+        result->widgetStyle.length > 0 &&
+        result->colorScheme.length > 0 &&
+        result->icons.length > 0 &&
+        result->font.length > 0;
+}
+
 typedef enum PlasmaCategory
 {
     PLASMA_CATEGORY_GENERAL,
@@ -11,9 +24,9 @@ typedef enum PlasmaCategory
     PLASMA_CATEGORY_OTHER
 } PlasmaCategory;
 
-static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* result)
+static bool detectPlasmaFromFile(const char* filename, FFQtResult* result)
 {
-    FILE* kdeglobals = fopen(filename->chars, "r");
+    FILE* kdeglobals = fopen(filename, "r");
     if(kdeglobals == NULL)
         return false;
 
@@ -67,10 +80,62 @@ static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* resul
     return true;
 }
 
-const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
+static void detectPlasma(const FFinstance* instance, FFQtResult* result)
 {
+    bool foundAFile = false;
+
+    //We need to do this because we use multiple threads on configDirs
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 64);
+
+    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
+    {
+        ffStrbufSet(&baseDir, ffListGet(&instance->state.configDirs, i));
+        ffStrbufAppendS(&baseDir, "kdeglobals");
+
+        if(detectPlasmaFromFile(baseDir.chars, result))
+            foundAFile = true;
+
+        if(allValuesSet(result))
+        {
+            ffStrbufDestroy(&baseDir);
+            return;
+        }
+    }
+
+    ffStrbufDestroy(&baseDir);
+    if(!foundAFile)
+        return;
+
+    //In Plasma the default value is never set in the config file, but the whole key-value is discarded.
+    ///We must set these values by our self if the file exists (it always does here)
+    if(result->widgetStyle.length == 0)
+        ffStrbufAppendS(&result->widgetStyle, "Breeze");
+
+    if(result->colorScheme.length == 0)
+        ffStrbufAppendS(&result->colorScheme, "BreezeLight");
+
+    if(result->icons.length == 0)
+        ffStrbufAppendS(&result->icons, "Breeze");
+
+    if(result->font.length == 0)
+        ffStrbufAppendS(&result->font, "Noto Sans, 10");
+}
+
+static void detectLXQt(const FFinstance* instance, FFQtResult* result)
+{
+    ffParsePropFileConfigValues(instance, "lxqt/lxqt.conf", 3, (FFpropquery[]) {
+        {"style = ", &result->widgetStyle},
+        {"icon_theme = ", &result->icons},
+        {"font = ", &result->font}
+    });
+}
+
+const FFQtResult* ffDetectQt(FFinstance* instance)
+{
+    static FFQtResult result;
+
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFPlasmaResult result;
     static bool init = false;
     pthread_mutex_lock(&mutex);
     if(init)
@@ -86,57 +151,11 @@ const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
     ffStrbufInit(&result.font);
 
     const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
-    if(ffStrbufIgnCaseCompS(&wmde->deProcessName, "plasmashell") != 0)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
 
-    bool foundAFile = false;
-
-    //We need to do this because we use multiple threads on configDirs
-    FFstrbuf baseDirCopy;
-    ffStrbufInitA(&baseDirCopy, 64);
-
-    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
-    {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-
-        ffStrbufSet(&baseDirCopy, baseDir);
-        ffStrbufAppendS(&baseDirCopy, "/kdeglobals");
-
-        if(detectFromConfigFile(&baseDirCopy, &result))
-            foundAFile = true;
-
-        if(
-            result.widgetStyle.length > 0 &&
-            result.colorScheme.length > 0 &&
-            result.icons.length > 0 &&
-            result.font.length > 0
-        ) break;
-    }
-
-    ffStrbufDestroy(&baseDirCopy);
-
-    if(!foundAFile)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-
-    //In Plasma the default value is never set in the config file, but the whole key-value is discarded.
-    ///We must set these values by our self if the file exists (it always does here)
-    if(result.widgetStyle.length == 0)
-        ffStrbufAppendS(&result.widgetStyle, "Breeze");
-
-    if(result.colorScheme.length == 0)
-        ffStrbufAppendS(&result.colorScheme, "BreezeLight");
-
-    if(result.icons.length == 0)
-        ffStrbufAppendS(&result.icons, "Breeze");
-
-    if(result.font.length == 0)
-        ffStrbufAppendS(&result.font, "Noto Sans, 10");
+    if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "KDE Plasma") == 0)
+        detectPlasma(instance, &result);
+    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "LXQt") == 0)
+        detectLXQt(instance, &result);
 
     pthread_mutex_unlock(&mutex);
     return &result;