Release 1.5.3

Enable LTO by default
Fix compile bug when LTO enabled

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,6 +7,13 @@ assignees: ''
 
 ---
 
+# General description of bug:
+
+
+# Often helpful questions:
+* Does the issue occur across multiple terminal emulators? [Y/N]
+* Does the issue occur across multiple shells? (bash, zsh, fish, etc) [Y/N]
+
 Output of `fastfetch --version`:
 ```
 //paste here
@@ -27,9 +34,8 @@ Output of `fastfetch --list-features`:
 //paste here
 ```
 
+<!--
 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 to much work) for you, post the output of `fastfetch --show-errors --recache --multithreading false --disable-linewrap false`.
+If this isn't possible (or too much work) for you, post the output of `fastfetch --show-errors --recache --multithreading false --disable-linewrap false`. 
+-->
 
-Often helpful questions:
-* Does the issue occur across multiple terminal emulators?
-* Does the issue occur across multiple shells? (bash, zsh, fish, etc)

.github/workflows/pull_request.yml

@@ -0,0 +1,37 @@
+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,101 +1,60 @@
-name: Manage pushes and pull requests
+name: manage pushes
 
 on:
   push:
     branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-env:
-  BUILD_TYPE: Release
 
 jobs:
-  check:
-    name: Build, Run and Analyze fastfetch
+  manage:
+    name: manage push
     runs-on: ubuntu-latest
     permissions:
-      actions: read
       contents: write
       security-events: write
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'cpp' ]
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
+      - name: checkout repository
+        uses: actions/checkout@v2
 
-    - name: Update and install 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 libxfconf-0-dev librpm-dev libzstd-dev
+      - 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
-      with:
-        languages: ${{ matrix.language }}
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
 
-    - name: Configure
-      run: cmake -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} .
+      - 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 .
 
-    - name: Build
-      run: cmake --build . -j$(nproc)
+      - 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 fastfetch
+        run: ./fastfetch --recache --disable-linewrap false --hide-cursor false --show-errors true
 
-    - name: Run flashfetch
-      run: ./flashfetch
+      - name: run flashfetch
+        run: ./flashfetch
 
-    - name: Run tests
-      run: ctest
+      - name: run tests
+        run: ctest
 
-    - name: Build deb package
-      run: sh packaging/deb/create.sh .
+      - name: perform CodeQL analysis
+        uses: github/codeql-action/analyze@v1
 
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
-
-    - name: Create tarball
-      if: github.event_name == 'push'
-      run: tar -cvf fastfetch.tar ./fastfetch -C packaging/deb ./fastfetch.deb
-
-    - name: Upload tarball
-      if: github.event_name == 'push'
-      uses: actions/upload-artifact@v3
-      with:
-        name: fastfetch.tar
-        path: ./fastfetch.tar
-
-  deploy:
-    name: Create GitHub release
-    runs-on: ubuntu-latest
-    needs: check
-    if: github.event_name == 'push'
-    permissions:
-      contents: write
-    steps:
-      - name: Download tarball
-        uses: actions/download-artifact@v3
-        with:
-          name: fastfetch.tar
-          path: ./fastfetch.tar
-
-      - name: Extract tarball
-        run: tar --overwrite -xvf ./fastfetch.tar/fastfetch.tar
-
-      - name: Get fastfetch version
+      - name: get fastfetch version
         id: get_version_fastfetch
         run: echo "::set-output name=release::$(./fastfetch --version-raw)"
 
-      - name: Get latest release version
+      - name: get latest release version
         id: get_version_release
         uses: pozetroninc/github-action-get-latest-release@master
         with:
           repository: ${{ github.repository }}
 
-      - name: Push release
+      - name: create release
         if: steps.get_version_fastfetch.outputs.release != steps.get_version_release.outputs.release
         uses: ncipollo/release-action@v1
         with:
           tag: ${{ steps.get_version_fastfetch.outputs.release }}
           commit: ${{ github.sha }}
-          artifacts: ./fastfetch,./fastfetch.deb
+          artifacts: ./fastfetch-*.*

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "packaging/aur"]
-	path = packaging/aur
-	url = https://aur.archlinux.org/fastfetch-git.git

CMakeLists.txt

@@ -1,15 +1,13 @@
-cmake_minimum_required(VERSION 3.1.0) # Threads::Threads
+cmake_minimum_required(VERSION 3.9.0) # CMAKE_INTERPROCEDURAL_OPTIMIZATION
 
 project(fastfetch
-    VERSION 1.1.2
+    VERSION 1.5.3
     LANGUAGES C
 )
 
-#e.g. +1
-#This allows to track builds between versions, without GitHub creating a new release
-set(PROJECT_VERSION_EXTRA "")
-
-include(GNUInstallDirs)
+#####################
+# Configure options #
+#####################
 
 OPTION(ENABLE_LIBPCI "Enable libpci" ON)
 OPTION(ENABLE_VULKAN "Enable vulkan" ON)
@@ -22,15 +20,91 @@ 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(BUILD_TESTS "Build tests" 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)
+
+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)
+
+####################
+# 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")
+
+include(CheckIPOSupported)
+check_ipo_supported(RESULT IPO_SUPPORTED)
+if(IPO_SUPPORTED)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+endif()
+
+#######################
+# Target FS structure #
+#######################
+
+if(NOT TARGET_DIR_ROOT)
+    if(NOT ANDROID)
+        set(TARGET_DIR_ROOT "")
+    else()
+        set(TARGET_DIR_ROOT "/data/data/com.termux/files/usr")
+    endif()
+endif()
+
+if(NOT TARGET_DIR_USR)
+    if(NOT ANDROID)
+        set(TARGET_DIR_USR "${TARGET_DIR_ROOT}/usr")
+    else()
+        set(TARGET_DIR_USR "${TARGET_DIR_ROOT}")
+    endif()
+endif()
+
+if(NOT TARGET_DIR_HOME)
+    if(NOT ANDROID)
+        set(TARGET_DIR_HOME "${TARGET_DIR_ROOT}/home")
+    else()
+        set(TARGET_DIR_HOME "/data/data/com.termux/files/home")
+    endif()
+endif()
+
+#################
+# Tweak version #
+#################
+
+if (SET_TWEAK AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    execute_process(
+        COMMAND git describe --tags
+        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+        OUTPUT_VARIABLE PROJECT_VERSION_TWEAK
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    string(REGEX MATCH "-[0-9]+" PROJECT_VERSION_TWEAK "${PROJECT_VERSION_TWEAK}")
+endif()
+
+#############
+# Text data #
+#############
 
 function(fastfetch_load_text FILENAME OUTVAR)
     file(READ "${FILENAME}" TEMP)
@@ -48,14 +122,15 @@ 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)
 
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(Threads REQUIRED)
-
-find_package(PkgConfig REQUIRED)
-
-# Init CMake targets.
+#######################
+# libfastfetch target #
+#######################
 
 add_library(libfastfetch STATIC
     src/util/FFstrbuf.c
@@ -64,17 +139,26 @@ add_library(libfastfetch STATIC
     src/common/init.c
     src/common/threading.c
     src/common/io.c
+    src/common/printing.c
+    src/common/caching.c
+    src/common/properties.c
+    src/common/font.c
     src/common/processing.c
-    src/common/logo.c
     src/common/format.c
     src/common/parsing.c
     src/common/settings.c
     src/common/library.c
     src/common/networking.c
+    src/logo/logo.c
+    src/logo/builtin.c
+    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/gtk.c
     src/detection/terminalShell.c
+    src/detection/vulkan.c
     src/detection/media.c
     src/detection/datetime.c
     src/detection/displayserver/displayServer.c
@@ -110,6 +194,7 @@ add_library(libfastfetch STATIC
     src/modules/disk.c
     src/modules/battery.c
     src/modules/locale.c
+    src/modules/vulkan.c
     src/modules/localip.c
     src/modules/publicip.c
     src/modules/player.c
@@ -118,115 +203,222 @@ add_library(libfastfetch STATIC
     src/modules/date.c
     src/modules/time.c
     src/modules/colors.c
+    src/modules/opengl.c
+    src/modules/opencl.c
 )
 
 if(ENABLE_LIBPCI)
-    pkg_check_modules (LIBPCI libpci)
+    pkg_check_modules(LIBPCI libpci)
     if(LIBPCI_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBPCI=1)
-    else(LIBPCI_FOUND)
+    else()
         message(WARNING "Package libpci not found. Building without support.")
-    endif(LIBPCI_FOUND)
-endif(ENABLE_LIBPCI)
+    endif()
+endif()
 
 if(ENABLE_VULKAN)
-    pkg_check_modules (VULKAN vulkan)
+    pkg_check_modules(VULKAN vulkan)
     if(VULKAN_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_VULKAN=1)
-    else(VULKAN_FOUND)
+    else()
         message(WARNING "Package vulkan not found. Building without support.")
-    endif(VULKAN_FOUND)
-endif(ENABLE_VULKAN)
+    endif()
+endif()
 
 if(ENABLE_WAYLAND)
     pkg_check_modules (WAYLAND wayland-client)
     if(WAYLAND_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WAYLAND=1)
-    else(WAYLAND_FOUND)
+    else()
         message(WARNING "Package wayland-client not found. Building without support.")
-    endif(WAYLAND_FOUND)
-endif(ENABLE_WAYLAND)
+    endif()
+endif()
 
 if(ENABLE_XCB_RANDR)
-    pkg_check_modules (XCB_RANDR xcb-randr)
+    pkg_check_modules(XCB_RANDR xcb-randr)
     if(XCB_RANDR_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XCB_RANDR=1)
-    else(XCB_RANDR_FOUND)
+    else()
         message(WARNING "Package xcb-randr not found. Building without support.")
-    endif(XCB_RANDR_FOUND)
-endif(ENABLE_XCB_RANDR)
+    endif()
+endif()
 
 if(ENABLE_XCB)
     pkg_check_modules (XCB xcb)
     if(XCB_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XCB=1)
-    else(XCB_FOUND)
+    else()
         message(WARNING "Package xcb not found. Building without support.")
-    endif(XCB_FOUND)
-endif(ENABLE_XCB)
+    endif()
+endif()
 
 if(ENABLE_XRANDR)
-    pkg_check_modules (XRANDR xrandr)
+    pkg_check_modules(XRANDR xrandr)
     if(XRANDR_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XRANDR=1)
-    else(XRANDR_FOUND)
+    else()
         message(WARNING "Package xrandr not found. Building without support.")
-    endif(XRANDR_FOUND)
-endif(ENABLE_XRANDR)
+    endif()
+endif()
 
 if(ENABLE_X11)
-    pkg_check_modules (X11 x11)
+    pkg_check_modules(X11 x11)
     if(X11_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_X11=1)
-    else(X11_FOUND)
+    else()
         message(WARNING "Package x11 not found. Building without support.")
-    endif(X11_FOUND)
-endif(ENABLE_X11)
+    endif()
+endif()
 
 if(ENABLE_GIO)
-    pkg_check_modules (GIO gio-2.0)
+    pkg_check_modules(GIO gio-2.0)
     if(GIO_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_GIO=1)
-    else(GIO_FOUND)
+    else()
         message(WARNING "Package gio-2.0 not found. Building without support.")
-    endif(GIO_FOUND)
-endif(ENABLE_GIO)
+    endif()
+endif()
 
 if(ENABLE_DCONF)
-    pkg_check_modules (DCONF dconf)
+    pkg_check_modules(DCONF dconf)
     if(DCONF_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_DCONF=1)
-    else(DCONF_FOUND)
+    else()
         message(WARNING "Package dconf not found. Building without support.")
-    endif(DCONF_FOUND)
-endif(ENABLE_DCONF)
+    endif()
+endif()
 
 if(ENABLE_DBUS)
-    pkg_check_modules (DBUS dbus-1)
+    pkg_check_modules(DBUS dbus-1)
     if(DBUS_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_DBUS=1)
-    else(DBUS_FOUND)
+    else()
         message(WARNING "Package dbus-1 not found. Building without support.")
-    endif(DBUS_FOUND)
-endif(ENABLE_DBUS)
+    endif()
+endif()
 
 if(ENABLE_XFCONF)
-    pkg_check_modules (XFCONF libxfconf-0)
+    pkg_check_modules(XFCONF libxfconf-0)
     if(XFCONF_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_XFCONF=1)
-    else(XFCONF_FOUND)
+    else()
         message(WARNING "Package libxfconf-0 not found. Building without support.")
-    endif(XFCONF_FOUND)
-endif(ENABLE_XFCONF)
+    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)
+    pkg_check_modules(RPM rpm)
     if(RPM_FOUND)
         target_compile_definitions(libfastfetch PRIVATE FF_HAVE_RPM=1)
-    else(RPM_FOUND)
-        message(WARNING "Package librpm not found. Building without support.")
-    endif(RPM_FOUND)
-endif(ENABLE_RPM)
+    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)
+    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.")
+        endif()
+    else()
+        message(WARNING "Chafa not enabled, because neither ImageMagick6 nor ImageMagick7 were found. Building without support.")
+    endif()
+endif()
+
+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()
+
+if(ENABLE_GLX)
+    pkg_check_modules(GLX glx)
+    if(GLX_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_GLX=1)
+    else()
+        message(WARNING "Package glx not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_OSMESA)
+    pkg_check_modules(OSMESA osmesa)
+    if(OSMESA_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_OSMESA=1)
+    else()
+        message(WARNING "Package osmesa not found. Building without support.")
+    endif()
+endif()
+
+if(ENABLE_OPENCL)
+    pkg_check_modules(OPENCL OpenCL)
+    if(OPENCL_FOUND)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_OPENCL=1)
+    else()
+        message(WARNING "Package opencl not found. Building without support.")
+    endif()
+endif()
 
 target_include_directories(libfastfetch
     PUBLIC ${PROJECT_BINARY_DIR}
@@ -243,7 +435,17 @@ target_include_directories(libfastfetch
     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
@@ -251,7 +453,13 @@ target_link_libraries(libfastfetch
     PRIVATE Threads::Threads
 )
 
-set_target_properties(libfastfetch PROPERTIES OUTPUT_NAME "fastfetch")
+set_target_properties(libfastfetch PROPERTIES
+    OUTPUT_NAME "fastfetch"
+)
+
+######################
+# Executable targets #
+######################
 
 add_executable(fastfetch
     src/fastfetch.c
@@ -267,7 +475,9 @@ target_link_libraries(flashfetch
     PRIVATE libfastfetch
 )
 
-# Testing.
+###################
+# Testing targets #
+###################
 
 if (BUILD_TESTS)
     add_executable(fastfetch-test-performance
@@ -288,13 +498,22 @@ if (BUILD_TESTS)
     add_test(NAME test-strbuf COMMAND fastfetch-test-strbuf)
 endif()
 
-# Installation.
+##################
+# install target #
+##################
+
+include(GNUInstallDirs)
 
 install(
     TARGETS fastfetch
     DESTINATION ${CMAKE_INSTALL_BINDIR}
 )
 
+install(
+    TARGETS flashfetch
+    DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
 install(
     FILES completions/bash
     DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions
@@ -310,3 +529,25 @@ install(
     FILES ./LICENSE
     DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}
 )
+
+##################
+# package target #
+##################
+
+set(CPACK_GENERATOR "DEB;RPM;TGZ;ZIP")
+
+set(CPACK_PACKAGE_CONTACT "Linus Dierheimer <Linus@Dierheimer.de>")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Neofetch clone written in C")
+set(CPACK_PACKAGE_DESCRIPTION "\
+fastfetch is a neofetch-like tool for fetching system information and displaying them in a pretty way. \
+It is written in c to achieve much better performance.\
+")
+set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/LinusDierheimer")
+
+set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
+set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
+
+set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+
+include(CPack)

DEVELOPMENT.md

@@ -11,12 +11,9 @@ Here i just add things that are easy to forget.
   - `libffdetect`: contains all the detection stuff. To be used by anything that needs system information
   - `libffprint`: contains the printing functions, logos, format etc
   - `fastfetch` and `flashfetch`: Executables, that initialize the config of libffprint. Fist one at runtime, second one at compile time
-- [ ] Support for printing images as ascii art logos (using imlib2 and libcaca probably)
-- [ ] Support for printing images in terminals that support it
 - [ ] Better OS output for all possible combinations of /etc/os-release variables.
 - [ ] Expose temperatures to CPU format string
 - [ ] Expose temperatures to GPU format string
-- [ ] Fallback GPU detection using GL (multi GPU suport somehow possible?)
 - [ ] 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
@@ -25,7 +22,6 @@ Here i just add things that are easy to forget.
 - [ ] Make CPU usage detection much faster and more accurate
 - [ ] Detect CPU usage in a common detection methode and expose it both to the cpuUsage module and the cpu format string
 - [ ] Per session caching
-- [ ] RPM packaging
 
 ### General
 - More presets

README.md

@@ -9,7 +9,7 @@ The output on my personal machine with default configurations looks like this:
 
 With customization and speed being two competing goals, this project actually builds two executables.  
 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 buildt 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).  
+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.
@@ -19,39 +19,48 @@ There are some presets defined for fastfech in [`presets`](presets), you can can
 Fastfetch dynamically loads needed libraries if they are available. Therefore its only hard dependencies are `libc` (any implementation of the c standard library), `libdl` and `libpthread`. They are all shipped with [`glibc`](https://www.gnu.org/software/libc/), which is already installed on most linux distributions, so you probably don't have to worry about it.  
 
 The following libraries are used if present at runtime:
-*  [`libpci`](https://github.com/pciutils/pciutils): GPU output.
-*  [`libvulkan`](https://www.vulkan.org/): Fallback for GPU output.
-*  [`libxcb-randr`](https://xcb.freedesktop.org/),
-   [`libXrandr`](https://gitlab.freedesktop.org/xorg/lib/libxrandr),
-   [`libxcb`](https://xcb.freedesktop.org/),
-   [`libX11`](https://gitlab.freedesktop.org/xorg/lib/libx11): At least one of them sould be present in X11 sessions for better resolution detection and faster WM detection. The `*randr` ones provide multi monitor support. The `libxcb*` ones usually have better performance.
-*  [`libwayland-client`](https://wayland.freedesktop.org/): Better resolution performance and output in wayland sessions. Supports different refresh rates per monitor.
-*  [`libGIO`](https://developer.gnome.org/gio/unstable/): Needed for values that are only stored GSettings.
-*  [`libDConf`](https://developer.gnome.org/dconf/unstable/): Needed for values that are only stored in DConf + Fallback for GSettings.
-*  [`libDBus`](https://www.freedesktop.org/wiki/Software/dbus): Needed for detecting current media player and song.
-*  [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
-*  [`librpm`](http://rpm.org/): Needed for rpm package count.
+* [`libpci`](https://github.com/pciutils/pciutils): GPU output.
+* [`libvulkan`](https://www.vulkan.org/): Vulkan module & fallback for GPU output.
+* [`libxcb-randr`](https://xcb.freedesktop.org/),
+    [`libXrandr`](https://gitlab.freedesktop.org/xorg/lib/libxrandr),
+    [`libxcb`](https://xcb.freedesktop.org/),
+    [`libX11`](https://gitlab.freedesktop.org/xorg/lib/libx11): At least one of them sould be present in X11 sessions for better resolution detection and faster WM detection. The `*randr` ones provide multi monitor support The `libxcb*` ones usually have better performance.
+* [`libwayland-client`](https://wayland.freedesktop.org/): Better resolution performance and output in wayland sessions. Supports different refresh rates per monitor.
+* [`libGIO`](https://developer.gnome.org/gio/unstable/): Needed for values that are only stored GSettings.
+* [`libDConf`](https://developer.gnome.org/dconf/unstable/): Needed for values that are only stored in DConf + Fallback for GSettings.
+* [`libmagickcore` (ImageMagick)](https://www.imagemagick.org/): Images in terminal using sixel or kitty graphics protocol.
+* [`libchafa`](https://github.com/hpjansson/chafa): Image output as ascii art.
+* [`libZ`](https://www.zlib.net/): Faster image output when using kitty graphics protocol.
+* [`libDBus`](https://www.freedesktop.org/wiki/Software/dbus): Needed for detecting current media player and song.
+* [`libEGL`](https://www.khronos.org/registry/EGL/),
+    [`libGLX`](https://dri.freedesktop.org/wiki/GLX/),
+    [`libOSMesa`](https://docs.mesa3d.org/osmesa.html): At least one of them is needed by the OpenGL module for gl context creation.
+* [`libOpenCL`](https://www.khronos.org/opencl/): OpenCL module
+* [`libXFConf`](https://gitlab.xfce.org/xfce/xfconf): Needed for XFWM theme and XFCE Terminal font.
+* [`libsqlite3`](https://www.sqlite.org/index.html): Needed for rpm package count.
+* [`librpm`](http://rpm.org/): Slower fallback for rpm package count. Needed on openSUSE.
 
 ## Support status
 All categories not listed here should work without needing a specific implementation.
 
 ##### Available Modules
 ```
-Title, Separator, OS, Host, Kernel, Uptime, Processes, Packages, Shell, Resolution, DE, WM, WMTheme, Theme, Icons, Font, Cursor, Terminal, Terminal Font, CPU, CPUUsage, GPU, Memory, Disk, Battery, Player, Song, 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, Disk, Battery, Player, Song, Vulkan, OpenGL, OpenCL, LocalIP, PublicIP, DateTime, Date, Time, Locale, Colors, Break, Custom
 ```
 
 ##### Logos
 ```
-Android, Arch, Arco, Artix, CachyOS, CentOS, Debian, Endeavour, Fedora, Garuda, Gentoo, KDE Neon, Linux, Manjaro, Mint, Pop!_OS, RebornOS, Ubuntu, Void, Zorin
+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
 ```
 * Most of the logos have a small variant. Access it by appending _small to the logo name.
 * Some logos have an old variant. Access it by appending _old to the logo name.
 * Unknown/unsupported logos will be replaced with a generic linux logo when running fastfetch.
 * Get a list of all available logos with `fastfetch --print-logos`.
+* Printing images as logo is supported using Sixel or Kitty graphics protocol.
 
 ##### Package managers
 ```
-Pacman, dpkg, rpm, emerge, xbps, Flatpak, Snap
+Pacman, dpkg, rpm, emerge, xbps, nix, Flatpak, Snap
 ```
 
 ##### WM themes
@@ -76,20 +85,23 @@ 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: Run [`packaging/deb/create.sh`](packaging/deb/create.sh) from the root directory. You can give a custom build directory as an argument.
-* 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
+
+Build: Follow the [build instructions](#building).
+
+* Create DEB / RPM: Run `cmake --build . --target package`.
+* Install directly: Run `sudo cmake --install . --prefix /usr/local`
 
 ## FAQ
 

completions/bash

@@ -122,8 +122,7 @@ __fastfetch_completion()
         "--recache"
         "--nocache"
         "--show-errors"
-        "--color-logo"
-        "--print-remaining-logo"
+        "--logo-print-remaining"
         "--multithreading"
         "--allow-slow-operations"
         "--disable-linewrap"
@@ -131,18 +130,31 @@ __fastfetch_completion()
         "--localip-show-ipv4"
         "--localip-show-ipv6"
         "--localip-show-loop"
+        "--escape-bedrock"
+        "--pipe"
     )
 
     local FF_OPTIONS_STRING=(
+        "--logo-type"
+        "--logo-padding"
+        "--logo-padding-left"
+        "--logo-padding-right"
+        "--logo-color-1"
+        "--logo-color-2"
+        "--logo-color-3"
+        "--logo-color-4"
+        "--logo-color-5"
+        "--logo-color-6"
+        "--logo-color-7"
+        "--logo-color-8"
+        "--logo-color-9"
         "-c"
         "--color"
-        "--spacing"
-        "-s"
         "--separator"
-        "-x"
-        "--offsetx"
+        "-s"
         "--structure"
         "--set"
+        "--gl"
         "--os-format"
         "--os-key"
         "--host-format"
@@ -207,6 +219,12 @@ __fastfetch_completion()
         "--date-key"
         "--time-format"
         "--time-key"
+        "--vulkan-key"
+        "--vulkan-format"
+        "--opengl-key"
+        "--opengl-format"
+        "--opencl-key"
+        "--opencl-format"
     )
 
     local FF_OPTIONS_PATH=(
@@ -222,7 +240,15 @@ __fastfetch_completion()
         "--lib-DConf"
         "--lib-DBus"
         "--lib-XFConf"
-        "--lib-RPM"
+        "--lib-sqlite3"
+        "--lib-rpm"
+        "--lib-imagemagick"
+        "--lib-z"
+        "--lib-chafa"
+        "--lib-egl"
+        "--lib-glx"
+        "--lib-osmesa"
+        "--lib-opencl"
         "--battery-dir"
         "--load-config"
     )

packaging/deb/control-template

@@ -1,13 +0,0 @@
-Package: fastfetch
-Version: <VERSION>
-Section: utils
-Priority: extra
-Architecture: amd64
-Maintainer: Linus@Dierheimer.de
-Homepage: https://github.com/LinusDierheimer/fastfetch
-Installed-Size: 410K
-Description: A fast alternative to neofetch
- 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, in return only Linux and Android are supported. It also uses
- mechanisms like multithreading and caching to finish as fast as possible.

packaging/deb/create.sh

@@ -1,28 +0,0 @@
-#!/bin/sh
-
-# This script is intended to be run from the root of the repository.
-# If you don't want to use build/ as build directoy, or already build the elsewere, you can give the build directoy as argument.
-
-BUILD_DIR="${1:-build}"
-ROOT_DIR="${2:-.}"
-PACKAGE_DIR="${BUILD_DIR}/packaging/deb/fastfetch"
-
-# Create missing files
-mkdir -p "${BUILD_DIR}" || exit 1
-
-if [ ! -f "${BUILD_DIR}/cmake_install.cmake" ]; then
-    cmake -S "${ROOT_DIR}" -B "${BUILD_DIR}" || exit 2
-    rm -f "${BUILD_DIR}/fastfetch" || exit 3 # Always rebuild the project if we reconfigured it
-fi
-
-if [ ! -f "${BUILD_DIR}/fastfetch" ]; then
-    cmake --build "${BUILD_DIR}" || exit 4
-fi
-
-# Populate the files
-cmake --install "${BUILD_DIR}" --prefix "${PACKAGE_DIR}/usr" || exit 5
-mkdir -p "${PACKAGE_DIR}/DEBIAN" || exit 6
-sed "s/<VERSION>/$("${BUILD_DIR}/fastfetch" --version-raw)/g" "${ROOT_DIR}/packaging/deb/control-template" > "${PACKAGE_DIR}/DEBIAN/control" || exit 7
-
-# Create the package
-dpkg-deb --build "${PACKAGE_DIR}" || exit 8

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

presets/verbose

@@ -26,3 +26,6 @@
 --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: {}"

src/common/caching.c

@@ -0,0 +1,200 @@
+#include "fastfetch.h"
+
+#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)
+{
+    ffStrbufAppend(buffer, &instance->state.cacheDir);
+    ffStrbufAppendS(buffer, moduleName);
+
+    if(extension != NULL)
+    {
+        ffStrbufAppendC(buffer, '.');
+        ffStrbufAppendS(buffer, extension);
+    }
+}
+
+static void readCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
+{
+    FFstrbuf path;
+    ffStrbufInitA(&path, 64);
+    getCacheFilePath(instance, moduleName, extension, &path);
+    ffAppendFileContent(path.chars, buffer);
+    ffStrbufDestroy(&path);
+}
+
+static void writeCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* content)
+{
+    FFstrbuf path;
+    ffStrbufInitA(&path, 64);
+    getCacheFilePath(instance, moduleName, extension, &path);
+    ffWriteFileContent(path.chars, content);
+    ffStrbufDestroy(&path);
+}
+
+void ffCacheValidate(FFinstance* instance)
+{
+    FFstrbuf content;
+    ffStrbufInit(&content);
+    readCacheFile(instance, "cacheversion", "ffv", &content);
+
+    bool isSameVersion = ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0;
+    ffStrbufDestroy(&content);
+    if(isSameVersion)
+        return;
+
+    instance->config.recache = true;
+
+    FFstrbuf version;
+    ffStrbufInitA(&version, sizeof(FASTFETCH_PROJECT_VERSION));
+    ffStrbufAppendS(&version, FASTFETCH_PROJECT_VERSION);
+    writeCacheFile(instance, "cacheversion", "ffv", &version);
+    ffStrbufDestroy(&version);
+}
+
+void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache)
+{
+    FFstrbuf cacheFileValue;
+    ffStrbufInitA(&cacheFileValue, 64);
+    getCacheFilePath(instance, moduleName, FF_CACHE_VALUE_EXTENSION, &cacheFileValue);
+    cache->value = fopen(cacheFileValue.chars, "w");
+    ffStrbufDestroy(&cacheFileValue);
+
+    FFstrbuf cacheFileSplit;
+    ffStrbufInitA(&cacheFileSplit, 64);
+    getCacheFilePath(instance, moduleName, FF_CACHE_SPLIT_EXTENSION, &cacheFileSplit);
+    cache->split = fopen(cacheFileSplit.chars, "w");
+    ffStrbufDestroy(&cacheFileSplit);
+}
+
+void ffCacheClose(FFcache* cache)
+{
+    if(cache->value != NULL)
+        fclose(cache->value);
+
+    if(cache->split != NULL)
+        fclose(cache->split);
+}
+
+static bool printCachedValue(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 512);
+    readCacheFile(instance, moduleName, FF_CACHE_VALUE_EXTENSION, &content);
+
+    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
+
+    if(content.length == 0)
+        return false;
+
+    uint8_t moduleCounter = 1;
+
+    uint32_t startIndex = 0;
+    while(startIndex < content.length)
+    {
+        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
+        uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+        puts(content.chars + startIndex);
+        startIndex = nullByteIndex + 1;
+        ++moduleCounter;
+    }
+
+    ffStrbufDestroy(&content);
+
+    return moduleCounter > 1;
+}
+
+static bool printCachedFormat(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 512);
+    readCacheFile(instance, moduleName, FF_CACHE_SPLIT_EXTENSION, &content);
+
+    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
+
+    if(content.length == 0)
+        return false;
+
+    uint8_t moduleCounter = 1;
+
+    FFformatarg* arguments = calloc(numArgs, sizeof(FFformatarg));
+    uint32_t argumentCounter = 0;
+
+    uint32_t startIndex = 0;
+    while(startIndex < content.length)
+    {
+        arguments[argumentCounter].type = FF_FORMAT_ARG_TYPE_STRING;
+        arguments[argumentCounter].value = &content.chars[startIndex];
+        ++argumentCounter;
+
+        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
+
+        if(argumentCounter == numArgs)
+        {
+            uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
+            ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
+            ++moduleCounter;
+            argumentCounter = 0;
+        }
+
+        startIndex = nullByteIndex + 1;
+    }
+
+    free(arguments);
+    ffStrbufDestroy(&content);
+
+    return moduleCounter > 1;
+}
+
+bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
+{
+    if(instance->config.recache)
+        return false;
+
+    if(formatString == NULL || formatString->length == 0)
+        return printCachedValue(instance, moduleName, customKeyFormat);
+    else
+        return printCachedFormat(instance, moduleName, customKeyFormat, formatString, 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)
+{
+    if(formatString == NULL || formatString->length == 0)
+    {
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+        ffStrbufPutTo(value, stdout);
+    }
+    else
+    {
+        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
+    }
+
+    if(cache->value != NULL)
+    {
+        ffStrbufWriteTo(value, cache->value);
+        fputc('\0', cache->value);
+    }
+
+    if(cache->split == NULL)
+        return;
+
+    for(uint32_t i = 0; i < numArgs; i++)
+    {
+        FFstrbuf buffer;
+        ffStrbufInitA(&buffer, 64);
+        ffFormatAppendFormatArg(&buffer, &arguments[i]);
+        ffStrbufWriteTo(&buffer, cache->split);
+        ffStrbufDestroy(&buffer);
+        fputc('\0', cache->split);
+    }
+}
+
+void ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments)
+{
+    FFcache cache;
+    ffCacheOpenWrite(instance, moduleName, &cache);
+    ffPrintAndAppendToCache(instance, moduleName, 0, customKeyFormat, &cache, value, formatString, numArgs, arguments);
+    ffCacheClose(&cache);
+}

src/common/font.c

@@ -0,0 +1,207 @@
+#include "fastfetch.h"
+
+#include <string.h>
+
+static void fontInit(FFfont* font)
+{
+    ffStrbufInit(&font->pretty);
+    ffStrbufInit(&font->name);
+    ffStrbufInitA(&font->size, 4);
+    ffListInitA(&font->styles, sizeof(FFstrbuf), 4);
+}
+
+static void fontInitPretty(FFfont* font)
+{
+    ffStrbufAppend(&font->pretty, &font->name);
+
+    if(font->size.length == 0 && font->styles.length == 0)
+        return;
+    else if(font->pretty.length == 0)
+        ffStrbufAppendS(&font->pretty, "default");
+
+    ffStrbufAppendS(&font->pretty, " (");
+
+    if(font->size.length > 0)
+    {
+        ffStrbufAppend(&font->pretty, &font->size);
+        ffStrbufAppendS(&font->pretty, "pt");
+
+        if(font->styles.length > 0)
+            ffStrbufAppendS(&font->pretty, ", ");
+    }
+
+    for(uint32_t i = 0; i < font->styles.length; i++)
+    {
+        ffStrbufAppend(&font->pretty, ffListGet(&font->styles, i));
+
+        if(i < font->styles.length - 1)
+            ffStrbufAppendS(&font->pretty, ", ");
+    }
+
+    ffStrbufAppendC(&font->pretty, ')');
+}
+
+void ffFontInitQt(FFfont* font, const char* data)
+{
+    fontInit(font);
+
+    //See https://doc.qt.io/qt-5/qfont.html#toString
+
+    //Family
+    while(*data != ',' && *data != '\0')
+    {
+        ffStrbufAppendC(&font->name, *data);
+        ++data;
+    }
+    if(*data != '\0')
+        ++data;
+    ffStrbufTrim(&font->name, ' ');
+
+    //Size
+    while(*data != ',' && *data != '\0')
+    {
+        ffStrbufAppendC(&font->size, *data);
+        ++data;
+    }
+    if(*data != '\0')
+        ++data;
+    ffStrbufTrim(&font->size, ' ');
+
+    #define FF_FONT_QT_SKIP_VALUE \
+        while(*data != ',' && *data != '\0') \
+            ++data; \
+        if(*data != '\0') \
+             ++data;
+
+    FF_FONT_QT_SKIP_VALUE //Pixel size
+    FF_FONT_QT_SKIP_VALUE //Style hint
+    FF_FONT_QT_SKIP_VALUE //Font weight
+    FF_FONT_QT_SKIP_VALUE //Font style
+    FF_FONT_QT_SKIP_VALUE //Underline
+    FF_FONT_QT_SKIP_VALUE //Strike out
+    FF_FONT_QT_SKIP_VALUE //Fixed pitch
+    FF_FONT_QT_SKIP_VALUE //Always 0
+
+    #undef FF_FONT_QT_SKIP_VALUE
+
+    while(*data != '\0')
+    {
+        while(*data == ' ')
+            ++data;
+
+        if(*data == '\0')
+            break;
+
+        FFstrbuf* style = ffListAdd(&font->styles);
+        ffStrbufInit(style);
+        while(*data != ' ' && *data != '\0')
+        {
+            ffStrbufAppendC(style, *data);
+            ++data;
+        }
+    }
+
+    fontInitPretty(font);
+}
+
+static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer)
+{
+    while(**data == ' ' || **data == '\t' || **data == ',')
+        ++(*data);
+
+    const char* wordStart = *data;
+
+    while(**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\')
+        ++(*data);
+
+    uint32_t wordLength = (uint32_t) (*data - wordStart);
+    if(wordLength == 0)
+        return;
+
+    if(**data == '\0' || **data == '`' || **data == '\\')
+    {
+        ffStrbufAppendNS(&font->size, wordLength, wordStart);
+        if(ffStrbufEndsWithS(&font->size, "px"))
+            ffStrbufSubstrBefore(&font->size, font->size.length - 2);
+
+        double dummy;
+        if(sscanf(font->size.chars, "%lf", &dummy) == 1)
+            return;
+
+        ffStrbufClear(&font->size);
+    }
+
+    if(
+        strncasecmp(wordStart, "Ultra", 5) == 0 ||
+        strncasecmp(wordStart, "Extra", 5) == 0 ||
+        strncasecmp(wordStart, "Semi", 4) == 0 ||
+        strncasecmp(wordStart, "Demi", 4) == 0 ||
+        strncasecmp(wordStart, "Normal", wordLength) == 0 ||
+        strncasecmp(wordStart, "Roman", wordLength) == 0 ||
+        strncasecmp(wordStart, "Oblique", wordLength) == 0 ||
+        strncasecmp(wordStart, "Italic", wordLength) == 0 ||
+        strncasecmp(wordStart, "Thin", wordLength) == 0 ||
+        strncasecmp(wordStart, "Light", wordLength) == 0 ||
+        strncasecmp(wordStart, "Bold", wordLength) == 0 ||
+        strncasecmp(wordStart, "Black", wordLength) == 0 ||
+        strncasecmp(wordStart, "Condensed", wordLength) == 0 ||
+        strncasecmp(wordStart, "Expanded", wordLength) == 0
+    ) {
+        if(alternativeBuffer == NULL)
+        {
+            alternativeBuffer = ffListAdd(&font->styles);
+            ffStrbufInit(alternativeBuffer);
+        }
+
+        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
+
+        if(
+            strncasecmp(wordStart, "Ultra ", 6) == 0 ||
+            strncasecmp(wordStart, "Extra ", 6) == 0 ||
+            strncasecmp(wordStart, "Semi ", 5) == 0 ||
+            strncasecmp(wordStart, "Demi ", 5) == 0
+        ) {
+            fontPangoParseWord(data, font, alternativeBuffer);
+        }
+
+        return;
+    }
+
+    if(alternativeBuffer != NULL)
+    {
+        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
+        return;
+    }
+
+    if(font->name.length > 0)
+        ffStrbufAppendC(&font->name, ' ');
+    ffStrbufAppendNS(&font->name, wordLength, wordStart);
+}
+
+void ffFontInitPango(FFfont* font, const char* data)
+{
+    fontInit(font);
+
+    while(*data != '\0' && *data != '`' && *data != '\\')
+        fontPangoParseWord(&data, font, NULL);
+
+    fontInitPretty(font);
+}
+
+void ffFontInitCopy(FFfont* font, const char* name)
+{
+    fontInit(font);
+    ffStrbufAppendS(&font->name, name);
+    fontInitPretty(font);
+}
+
+void ffFontDestroy(FFfont* font)
+{
+    ffStrbufDestroy(&font->pretty);
+    ffStrbufDestroy(&font->name);
+    ffStrbufDestroy(&font->size);
+
+    for(uint32_t i = 0; i < font->styles.length; i++)
+        ffStrbufDestroy(ffListGet(&font->styles, i));
+    ffListDestroy(&font->styles);
+}

src/common/format.c

@@ -173,7 +173,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
                 appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
             else
             {
-                ffStrbufAppendS(buffer, "\033[0m");
+                ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
                 --numOpenColors;
             }
 
@@ -284,6 +284,5 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFst
 
     ffStrbufTrimRight(buffer, ' ');
 
-    if(numOpenColors > 0)
-        ffStrbufAppendS(buffer, "\033[0m");
+    ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
 }

src/common/init.c

@@ -58,12 +58,12 @@ static void initConfigDirs(FFstate* state)
 
     FFstrbuf* systemConfigHome = ffListAdd(&state->configDirs);
     ffStrbufInitA(systemConfigHome, 64);
-    ffStrbufAppendS(systemConfigHome, "/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, "/etc");
+    ffStrbufAppendS(systemConfig, FASTFETCH_TARGET_DIR_ROOT"/etc");
     FF_ENSURE_ONLY_ONCE_IN_LIST(systemConfig)
 
     #undef FF_ENSURE_ONLY_ONCE_IN_LIST
@@ -92,6 +92,8 @@ static void initCacheDir(FFstate* state)
 static void initState(FFstate* state)
 {
     state->logoWidth = 0;
+    state->logoHeight = 0;
+    state->keysHeight = 0;
     state->passwd = getpwuid(getuid());
     uname(&state->utsname);
     sysinfo(&state->sysinfo);
@@ -102,25 +104,29 @@ static void initState(FFstate* state)
 
 static void defaultConfig(FFinstance* instance)
 {
-    ffStrbufInit(&instance->config.color);
+    ffStrbufInit(&instance->config.logoSource);
+    instance->config.logoType = 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.mainColor);
     ffStrbufInit(&instance->config.separator);
     ffStrbufAppendS(&instance->config.separator, ": ");
 
-    instance->config.logoKeySpacing = 4;
-    instance->config.offsetx = 0;
-    instance->config.colorLogo = true;
     instance->config.showErrors = false;
     instance->config.recache = false;
     instance->config.cacheSave = true;
-    instance->config.printRemainingLogo = true;
     instance->config.allowSlowOperations = false;
     instance->config.disableLinewrap = true;
     instance->config.hideCursor = true;
-    instance->config.userLogoIsRaw = false;
-
-    for(uint8_t i = 0; i < (uint8_t) FASTFETCH_LOGO_MAX_COLORS; ++i)
-        ffStrbufInit(&instance->config.logoColors[i]);
+    instance->config.escapeBedrock = true;
+    instance->config.glType = FF_GL_TYPE_AUTO;
+    instance->config.pipe = false;
 
     ffStrbufInitA(&instance->config.osFormat, 0);
     ffStrbufInitA(&instance->config.osKey, 0);
@@ -184,6 +190,12 @@ static void defaultConfig(FFinstance* instance)
     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);
 
     ffStrbufInitA(&instance->config.libPCI, 0);
     ffStrbufInitA(&instance->config.libVulkan, 0);
@@ -196,7 +208,15 @@ static void defaultConfig(FFinstance* instance)
     ffStrbufInitA(&instance->config.libDConf, 0);
     ffStrbufInitA(&instance->config.libDBus, 0);
     ffStrbufInitA(&instance->config.libXFConf, 0);
+    ffStrbufInitA(&instance->config.libSQLite3, 0);
     ffStrbufInitA(&instance->config.librpm, 0);
+    ffStrbufInitA(&instance->config.libImageMagick, 0);
+    ffStrbufInitA(&instance->config.libZ, 0);
+    ffStrbufInitA(&instance->config.libChafa, 0);
+    ffStrbufInitA(&instance->config.libEGL, 0);
+    ffStrbufInitA(&instance->config.libGLX, 0);
+    ffStrbufInitA(&instance->config.libOSMesa, 0);
+    ffStrbufInitA(&instance->config.libOpenCL, 0);
 
     ffStrbufInitA(&instance->config.diskFolders, 0);
 
@@ -219,32 +239,31 @@ void ffInitInstance(FFinstance* instance)
 {
     initState(&instance->state);
     defaultConfig(instance);
-    ffCacheValidate(instance);
-}
-
-static void resetConsole(bool disableLinewrap, bool hideCursor)
-{
-    if(disableLinewrap)
-        fputs("\033[?7h", stdout);
-
-    if(hideCursor)
-        fputs("\033[?25h", stdout);
 }
 
 static volatile bool ffDisableLinewrap = true;
 static volatile bool ffHideCursor = true;
 
+static void resetConsole()
+{
+    if(ffDisableLinewrap)
+        fputs("\033[?7h", stdout);
+
+    if(ffHideCursor)
+        fputs("\033[?25h", stdout);
+}
+
 static void exitSignalHandler(int signal)
 {
     FF_UNUSED(signal);
-    resetConsole(ffDisableLinewrap, ffHideCursor);
+    resetConsole();
     exit(0);
 }
 
 void ffStart(FFinstance* instance)
 {
-    ffDisableLinewrap = instance->config.disableLinewrap;
-    ffHideCursor = instance->config.hideCursor;
+    ffDisableLinewrap = instance->config.disableLinewrap && !instance->config.pipe;
+    ffHideCursor = instance->config.hideCursor && !instance->config.pipe;
 
     struct sigaction action = {};
     action.sa_handler = exitSignalHandler;
@@ -253,21 +272,32 @@ void ffStart(FFinstance* instance)
     sigaction(SIGTERM, &action, NULL);
     sigaction(SIGQUIT, &action, NULL);
 
-    if(instance->config.hideCursor)
+    //We do the cache validation here, so we can skip it if --recache is given
+    if(!instance->config.recache)
+        ffCacheValidate(instance);
+
+    //reset everything to default before we start printing
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+    if(ffHideCursor)
         fputs("\033[?25l", stdout);
 
-    if(instance->config.disableLinewrap)
+    if(ffDisableLinewrap)
         fputs("\033[?7l", stdout);
+
+    ffLogoPrint(instance);
 }
 
 void ffFinish(FFinstance* instance)
 {
-    if(instance->config.printRemainingLogo)
-        ffPrintRemainingLogo(instance);
+    if(instance->config.logoPrintRemaining)
+        ffLogoPrintRemaining(instance);
 
-    resetConsole(instance->config.disableLinewrap, instance->config.hideCursor);
+    resetConsole();
 }
 
+//Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
 void ffListFeatures()
 {
     fputs(
@@ -301,11 +331,38 @@ void ffListFeatures()
         #ifdef FF_HAVE_DBUS
             "dbus\n"
         #endif
+        #ifdef FF_HAVE_IMAGEMAGICK7
+            "imagemagick7\n"
+        #endif
+        #ifdef FF_HAVE_IMAGEMAGICK6
+            "imagemagick6\n"
+        #endif
+        #ifdef FF_HAVE_CHAFA
+            "chafa\n"
+        #endif
+        #ifdef FF_HAVE_ZLIB
+            "zlib\n"
+        #endif
         #ifdef FF_HAVE_XFCONF
             "xfconf\n"
         #endif
+        #ifdef FF_HAVE_SQLITE3
+            "sqlite3\n"
+        #endif
         #ifdef FF_HAVE_RPM
-            "librpm\n"
+            "rpm\n"
+        #endif
+        #ifdef FF_HAVE_EGL
+            "egl\n"
+        #endif
+        #ifdef FF_HAVE_GLX
+            "glx\n"
+        #endif
+        #ifdef FF_HAVE_OSMESA
+            "osmesa\n"
+        #endif
+        #ifdef FF_HAVE_OPENCL
+            "opencl\n"
         #endif
         ""
     , stdout);

src/common/io.c

@@ -1,421 +1,52 @@
 #include "fastfetch.h"
 
-#include <malloc.h>
+#include <stdio.h>
 #include <unistd.h>
 #include <fcntl.h>
-
-#define FF_IO_CACHE_VALUE_EXTENSION "ffcv"
-#define FF_IO_CACHE_SPLIT_EXTENSION "ffcs"
-
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
-{
-    ffPrintLogoLine(instance);
-
-    fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-    ffPrintColor(&instance->config.color);
-
-    if(customKeyFormat == NULL || customKeyFormat->length == 0)
-    {
-        fputs(moduleName, stdout);
-
-        if(moduleIndex > 0)
-            printf(" %hhu", moduleIndex);
-    }
-    else
-    {
-        FFstrbuf key;
-        ffStrbufInit(&key);
-        ffParseFormatString(&key, customKeyFormat, NULL, 1, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
-        });
-        ffStrbufWriteTo(&key, stdout);
-        ffStrbufDestroy(&key);
-    }
-
-    fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
-    ffStrbufWriteTo(&instance->config.separator, 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)
-{
-    FFstrbuf buffer;
-    ffStrbufInitA(&buffer, 256);
-
-    ffParseFormatString(&buffer, formatString, error, numArgs, arguments);
-
-    if(buffer.length > 0)
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffStrbufPutTo(&buffer, stdout);
-    }
-
-    ffStrbufDestroy(&buffer);
-}
-
-void ffGetCacheFilePath(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
-{
-    ffStrbufAppend(buffer, &instance->state.cacheDir);
-    ffStrbufAppendS(buffer, moduleName);
-
-    if(extension != NULL)
-    {
-        ffStrbufAppendC(buffer, '.');
-        ffStrbufAppendS(buffer, extension);
-    }
-}
-
-void ffReadCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer)
-{
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffGetCacheFilePath(instance, moduleName, extension, &path);
-    ffAppendFileContent(path.chars, buffer);
-    ffStrbufDestroy(&path);
-}
-
-void ffWriteCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* content)
-{
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffGetCacheFilePath(instance, moduleName, extension, &path);
-    ffWriteFileContent(path.chars, content);
-    ffStrbufDestroy(&path);
-}
-
-static bool printCachedValue(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat)
-{
-    FFstrbuf content;
-    ffStrbufInitA(&content, 512);
-    ffReadCacheFile(instance, moduleName, FF_IO_CACHE_VALUE_EXTENSION, &content);
-
-    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
-
-    if(content.length == 0)
-        return false;
-
-    uint8_t moduleCounter = 1;
-
-    uint32_t startIndex = 0;
-    while(startIndex < content.length)
-    {
-        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
-        uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        puts(content.chars + startIndex);
-        startIndex = nullByteIndex + 1;
-        ++moduleCounter;
-    }
-
-    ffStrbufDestroy(&content);
-
-    return moduleCounter > 1;
-}
-
-static bool printCachedFormat(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
-{
-    FFstrbuf content;
-    ffStrbufInitA(&content, 512);
-    ffReadCacheFile(instance, moduleName, FF_IO_CACHE_SPLIT_EXTENSION, &content);
-
-    ffStrbufTrimRight(&content, '\0'); //Strbuf always appends a '\0' at the end. We want the last null byte to be at the position of the length
-
-    if(content.length == 0)
-        return false;
-
-    uint8_t moduleCounter = 1;
-
-    FFformatarg* arguments = calloc(numArgs, sizeof(FFformatarg));
-    uint32_t argumentCounter = 0;
-
-    uint32_t startIndex = 0;
-    while(startIndex < content.length)
-    {
-        arguments[argumentCounter].type = FF_FORMAT_ARG_TYPE_STRING;
-        arguments[argumentCounter].value = &content.chars[startIndex];
-        ++argumentCounter;
-
-        uint32_t nullByteIndex = ffStrbufNextIndexC(&content, startIndex, '\0');
-
-        if(argumentCounter == numArgs)
-        {
-            uint8_t moduleIndex = (moduleCounter == 1 && nullByteIndex == content.length) ? 0 : moduleCounter;
-            ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
-            ++moduleCounter;
-            argumentCounter = 0;
-        }
-
-        startIndex = nullByteIndex + 1;
-    }
-
-    free(arguments);
-    ffStrbufDestroy(&content);
-
-    return moduleCounter > 1;
-}
-
-bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs)
-{
-    if(instance->config.recache)
-        return false;
-
-    if(formatString == NULL || formatString->length == 0)
-        return printCachedValue(instance, moduleName, customKeyFormat);
-    else
-        return printCachedFormat(instance, moduleName, customKeyFormat, formatString, 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)
-{
-    if(formatString == NULL || formatString->length == 0)
-    {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
-        ffStrbufPutTo(value, stdout);
-    }
-    else
-    {
-        ffPrintFormatString(instance, moduleName, moduleIndex, customKeyFormat, formatString, NULL, numArgs, arguments);
-    }
-
-    if(cache->value != NULL)
-    {
-        ffStrbufWriteTo(value, cache->value);
-        fputc('\0', cache->value);
-    }
-
-    if(cache->split == NULL)
-        return;
-
-    for(uint32_t i = 0; i < numArgs; i++)
-    {
-        FFstrbuf buffer;
-        ffStrbufInitA(&buffer, 64);
-        ffFormatAppendFormatArg(&buffer, &arguments[i]);
-        ffStrbufWriteTo(&buffer, cache->split);
-        ffStrbufDestroy(&buffer);
-        fputc('\0', cache->split);
-    }
-}
-
-void ffPrintAndSaveToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments)
-{
-    FFcache cache;
-    ffCacheOpenWrite(instance, moduleName, &cache);
-    ffPrintAndAppendToCache(instance, moduleName, 0, customKeyFormat, &cache, value, formatString, numArgs, arguments);
-    ffCacheClose(&cache);
-}
-
-void ffCacheValidate(FFinstance* instance)
-{
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffGetCacheFilePath(instance, "cacheversion", "ffv", &path);
-
-    FFstrbuf content;
-    ffStrbufInit(&content);
-    ffAppendFileContent(path.chars, &content);
-
-    bool isSameVersion = ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0;
-    ffStrbufDestroy(&content);
-    if(isSameVersion)
-    {
-        ffStrbufDestroy(&path);
-        return;
-    }
-
-    instance->config.recache = true;
-
-    FFstrbuf version;
-    ffStrbufInit(&version);
-    ffStrbufAppendS(&version, FASTFETCH_PROJECT_VERSION);
-    ffWriteFileContent(path.chars, &version);
-    ffStrbufDestroy(&version);
-
-    ffStrbufDestroy(&path);
-}
-
-void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache)
-{
-    FFstrbuf cacheFileValue;
-    ffStrbufInitA(&cacheFileValue, 64);
-    ffGetCacheFilePath(instance, moduleName, FF_IO_CACHE_VALUE_EXTENSION, &cacheFileValue);
-    cache->value = fopen(cacheFileValue.chars, "w");
-    ffStrbufDestroy(&cacheFileValue);
-
-    FFstrbuf cacheFileSplit;
-    ffStrbufInitA(&cacheFileSplit, 64);
-    ffGetCacheFilePath(instance, moduleName, FF_IO_CACHE_SPLIT_EXTENSION, &cacheFileSplit);
-    cache->split = fopen(cacheFileSplit.chars, "w");
-    ffStrbufDestroy(&cacheFileSplit);
-}
-
-void ffCacheClose(FFcache* cache)
-{
-    if(cache->value != NULL)
-        fclose(cache->value);
-
-    if(cache->split != NULL)
-        fclose(cache->split);
-}
-
-bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries)
-{
-    bool* searchedValues = malloc(sizeof(bool) * numQueries);
-    bool allSet = true;
-    for(uint32_t i = 0; i < numQueries; i++)
-    {
-        if((searchedValues[i] = queries[i].buffer->length == 0))
-            allSet = false;
-    }
-
-    if(allSet)
-    {
-        free(searchedValues);
-        return true;
-    }
-
-    FILE* file = fopen(filename, "r");
-    if(file == NULL)
-        return false;
-
-    char* line = NULL;
-    size_t len = 0;
-
-    while (getline(&line, &len, file) != -1)
-    {
-        for(uint32_t i = 0; i < numQueries; i++)
-        {
-            if(!searchedValues[i])
-                continue;
-
-            uint32_t currentLength = queries[i].buffer->length;
-            queries[i].buffer->length = 0;
-            if(!ffGetPropValue(line, queries[i].start, queries[i].buffer))
-                queries[i].buffer->length = currentLength;
-        }
-    }
-
-    free(searchedValues);
-
-    if(line != NULL)
-        free(line);
-
-    fclose(file);
-
-    return true;
-}
-
-bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
-}
-
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
-{
-    FFstrbuf absolutePath;
-    ffStrbufInitA(&absolutePath, 64);
-    ffStrbufAppendS(&absolutePath, instance->state.passwd->pw_dir);
-    ffStrbufAppendC(&absolutePath, '/');
-    ffStrbufAppendS(&absolutePath, relativeFile);
-
-    bool result = ffParsePropFileValues(absolutePath.chars, numQueries, queries);
-
-    ffStrbufDestroy(&absolutePath);
-
-    return result;
-}
-
-bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
-}
-
-bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
-{
-    bool foundAFile = false;
-
-    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
-    {
-        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
-        uint32_t baseDirLength = baseDir->length;
-
-        if(*relativeFile != '/')
-            ffStrbufAppendC(baseDir, '/');
-
-        ffStrbufAppendS(baseDir, relativeFile);
-
-        if(ffParsePropFileValues(baseDir->chars, numQueries, queries))
-            foundAFile = true;
-
-        ffStrbufSubstrBefore(baseDir, baseDirLength);
-
-        bool allSet = true;
-        for(uint32_t k = 0; k < numQueries; k++)
-        {
-            if(queries[k].buffer->length == 0)
-            {
-                allSet = false;
-                break;
-            }
-        }
-
-        if(allSet)
-            break;
-    }
-
-    return foundAFile;
-}
-
-bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
-{
-    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
-}
+#include <stdarg.h>
+#include <termios.h>
+#include <poll.h>
 
 bool ffWriteFDContent(int fd, const FFstrbuf* content)
 {
     return write(fd, content->chars, content->length) != -1;
 }
 
-void ffWriteFileContent(const char* fileName, const FFstrbuf* content)
+static void createSubfolders(const char* fileName)
 {
-    int fd = open(fileName, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-    if(fd == -1)
-        return;
+    FFstrbuf path;
+    ffStrbufInit(&path);
 
-    ffWriteFDContent(fd, content);
+    while(*fileName != '\0')
+    {
+        ffStrbufAppendC(&path, *fileName);
+        if(*fileName == '/')
+            mkdir(path.chars, S_IRWXU | S_IRGRP | S_IROTH);
+        ++fileName;
+    }
+
+    ffStrbufDestroy(&path);
+}
+
+bool ffWriteFileContent(const char* fileName, const FFstrbuf* content)
+{
+    int openFlagsModes = O_WRONLY | O_CREAT | O_TRUNC;
+    int openFlagsRights = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+
+    int fd = open(fileName, openFlagsModes, openFlagsRights);
+    if(fd == -1)
+    {
+        createSubfolders(fileName);
+        fd = open(fileName, openFlagsModes, openFlagsRights);
+        if(fd == -1)
+            return false;
+    }
+
+    bool ret = ffWriteFDContent(fd, content);
 
     close(fd);
+
+    return ret;
 }
 
 void ffAppendFDContent(int fd, FFstrbuf* buffer)
@@ -430,7 +61,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);
     }
 
@@ -491,15 +122,50 @@ void ffSuppressIO(bool suppress)
     dup2(suppress ? nullFile : origErr, STDERR_FILENO);
 }
 
-void ffPrintColor(const FFstrbuf* colorValue)
-{
-    fputs("\033[", stdout);
-    ffStrbufWriteTo(colorValue, stdout);
-    fputc('m', stdout);
-}
-
 bool ffFileExists(const char* fileName, mode_t mode)
 {
     struct stat fileStat;
     return stat(fileName, &fileStat) == 0 && ((fileStat.st_mode & S_IFMT) == mode);
 }
+
+void ffGetTerminalResponse(const char* request, const char* format, ...)
+{
+    struct termios oldTerm, newTerm;
+    if(tcgetattr(STDIN_FILENO, &oldTerm) == -1)
+        return;
+
+    newTerm = oldTerm;
+    newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
+    if(tcsetattr(STDIN_FILENO, TCSANOW, &newTerm) == -1)
+        return;
+
+    fputs(request, stdout);
+    fflush(stdout);
+
+    struct pollfd pfd;
+    pfd.fd = STDIN_FILENO;
+    pfd.events = POLLIN;
+    pfd.revents = 0;
+
+    //Give the terminal 35ms to respond
+    if(poll(&pfd, 1, 35) <= 0)
+    {
+        tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+        return;
+    }
+
+    char buffer[512];
+    ssize_t readed = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
+
+    tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+
+    if(readed <= 0)
+        return;
+
+    buffer[readed] = '\0';
+
+    va_list args;
+    va_start(args, format);
+    vsscanf(buffer, format, args);
+    va_end(args);
+}

src/common/library.c

@@ -2,6 +2,33 @@
 
 #include <stdarg.h>
 
+static void* libraryLoad(const char* path, int maxVersion)
+{
+    void* result = dlopen(path, RTLD_LAZY);
+    if(result != NULL)
+        return result;
+
+    FFstrbuf pathbuf;
+    ffStrbufInitA(&pathbuf, 64);
+    ffStrbufAppendS(&pathbuf, path);
+    ffStrbufAppendC(&pathbuf, '.');
+
+    for(int i = maxVersion; i >= 0; --i)
+    {
+        uint32_t originalLength = pathbuf.length;
+        ffStrbufAppendF(&pathbuf, "%i", i);
+
+        result = dlopen(pathbuf.chars, RTLD_LAZY);
+        if(result != NULL)
+            break;
+
+        ffStrbufSubstrBefore(&pathbuf, originalLength);
+    }
+
+    ffStrbufDestroy(&pathbuf);
+    return result;
+}
+
 void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)
 {
     if(userProvidedName->length > 0)
@@ -11,12 +38,15 @@ void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)
     va_start(defaultNames, userProvidedName);
 
     void* result = NULL;
-    const char* name = va_arg(defaultNames, const char*);
 
-    while(result == NULL && name != NULL)
+    while(result == NULL)
     {
-        result = dlopen(name, RTLD_LAZY);
-        name = va_arg(defaultNames, const char*);
+        const char* path = va_arg(defaultNames, const char*);
+        if(path == NULL)
+            break;
+
+        int maxVersion = va_arg(defaultNames, int);
+        result = libraryLoad(path, maxVersion);
     }
 
     va_end(defaultNames);

src/common/parsing.c

@@ -1,8 +1,71 @@
 #include "fastfetch.h"
 
-#include <string.h>
+bool ffStrSet(const char* str)
+{
+    if(str == NULL)
+        return false;
 
-void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
+    while(*str != '\0')
+    {
+        if(*str != ' ' && *str != '\t' && *str != '\n' && *str != '\r')
+            return true;
+    }
+
+    return false;
+}
+
+void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch)
+{
+    if(major->length > 0)
+        ffStrbufAppend(buffer, major);
+    else if(minor->length > 0 || patch->length > 0)
+        ffStrbufAppendC(buffer, '1');
+
+    if(minor->length == 0 && patch->length == 0)
+        return;
+
+    ffStrbufAppendC(buffer, '.');
+
+    if(minor->length > 0)
+        ffStrbufAppend(buffer, minor);
+    else if(patch->length > 0)
+        ffStrbufAppendC(buffer, '0');
+
+    if(patch->length == 0)
+        return;
+
+    ffStrbufAppendC(buffer, '.');
+
+    ffStrbufAppend(buffer, patch);
+}
+
+int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2)
+{
+    if(version1->major != version2->major)
+        return version1->major > version2->major ? 1 : -1;
+
+    if(version1->minor != version2->minor)
+        return version1->minor > version2->minor ? 1 : -1;
+
+    if(version1->patch != version2->patch)
+        return version1->patch > version2->patch ? 1 : -1;
+
+    return 0;
+}
+
+void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty)
+{
+    if(version->major > 0 || version->minor > 0 || version->patch > 0)
+        ffStrbufAppendF(pretty, "%u", version->major);
+
+    if(version->minor > 0 || version->patch > 0)
+        ffStrbufAppendF(pretty, ".%u", version->minor);
+
+    if(version->patch > 0)
+        ffStrbufAppendF(pretty, ".%u", version->patch);
+}
+
+void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
 {
     if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)
     {
@@ -81,329 +144,3 @@ void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3
         ffStrbufAppendS(buffer, " [GTK4]");
     }
 }
-
-static void fontInit(FFfont* font)
-{
-    ffStrbufInit(&font->pretty);
-    ffStrbufInit(&font->name);
-    ffStrbufInitA(&font->size, 4);
-    ffListInitA(&font->styles, sizeof(FFstrbuf), 4);
-}
-
-static void fontInitPretty(FFfont* font)
-{
-    ffStrbufAppend(&font->pretty, &font->name);
-
-    if(font->size.length == 0 && font->styles.length == 0)
-        return;
-    else if(font->pretty.length == 0)
-        ffStrbufAppendS(&font->pretty, "default");
-
-    ffStrbufAppendS(&font->pretty, " (");
-
-    if(font->size.length > 0)
-    {
-        ffStrbufAppend(&font->pretty, &font->size);
-        ffStrbufAppendS(&font->pretty, "pt");
-
-        if(font->styles.length > 0)
-            ffStrbufAppendS(&font->pretty, ", ");
-    }
-
-    for(uint32_t i = 0; i < font->styles.length; i++)
-    {
-        ffStrbufAppend(&font->pretty, ffListGet(&font->styles, i));
-
-        if(i < font->styles.length - 1)
-            ffStrbufAppendS(&font->pretty, ", ");
-    }
-
-    ffStrbufAppendC(&font->pretty, ')');
-}
-
-void ffFontInitQt(FFfont* font, const char* data)
-{
-    fontInit(font);
-
-    //See https://doc.qt.io/qt-5/qfont.html#toString
-
-    //Family
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->name, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
-    ffStrbufTrim(&font->name, ' ');
-
-    //Size
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->size, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
-    ffStrbufTrim(&font->size, ' ');
-
-    #define FF_FONT_QT_SKIP_VALUE \
-        while(*data != ',' && *data != '\0') \
-            ++data; \
-        if(*data != '\0') \
-             ++data;
-
-    FF_FONT_QT_SKIP_VALUE //Pixel size
-    FF_FONT_QT_SKIP_VALUE //Style hint
-    FF_FONT_QT_SKIP_VALUE //Font weight
-    FF_FONT_QT_SKIP_VALUE //Font style
-    FF_FONT_QT_SKIP_VALUE //Underline
-    FF_FONT_QT_SKIP_VALUE //Strike out
-    FF_FONT_QT_SKIP_VALUE //Fixed pitch
-    FF_FONT_QT_SKIP_VALUE //Always 0
-
-    #undef FF_FONT_QT_SKIP_VALUE
-
-    while(*data != '\0')
-    {
-        while(*data == ' ')
-            ++data;
-
-        if(*data == '\0')
-            break;
-
-        FFstrbuf* style = ffListAdd(&font->styles);
-        ffStrbufInit(style);
-        while(*data != ' ' && *data != '\0')
-        {
-            ffStrbufAppendC(style, *data);
-            ++data;
-        }
-    }
-
-    fontInitPretty(font);
-}
-
-static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer)
-{
-    while(**data == ' ' || **data == '\t' || **data == ',')
-        ++(*data);
-
-    const char* wordStart = *data;
-
-    while(**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\')
-        ++(*data);
-
-    uint32_t wordLength = (uint32_t) (*data - wordStart);
-    if(wordLength == 0)
-        return;
-
-    if(**data == '\0' || **data == '`' || **data == '\\')
-    {
-        ffStrbufAppendNS(&font->size, wordLength, wordStart);
-        if(ffStrbufEndsWithS(&font->size, "px"))
-            ffStrbufSubstrBefore(&font->size, font->size.length - 2);
-
-        double dummy;
-        if(sscanf(font->size.chars, "%lf", &dummy) == 1)
-            return;
-
-        ffStrbufClear(&font->size);
-    }
-
-    if(
-        strncasecmp(wordStart, "Ultra", 5) == 0 ||
-        strncasecmp(wordStart, "Extra", 5) == 0 ||
-        strncasecmp(wordStart, "Semi", 4) == 0 ||
-        strncasecmp(wordStart, "Demi", 4) == 0 ||
-        strncasecmp(wordStart, "Normal", wordLength) == 0 ||
-        strncasecmp(wordStart, "Roman", wordLength) == 0 ||
-        strncasecmp(wordStart, "Oblique", wordLength) == 0 ||
-        strncasecmp(wordStart, "Italic", wordLength) == 0 ||
-        strncasecmp(wordStart, "Thin", wordLength) == 0 ||
-        strncasecmp(wordStart, "Light", wordLength) == 0 ||
-        strncasecmp(wordStart, "Bold", wordLength) == 0 ||
-        strncasecmp(wordStart, "Black", wordLength) == 0 ||
-        strncasecmp(wordStart, "Condensed", wordLength) == 0 ||
-        strncasecmp(wordStart, "Expanded", wordLength) == 0
-    ) {
-        if(alternativeBuffer == NULL)
-        {
-            alternativeBuffer = ffListAdd(&font->styles);
-            ffStrbufInit(alternativeBuffer);
-        }
-
-        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
-
-        if(
-            strncasecmp(wordStart, "Ultra ", 6) == 0 ||
-            strncasecmp(wordStart, "Extra ", 6) == 0 ||
-            strncasecmp(wordStart, "Semi ", 5) == 0 ||
-            strncasecmp(wordStart, "Demi ", 5) == 0
-        ) {
-            fontPangoParseWord(data, font, alternativeBuffer);
-        }
-
-        return;
-    }
-
-    if(alternativeBuffer != NULL)
-    {
-        ffStrbufAppendNSExludingC(alternativeBuffer, wordLength, wordStart, '-');
-        return;
-    }
-
-    if(font->name.length > 0)
-        ffStrbufAppendC(&font->name, ' ');
-    ffStrbufAppendNS(&font->name, wordLength, wordStart);
-}
-
-void ffFontInitPango(FFfont* font, const char* data)
-{
-    fontInit(font);
-
-    while(*data != '\0' && *data != '`' && *data != '\\')
-        fontPangoParseWord(&data, font, NULL);
-
-    fontInitPretty(font);
-}
-
-void ffFontInitCopy(FFfont* font, const char* name)
-{
-    fontInit(font);
-    ffStrbufAppendS(&font->name, name);
-    fontInitPretty(font);
-}
-
-void ffFontDestroy(FFfont* font)
-{
-    ffStrbufDestroy(&font->pretty);
-    ffStrbufDestroy(&font->name);
-    ffStrbufDestroy(&font->size);
-
-    for(uint32_t i = 0; i < font->styles.length; i++)
-        ffStrbufDestroy(ffListGet(&font->styles, i));
-    ffListDestroy(&font->styles);
-}
-
-static bool getPropValueLine(const char** line, const char* start, FFstrbuf* buffer)
-{
-    if(**line == '\0')
-        return false;
-
-    //Skip any amount of whitespace at the begin of line
-    while(**line == ' ' || **line == '\t')
-        ++(*line);
-
-    while(*start != '\0')
-    {
-        // Any amount of whitespace in the format string matches any amount of whitespace in the line, even none
-        if(*start == ' ' || *start == '\t')
-        {
-            while(*start == ' ' || *start == '\t')
-                ++start;
-
-            while(**line == ' ' || **line == '\t')
-                ++(*line);
-
-            continue;
-        }
-
-        //Line doesn't match start, skip it
-        if(**line != *start || **line == '\0')
-            return false;
-
-        //Line and start match, continue testing
-        ++(*line);
-        ++start;
-    }
-
-    char valueEnd = '\n';
-
-    //Allow faster parsing of XML
-    if(*(*line - 1) == '>')
-        valueEnd = '<';
-
-    //Skip any amount of whitespace at the begin of the value
-    while(**line == ' ' || **line == '\t')
-        ++(*line);
-
-    //Allow faster parsing of quotet values
-    if(**line == '"' || **line == '\'')
-    {
-        valueEnd = **line;
-        ++(*line);
-    }
-
-    //Copy the value to the buffer
-    while(**line != valueEnd && **line != '\n' && **line != '\0')
-    {
-        ffStrbufAppendC(buffer, **line);
-        ++(*line);
-    }
-
-    ffStrbufTrimRight(buffer, ' ');
-
-    return true;
-}
-
-bool ffGetPropValue(const char* line, const char* start, FFstrbuf* buffer)
-{
-    return getPropValueLine(&line, start, buffer);
-}
-
-bool ffGetPropValueFromLines(const char* lines, const char* start, FFstrbuf* buffer)
-{
-    while(!getPropValueLine(&lines, start, buffer))
-    {
-        while(*lines != '\0' && *lines != '\n')
-            ++lines;
-
-        if(*lines == '\0')
-            return false;
-
-        //Skip '\n'
-        ++lines;
-    }
-
-    return true;
-}
-
-void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch)
-{
-    if(major->length > 0)
-        ffStrbufAppend(buffer, major);
-    else if(minor->length > 0 || patch->length > 0)
-        ffStrbufAppendC(buffer, '1');
-
-    if(minor->length == 0 && patch->length == 0)
-        return;
-
-    ffStrbufAppendC(buffer, '.');
-
-    if(minor->length > 0)
-        ffStrbufAppend(buffer, minor);
-    else if(patch->length > 0)
-        ffStrbufAppendC(buffer, '0');
-
-    if(patch->length == 0)
-        return;
-
-    ffStrbufAppendC(buffer, '.');
-
-    ffStrbufAppend(buffer, patch);
-}
-
-bool ffStrSet(const char* str)
-{
-    if(str == NULL)
-        return false;
-
-    while(*str != '\0')
-    {
-        if(*str != ' ' && *str != '\t' && *str != '\n' && *str != '\r')
-            return true;
-    }
-
-    return false;
-}

src/common/printing.c

@@ -0,0 +1,104 @@
+#include "fastfetch.h"
+
+void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat)
+{
+    ffLogoPrintLine(instance);
+
+    if(!instance->config.pipe)
+    {
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
+        ffPrintColor(&instance->config.mainColor);
+    }
+
+    if(customKeyFormat == NULL || customKeyFormat->length == 0)
+    {
+        fputs(moduleName, stdout);
+
+        if(moduleIndex > 0)
+            printf(" %hhu", moduleIndex);
+    }
+    else
+    {
+        FFstrbuf key;
+        ffStrbufInit(&key);
+        ffParseFormatString(&key, customKeyFormat, NULL, 1, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
+        });
+        ffStrbufWriteTo(&key, stdout);
+        ffStrbufDestroy(&key);
+    }
+
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+    ffStrbufWriteTo(&instance->config.separator, stdout);
+
+    if(!instance->config.pipe)
+        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)
+{
+    FFstrbuf buffer;
+    ffStrbufInitA(&buffer, 256);
+
+    ffParseFormatString(&buffer, formatString, error, numArgs, arguments);
+
+    if(buffer.length > 0)
+    {
+        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat);
+        ffStrbufPutTo(&buffer, stdout);
+    }
+
+    ffStrbufDestroy(&buffer);
+}
+
+void ffPrintColor(const FFstrbuf* colorValue)
+{
+    //If the color is not set, this would reset in \033[m, which resets everything.
+    //So we only print it, if the main color is at least one char.
+    if(colorValue->length == 0)
+        return;
+
+    fputs("\033[", stdout);
+    ffStrbufWriteTo(colorValue, stdout);
+    fputc('m', stdout);
+}
+
+void ffPrintCharTimes(char c, uint32_t times)
+{
+    for(uint32_t i = 0; i < times; i++)
+        putchar(c);
+}

src/common/properties.c

@@ -0,0 +1,212 @@
+#include "fastfetch.h"
+
+static bool parsePropLinePointer(const char** line, const char* start, FFstrbuf* buffer)
+{
+    if(**line == '\0')
+        return false;
+
+    //Skip any amount of whitespace at the begin of line
+    while(**line == ' ' || **line == '\t')
+        ++(*line);
+
+    while(*start != '\0')
+    {
+        // Any amount of whitespace in the format string matches any amount of whitespace in the line, even none
+        if(*start == ' ' || *start == '\t')
+        {
+            while(*start == ' ' || *start == '\t')
+                ++start;
+
+            while(**line == ' ' || **line == '\t')
+                ++(*line);
+
+            continue;
+        }
+
+        //Line doesn't match start, skip it
+        if(**line != *start || **line == '\0')
+            return false;
+
+        //Line and start match, continue testing
+        ++(*line);
+        ++start;
+    }
+
+    char valueEnd = '\n';
+
+    //Allow faster parsing of XML
+    if(*(*line - 1) == '>')
+        valueEnd = '<';
+
+    //Skip any amount of whitespace at the begin of the value
+    while(**line == ' ' || **line == '\t')
+        ++(*line);
+
+    //Allow faster parsing of quotet values
+    if(**line == '"' || **line == '\'')
+    {
+        valueEnd = **line;
+        ++(*line);
+    }
+
+    //Copy the value to the buffer
+    while(**line != valueEnd && **line != '\n' && **line != '\0')
+    {
+        ffStrbufAppendC(buffer, **line);
+        ++(*line);
+    }
+
+    ffStrbufTrimRight(buffer, ' ');
+
+    return true;
+}
+
+bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer)
+{
+    return parsePropLinePointer(&line, start, buffer);
+}
+
+bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer)
+{
+    while(!parsePropLinePointer(&lines, start, buffer))
+    {
+        while(*lines != '\0' && *lines != '\n')
+            ++lines;
+
+        if(*lines == '\0')
+            return false;
+
+        //Skip '\n'
+        ++lines;
+    }
+
+    return true;
+}
+
+// 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)
+{
+    bool valueStorage[4];
+    bool* unsetValues;
+
+    if(numQueries > sizeof(valueStorage) / sizeof(valueStorage[0]))
+        unsetValues = malloc(sizeof(bool) * numQueries);
+    else
+        unsetValues = valueStorage;
+
+    bool allSet = true;
+    for(uint32_t i = 0; i < numQueries; i++)
+    {
+        if((unsetValues[i] = queries[i].buffer->length == 0))
+            allSet = false;
+    }
+
+    FILE* file = fopen(filename, "r");
+    if(file == NULL)
+        return false;
+
+    if(allSet)
+    {
+        fclose(file);
+        if(unsetValues != valueStorage)
+            free(unsetValues);
+        return true;
+    }
+
+    char* line = NULL;
+    size_t len = 0;
+
+    while (getline(&line, &len, file) != -1)
+    {
+        for(uint32_t i = 0; i < numQueries; i++)
+        {
+            if(!unsetValues[i])
+                continue;
+
+            uint32_t currentLength = queries[i].buffer->length;
+            queries[i].buffer->length = 0;
+            if(!ffParsePropLine(line, queries[i].start, queries[i].buffer))
+                queries[i].buffer->length = currentLength;
+        }
+    }
+
+    if(line != NULL)
+        free(line);
+
+    fclose(file);
+
+    if(unsetValues != valueStorage)
+        free(unsetValues);
+
+    return true;
+}
+
+bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
+}
+
+bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+{
+    FFstrbuf absolutePath;
+    ffStrbufInitA(&absolutePath, 64);
+    ffStrbufAppendS(&absolutePath, instance->state.passwd->pw_dir);
+    ffStrbufAppendC(&absolutePath, '/');
+    ffStrbufAppendS(&absolutePath, relativeFile);
+
+    bool result = ffParsePropFileValues(absolutePath.chars, numQueries, queries);
+
+    ffStrbufDestroy(&absolutePath);
+
+    return result;
+}
+
+bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}
+
+bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+{
+    bool foundAFile = false;
+
+    for(uint32_t i = 0; i < instance->state.configDirs.length; i++)
+    {
+        FFstrbuf* baseDir = (FFstrbuf*) ffListGet(&instance->state.configDirs, i);
+        uint32_t baseDirLength = baseDir->length;
+
+        if(*relativeFile != '/')
+            ffStrbufAppendC(baseDir, '/');
+
+        ffStrbufAppendS(baseDir, relativeFile);
+
+        if(ffParsePropFileValues(baseDir->chars, numQueries, queries))
+            foundAFile = true;
+
+        ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+        bool allSet = true;
+        for(uint32_t k = 0; k < numQueries; k++)
+        {
+            if(queries[k].buffer->length == 0)
+            {
+                allSet = false;
+                break;
+            }
+        }
+
+        if(allSet)
+            break;
+    }
+
+    return foundAFile;
+}
+
+bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+}

src/common/settings.c

@@ -1,6 +1,7 @@
 #include "fastfetch.h"
 
 #include <pthread.h>
+#include <string.h>
 
 #define FF_LIBRARY_DATA_LOAD_INIT(dataObject, userLibraryName, ...) \
     static dataObject data; \
@@ -80,7 +81,7 @@ typedef struct GSettingsData
 
 static const GSettingsData* getGSettingsData(FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0.so", "libgio-2.0.so.0");
+    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0.so", 1);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_lookup)
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_has_key)
@@ -152,7 +153,7 @@ typedef struct DConfData
 
 static const DConfData* getDConfData(FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf.so", "libdconf.so.1");
+    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf.so", 2);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_read_full)
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_new)
@@ -222,7 +223,7 @@ typedef struct XFConfData
 
 static const XFConfData* getXFConfData(FFinstance* instance)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0.so", "libxfconf-0.so.3");
+    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0.so", 4);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get)
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_has_property)
@@ -267,6 +268,74 @@ FFvariant ffSettingsGetXFConf(FFinstance* instance, const char* channelName, con
 }
 #endif //FF_HAVE_XFCONF
 
+#ifdef FF_HAVE_SQLITE3
+#include <sqlite3.h>
+
+typedef struct SQLiteData
+{
+    FF_LIBRARY_SYMBOL(sqlite3_open_v2)
+    FF_LIBRARY_SYMBOL(sqlite3_prepare_v2)
+    FF_LIBRARY_SYMBOL(sqlite3_step)
+    FF_LIBRARY_SYMBOL(sqlite3_data_count)
+    FF_LIBRARY_SYMBOL(sqlite3_column_int)
+    FF_LIBRARY_SYMBOL(sqlite3_finalize)
+    FF_LIBRARY_SYMBOL(sqlite3_close)
+} SQLiteData;
+
+static const SQLiteData* getSQLiteData(const FFinstance* instance)
+{
+    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance->config.libSQLite3, "libsqlite3.so", 1);
+
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_open_v2)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_prepare_v2)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_step)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_data_count)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_column_int)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_finalize)
+    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_close)
+
+    FF_LIBRARY_DATA_LOAD_RETURN
+}
+
+int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+{
+    const SQLiteData* data = getSQLiteData(instance);
+    if(data == NULL)
+        return 0;
+
+    sqlite3* db;
+    if(data->ffsqlite3_open_v2(dbPath, &db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
+        return 0;
+
+    sqlite3_stmt* stmt;
+    if(data->ffsqlite3_prepare_v2(db, query, (int) strlen(query), &stmt, NULL) != SQLITE_OK)
+    {
+        data->ffsqlite3_close(db);
+        return 0;
+    }
+
+    if(data->ffsqlite3_step(stmt) != SQLITE_ROW || data->ffsqlite3_data_count(stmt) < 1)
+    {
+        data->ffsqlite3_finalize(stmt);
+        data->ffsqlite3_close(db);
+        return 0;
+    }
+
+    int result = data->ffsqlite3_column_int(stmt, 0);
+
+    data->ffsqlite3_finalize(stmt);
+    data->ffsqlite3_close(db);
+
+    return result;
+}
+#else //FF_HAVE_SQLITE3
+int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+{
+    FF_UNUSED(instance, dbPath, query)
+    return 0;
+}
+#endif //FF_HAVE_SQLITE3
+
 #ifdef __ANDROID__
 #include <sys/system_properties.h>
 bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result) {

src/data/config.txt

@@ -27,38 +27,17 @@
 # Get the default structure with "fastfetch --print-structure".
 #--structure $"FASTFETCH_DATATEXT_STRUCTURE$"
 
-# Logo option:
-# Sets the logo to use.
-# List available logos with "fastfetch --list-logos".
-# Print available logos with "fastfetch --print-logos".
-# Must be the name of an available logo or a path to a text file containing a custom logo.
-# Default is the current distribution.
-#--logo arch
+# Multithreading option:
+# Sets if fastfetch should use multiple threads to detect the values.
+# Must be true or false.
+# Default is true.
+#--multithreading true
 
-# Color 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.
-# Use "fastfetch --help color" to learn more and see examples.
-#--color magenta
-
-# Spacing option:
-# Sets the amount of whitespace between the logo and keys.
-# Must be an positive integer.
-# Default is 4.
-#--spacing 4
-
-# Separator option:
-# Sets the string placed between a key and its value.
-# Can be any string.
-# Default is ": ".
-#--separator ": "
-
-# Offset option:
-# Sets the amount of whitespace before the logo. Can be negative to cut the logo.
-# Must be an integer.
-# Default is 0.
-#--offsetx 0
+# Slow operations option:
+# Sets if fastfetch is allowed to use known slow operations to detect more / better values.
+# Must be true or false.
+# Default is false.
+#--allow-slow-operations false
 
 # Linewrap option:
 # Sets if fastfetch should disable linewrap during the run.
@@ -72,35 +51,31 @@
 # Default is true.
 #--hide-cursor true
 
-# Remaing logo option:
-# Sets if the remaining logo should be printed, if it is higher than the information printed.
-# Must be true or false.
-# Default is true.
-#--print-remaining-logo true
+# Logo option:
+# Sets the logo to use.
+# List available logos with "fastfetch --list-logos".
+# Print available logos with "fastfetch --print-logos".
+# Must be the name of an available logo or a path to a text file containing a custom logo.
+# Default is the current distribution.
+#--logo arch
 
-# Multithreading option:
-# Sets if fastfetch should use multiple threads to detect the values.
-# Must be true or false.
-# Default is true.
-#--multithreading true
+# Logo type option:
+# Sets the logo type to use.
+# Must be auto, builtin, file, raw, sixel, kitty or chafa.
+# Default is auto.
+#--logo-type auto
 
-# Slow operations option:
-# Sets if fastfetch is allowed to use known slow operations to detect more / better values.
-# Must be true or false.
-# Default is false.
-#--allow-slow-operations false
+# Logo width option:
+# Sets the width of the logo (in characters) if the logo is an image.
+# Must be a positive integer.
+# Default is 65.
+#--logo-width 65
 
-# Color logo option:
-# Sets if the logo should be colored.
-# Must be true or false.
-# Default is true.
-#--color-logo true
-
-# Separator string option:
-# Sets the string printed by the "separator" module (usually between title and rest of output)
-# Must be any string. It is repated / cut to fit perfectly.
-# Default is "-"
-#--separator-string -
+# Logo height option:
+# Sets the height of the logo (in characters) if the logo is an image.
+# Must be a positive integer.
+# Default is 0 (keeps aspect ration).
+#--logo-height 0
 
 # Logo color options:
 # Overwrite a color in the logo. Also works for user provided logos.
@@ -109,16 +84,53 @@
 # Default is the one specified by the logo.
 # Use "fastfetch --help color" to learn more and see examples.
 # Valid index range is [1-9].
-#--color-1 red
-#--color-2 32
+#--logo-color-1 red
+#--logo-color-2 32
 # [...]
-#--color-9 yellow
+#--logo-color-9 yellow
 
-# User logo raw option:
-# Sets if color replacements should be performed on the user provided logo.
+# Logo padding option:
+# Adds a padding to the left and the right side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding 0
+
+# Logo padding left option:
+# Adds a padding to the left side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding-left 0
+
+# Logo padding right option:
+# Adds a padding to the right side of the logo.
+# Must be a positive integer.
+# Default is 0.
+#--logo-padding-right 0
+
+# Logo print remaining option:
+# Sets if the remaining logo should be printed, it is has more lines than modules to show.
 # Must be true or false.
 # Default is true.
-#--color-raw true
+#--logo-print-remaining true
+
+# Color 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.
+# Use "fastfetch --help color" to learn more and see examples.
+#--color magenta
+
+# Separator option:
+# Sets the string placed between a key and its value.
+# Can be any string.
+# Default is ": ".
+#--separator ": "
+
+# Separator string option:
+# Sets the string printed by the "separator" module (usually between title and rest of output)
+# Must be any string. It is repated / cut to fit perfectly.
+# Default is "-"
+#--separator-string -
 
 # Public IP timeout option:
 # Sets the time to wait for the public ip server to respond.
@@ -139,6 +151,18 @@
 # Default is the first match starting with org.mpris.MediaPlayer2.
 #--player-name spotify
 
+# Escape bedrock option
+# Sets if fastfetch should escape the bedrock jail, if it detectes that it is running in one
+# Must be true or false.
+# Default is true.
+#--escape-bedrock true
+
+# GL option
+# Sets with opengl context creation library to use
+# Must be either auto, egl, glx or osmesa
+# Default is auto.
+#--gl auto
+
 # Key options:
 # Sets the displayed key of a module
 # Can be any string. Some of theme take an argument like a format string. See "fastfetch --help format" for help.
@@ -171,6 +195,9 @@
 #--player-key Media Player
 #--song-key Song
 #--datetime-key Date Time
+#--vulkan-key Vulkan
+#--opengl-key OpenGL
+#--opencl-key OpenCL
 
 # Format options:
 # Sets the format string for module values.
@@ -206,6 +233,9 @@
 #--player-format
 #--song-format
 #--datetime-format
+#--vulkan-format
+#--opengl-format
+#--opencl-format
 
 # Library options:
 # Sets an user specific path to a library to load.
@@ -221,4 +251,12 @@
 #--lib-DConf /usr/lib/libdconf.so
 #--lib-DBus /usr/lib/libdbus-1.so
 #--lib-XFConf /usr/lib/libxfconf-0.so
+#--lib-sqlite3 /usr/lib/libsqlite3.so
 #--lib-rpm /usr/lib/librpm.so
+#--lib-imagemagick /usr/lib/libMagickCore-7.Q16HDRI.so
+#--lib-z /usr/lib/libz.so
+#--lib-chafa /usr/lib/libchafa.so
+#--lib-egl /usr/lib/libEGL.so
+#--lib-glx /usr/lib/libGLX.so
+#--lib-osmesa /usr/lib/libOSMesa.so
+#--lib-opencl /usr/lib/libOpenCL.so

src/data/help.txt

@@ -1,39 +1,50 @@
 Usage: fastfetch <options>
 
 Informative options:
-    -h,           --help:            shows this message and exits
-    -h <command>, --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:      prints the default config and exits
+    --print-structure:   prints the default stucture and exits
 
 General options:
-                 --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.
-                 --set <key=value>:                hard set the value of a key
-    -c <color>,  --color <color>:                  sets the color of the keys. Must be a linux console color code or the name of a color (+)
-                 --color-[1-9] <color>:            overwrites a color of the logo. Must be a linux console color code or the name of a color
-                 --spacing <width>:                sets the distance between logo and text
-    -s <str>,    --separator <str>:                sets the separator between key and value. Default is a colon with a space
-    -x <offset>, --offsetx <offset>:               sets the x offset. Can be negative to cut the logo, but no more than logo width.
-                 --show-errors <?value>:           print occuring errors
-    -r <?value>  --recache <?value>:               generate new cached values
-                 --nocache <?value>:               don't use cached values, but also don't overwrite existing ones
-                 --print-remaining-logo <?value>:  print the remaining logo, if it is higher than the number of lines shown
-                 --multithreading <?value>:        use multiple threads to detect values
-                 --load-config <file>:             load a config file (+)
-                 --allow-slow-operations <?value>: Allow operations that are usually very slow for more detailed output
-                 --disable-linewrap <?value>:      Disable linewrap during the run
-                 --hide-cursor <?value>:           Hide the cursor during the run
-                 --logo-raw <?value>:              Print a custom logo as is, without any color replacements
+    -r,--recache <?value>:            generate new cached values
+    --nocache <?value>:               don't use cached values, but also don't overwrite existing ones
+    --load-config <file>:             load a config file or a preset (+)
+    --multithreading <?value>:        use multiple threads to detect values
+    --allow-slow-operations <?value>: allow operations that are usually very slow for more detailed output
+    --escape-bedrock <?value>:        on bedrock linux, sets if it should escape the bedrock jail or not
+    --pipe <?value>:                  disable logo and all escape sequences
 
 Logo options:
-    -l <name>, --logo <name>:         sets the shown logo. Also changes the main color accordingly. This will also load file contents as logo if the given argument is a valid path.
-               --color-logo <?value>: if set to false, the logo will be black / white
+    -l,--logo <logo>:                set the logo to use. The type is specified by --logo-type. If default: the name of a builtin logo or a path to a file
+    --logo-type <type>:              set the type of the logo given. Must be auto, builtin, file, raw, sixel, kitty or chafa.
+    --logo-width <width>:            set the width of the logo (in characters), if it is an image
+    --logo-height <height>:          set the height of the logo (in characters), if it is an image
+    --logo-color-[1-9] <color>:      overwrite a color in the logo
+    --logo-padding <padding>:        set the padding on the left and the right of the logo
+    --logo-padding-left <padding>:   set the padding on the left of the logo
+    --logo-padding-right <padding>:  set the padding on the right of the logo
+    --logo-print-remaining <?value>: weather to print the remaining logo, if it has more lines than modules to display
+    --sixel <file>:                  short for --logo-type sixel --logo <file>
+    --kitty <file>:                  short for --logo-type kitty --logo <file>
+    --chafa <file>:                  short for --logo-type chafa --logo <file>
+    --file <file>:                   short for --logo-type file --logo <file>
+    --raw <file>:                    short for --logo-type raw --logo <file>
+
+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 (+)
+    --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
+    --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
 
 Format options: Provide the format string for custom output. Use fastfetch --help *-format for specific help.
     --os-format <format>
@@ -67,6 +78,9 @@ Format options: Provide the format string for custom output. Use fastfetch --hel
     --datetime-format <format>
     --time-format <format>
     --date-format <format>
+    --vulkan-format <format>
+    --opengl-format <format>
+    --opencl-format <format>
 
 Key options: Provide a custom key for an output
     --os-key <key>
@@ -100,6 +114,9 @@ Key options: Provide a custom key for an output
     --datetime-key <key>
     --time-key <key>
     --date-key <key>
+    --vulkan-key <key>
+    --opengl-key <key>
+    --opencl-key <key>
 
 Library options: Set the path of a library to load
     --lib-PCI <path>
@@ -113,7 +130,15 @@ Library options: Set the path of a library to load
     --lib-DConf <path>
     --lib-DBus <path>
     --lib-XFConf <path>
-    --lib-RPM <path>
+    --lib-sqlite3 <path>
+    --lib-rpm <path>
+    --lib-imagemagick <path>
+    --lib-z <path>
+    --lib-chafa <path>
+    --lib-egl <path>
+    --lib-glx <path>
+    --lib-osmesa <path>
+    --lib-opencl <path>
 
 Module specific options:
     --separator-string <str>:     Set the string printed by the separator module
@@ -125,6 +150,7 @@ Module specific options:
     --localip-show-loop <?value>: Show loop back addresses (127.0.0.1) in local ip module. Default is false
     --public-ip-timeout:          Time in milliseconds to wait for the public ip server to respond. Default is disabled (0)
     --player-name:                The name of the player to use
+    --gl <value>:                 Sets the opengl context creation library to use. Must be auto, egl, glx or osmesa. Default is auto
 
 Parsing is not case sensitive. E.g. "--lib-PCI" is equal to "--Lib-Pci"
 If a value starts with a ?, it is optional. "true" will be used if not set.

src/data/modules.txt

@@ -17,6 +17,8 @@ Locale
 LocalIP
 Memory
 OS
+OpenCL
+OpenGL
 Packages
 Player
 Processes
@@ -31,5 +33,6 @@ Theme
 Time
 Title
 Uptime
+Vulkan
 WM
 WMTheme

src/detection/displayserver/wayland.c

@@ -78,7 +78,7 @@ void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* resul
     if(getenv("XDG_RUNTIME_DIR") == NULL)
         return;
 
-    FF_LIBRARY_LOAD(wayland, instance->config.libWayland, , "libwayland-client.so", "libwayland-client.so.0")
+    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,)

src/detection/displayserver/wmde.c

@@ -98,7 +98,15 @@ static void getKDE(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "plasmashell");
     ffStrbufSetS(&result->dePrettyName, "KDE Plasma");
-    ffParsePropFile("/usr/share/xsessions/plasma.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/xsessions/plasma.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/xsessions/plasma5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/wayland-sessions/plasmawayland.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+    if(result->deVersion.length == 0)
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/wayland-sessions/plasmawayland5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+
     applyBetterWM(result, getenv("KDEWM"));
 }
 
@@ -106,14 +114,14 @@ static void getGnome(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "gnome-shell");
     ffStrbufSetS(&result->dePrettyName, "GNOME");
-    ffParsePropFile("/usr/share/gnome-shell/org.gnome.Extensions", "version :", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/gnome-shell/org.gnome.Extensions", "version :", &result->deVersion);
 }
 
 static void getCinnamon(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "cinnamon");
     ffStrbufSetS(&result->dePrettyName, "Cinnamon");
-    ffParsePropFile("/usr/share/applications/cinnamon.desktop", "X-GNOME-Bugzilla-Version =", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/applications/cinnamon.desktop", "X-GNOME-Bugzilla-Version =", &result->deVersion);
 }
 
 static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
@@ -130,7 +138,7 @@ static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
     FFstrbuf micro;
     ffStrbufInit(&micro);
 
-    ffParsePropFileValues("/usr/share/mate-about/mate-version.xml", 3, (FFpropquery[]) {
+    ffParsePropFileValues(FASTFETCH_TARGET_DIR_USR"/share/mate-about/mate-version.xml", 3, (FFpropquery[]) {
         {"<platform>", &major},
         {"<minor>", &minor},
         {"<micro>", &micro}
@@ -159,7 +167,7 @@ static void getXFCE4(const FFinstance* instance, FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "xfce4-session");
     ffStrbufSetS(&result->dePrettyName, "Xfce4");
-    ffParsePropFile("/usr/share/gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version", &result->deVersion);
 
     if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
     {
@@ -180,12 +188,12 @@ static void getLXQt(const FFinstance* instance, FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "lxqt-session");
     ffStrbufSetS(&result->dePrettyName, "LXQt");
-    ffParsePropFile("/usr/lib/pkgconfig/lxqt.pc", "Version:", &result->deVersion);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/lib/pkgconfig/lxqt.pc", "Version:", &result->deVersion);
 
     if(result->deVersion.length == 0)
-        ffParsePropFile("/usr/share/cmake/lxqt/lxqt-config.cmake", "set ( LXQT_VERSION", &result->deVersion);
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/cmake/lxqt/lxqt-config.cmake", "set ( LXQT_VERSION", &result->deVersion);
     if(result->deVersion.length == 0)
-        ffParsePropFile("/usr/share/cmake/lxqt/lxqt-config-version.cmake", "set ( PACKAGE_VERSION", &result->deVersion);
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/cmake/lxqt/lxqt-config-version.cmake", "set ( PACKAGE_VERSION", &result->deVersion);
 
     if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
     {
@@ -197,7 +205,7 @@ static void getLXQt(const FFinstance* instance, FFDisplayServerResult* result)
         });
 
         result->deVersion.length = 0; //don't set '\0' byte
-        ffGetPropValueFromLines(result->deVersion.chars , "liblxqt", &result->deVersion);
+        ffParsePropLines(result->deVersion.chars , "liblxqt", &result->deVersion);
     }
 
     FFstrbuf wmProcessNameBuffer;

src/detection/displayserver/xcb.c

@@ -89,7 +89,7 @@ static void xcbDetectWMfromEWMH(XcbPropertyData* data, xcb_connection_t* connect
 
 void ffdsConnectXcb(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcb, instance->config.libXcb, , "libxcb.so", "libxcb.so.1")
+    FF_LIBRARY_LOAD(xcb, instance->config.libXcb, , "libxcb.so", 2)
     FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_connect,)
     FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_get_setup,)
     FF_LIBRARY_LOAD_SYMBOL(xcb, xcb_setup_roots_iterator,)
@@ -213,15 +213,15 @@ static bool xcbRandrHandleCrtc(XcbRandrData* data, xcb_randr_crtc_t crtc)
         return false;
 
     bool res = xcbRandrHandleMode(data, crtcInfoReply->mode);
-
-    free(crtcInfoReply);
-
-    return res ? true : ffdsAppendResolution(
+    res = res ? true : ffdsAppendResolution(
         data->result,
         (uint32_t) crtcInfoReply->width,
         (uint32_t) crtcInfoReply->height,
         data->defaultRefreshRate
     );
+
+    free(crtcInfoReply);
+    return res;
 }
 
 static bool xcbRandrHandleOutput(XcbRandrData* data, xcb_randr_output_t output)
@@ -324,7 +324,7 @@ static void xcbRandrHandleScreen(XcbRandrData* data, xcb_screen_t* screen)
 
 void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcbRandr, instance->config.libXcbRandr, , "libxcb-randr.so", "libxcb-randr.so.0")
+    FF_LIBRARY_LOAD(xcbRandr, instance->config.libXcbRandr, , "libxcb-randr.so", 1)
     FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_connect,)
     FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_get_setup,)
     FF_LIBRARY_LOAD_SYMBOL(xcbRandr, xcb_setup_roots_iterator,)

src/detection/displayserver/xlib.c

@@ -53,7 +53,7 @@ static void x11DetectWMFromEWMH(X11PropertyData* data, Display* display, FFDispl
 
 void ffdsConnectXlib(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(x11, instance->config.libX11, , "libX11.so", "libX11.so.6", "libX11-xcb.so", "libX11-xcb.so.1")
+    FF_LIBRARY_LOAD(x11, instance->config.libX11, , "libX11.so", 7, "libX11-xcb.so", 2)
     FF_LIBRARY_LOAD_SYMBOL(x11, XOpenDisplay,)
     FF_LIBRARY_LOAD_SYMBOL(x11, XCloseDisplay,)
 
@@ -161,15 +161,15 @@ static bool xrandrHandleCrtc(XrandrData* data, RRCrtc crtc)
         return false;
 
     bool res = xrandrHandleMode(data, crtcInfo->mode);
-
-    data->ffXRRFreeCrtcInfo(crtcInfo);
-
-    return res ? true : ffdsAppendResolution(
+    res = res ? true : ffdsAppendResolution(
         data->result,
         (uint32_t) crtcInfo->width,
         (uint32_t) crtcInfo->height,
         data->defaultRefreshRate
     );
+
+    data->ffXRRFreeCrtcInfo(crtcInfo);
+    return res;
 }
 
 static bool xrandrHandleOutput(XrandrData* data, RROutput output)
@@ -257,7 +257,7 @@ static void xrandrHandleScreen(XrandrData* data, Screen* screen)
 
 void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xrandr, instance->config.libXrandr, , "libXrandr.so", "libXrandr.so.2")
+    FF_LIBRARY_LOAD(xrandr, instance->config.libXrandr, , "libXrandr.so", 3)
 
     FF_LIBRARY_LOAD_SYMBOL(xrandr, XOpenDisplay,)
     FF_LIBRARY_LOAD_SYMBOL(xrandr, XCloseDisplay,)

src/detection/gtk.c

@@ -69,23 +69,14 @@ 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;
     }
-
-    //Fallback + Gnome impl
-
-    if(themeName == NULL)
+    else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, "Gnome") == 0)
+    {
         themeName = ffSettingsGet(instance, "/org/gnome/desktop/interface/gtk-theme", "org.gnome.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(iconsName == NULL)
         iconsName = ffSettingsGet(instance, "/org/gnome/desktop/interface/icon-theme", "org.gnome.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(fontName == NULL)
         fontName = ffSettingsGet(instance, "/org/gnome/desktop/interface/font-name", "org.gnome.desktop.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(cursorTheme == NULL)
         cursorTheme = ffSettingsGet(instance, "/org/gnome/desktop/interface/cursor-theme", "org.gnome.desktop.interface", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
-
-    if(cursorSize <= 0)
         cursorSize = ffSettingsGet(instance, "/org/gnome/desktop/interface/cursor-size", "org.gnome.desktop.interface", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
+    }
 
     pthread_mutex_unlock(&mutex);
     applyGTKDConfSettings(result, themeName, iconsName, fontName, cursorTheme, cursorSize);
@@ -146,41 +137,8 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
     ffStrbufSubstrBefore(configDir, configDirLength);
 }
 
-static void detectGTK(FFinstance* instance, const char* version, const char* envVariable, FFGTKResult* result)
+static void detectGTK(FFinstance* instance, const char* version, FFGTKResult* result)
 {
-    FFstrbuf buffer;
-    ffStrbufInitA(&buffer, 128);
-
-    // From ENV: GTK*_RC_FILES
-
-    ffStrbufSetS(&buffer, getenv(envVariable));
-    uint32_t startIndex = 0;
-    while (startIndex < buffer.length)
-    {
-        uint32_t colonIndex = ffStrbufNextIndexC(&buffer, startIndex, ':');
-        buffer.chars[colonIndex] = '\0';
-
-        detectGTKFromConfigFile(buffer.chars + startIndex, result);
-        if(allPropertiesSet(result))
-        {
-            ffStrbufDestroy(&buffer);
-            return;
-        }
-
-        startIndex = colonIndex + 1;
-    }
-
-    //From DConf / GSettings
-
-    detectGTKFromDConf(instance, result);
-    if(allPropertiesSet(result))
-    {
-        ffStrbufDestroy(&buffer);
-        return;
-    }
-
-    //From config dirs
-
     //We need to do this because we use multiple threads on configDirs
     FFstrbuf baseDirCopy;
     ffStrbufInitA(&baseDirCopy, 64);
@@ -191,14 +149,20 @@ static void detectGTK(FFinstance* instance, const char* version, const char* env
         ffStrbufSet(&baseDirCopy, baseDir);
         detectGTKFromConfigDir(&baseDirCopy, version, result);
         if(allPropertiesSet(result))
-            break;
+        {
+            ffStrbufDestroy(&baseDirCopy);
+            return;
+        }
     }
 
     ffStrbufDestroy(&baseDirCopy);
-    ffStrbufDestroy(&buffer);
+
+    //Mate, Cinnamon and Gnome use dconf to save theme config
+    //On other DEs, this will do nothing
+    detectGTKFromDConf(instance, result);
 }
 
-#define FF_CALCULATE_GTK_IMPL(version) \
+#define FF_DETECT_GTK_IMPL(version) \
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \
     static FFGTKResult result; \
     static bool init = false; \
@@ -213,23 +177,23 @@ static void detectGTK(FFinstance* instance, const char* version, const char* env
     ffStrbufInit(&result.font); \
     ffStrbufInit(&result.cursor); \
     ffStrbufInit(&result.cursorSize); \
-    detectGTK(instance, #version, "GTK"#version"_RC_FILES", &result); \
+    detectGTK(instance, #version, &result); \
     pthread_mutex_unlock(&mutex); \
     return &result;
 
 const FFGTKResult* ffDetectGTK2(FFinstance* instance)
 {
-    FF_CALCULATE_GTK_IMPL(2)
+    FF_DETECT_GTK_IMPL(2)
 }
 
 const FFGTKResult* ffDetectGTK3(FFinstance* instance)
 {
-    FF_CALCULATE_GTK_IMPL(3)
+    FF_DETECT_GTK_IMPL(3)
 }
 
 const FFGTKResult* ffDetectGTK4(FFinstance* instance)
 {
-    FF_CALCULATE_GTK_IMPL(4)
+    FF_DETECT_GTK_IMPL(4)
 }
 
 #undef FF_CALCULATE_GTK_IMPL

src/detection/media.c

@@ -1,10 +1,10 @@
 #include "fastfetch.h"
 
-#include <ctype.h>
 #include <string.h>
 #include <pthread.h>
 
 #define FF_DBUS_MPRIS_PREFIX "org.mpris.MediaPlayer2."
+#define FF_DBUS_TIMEOUT_MILLISECONDS 35
 
 #ifdef FF_HAVE_DBUS
 #include <dbus/dbus.h>
@@ -69,8 +69,11 @@ static bool getValue(DBusMessageIter* iter, FFstrbuf* result, DBusData* data)
 
     while(true)
     {
-        if((foundAValue = getValue(&subIter, result, data)))
+        if(getValue(&subIter, result, data))
+        {
+            foundAValue = true;
             ffStrbufAppendS(result, ", ");
+        }
 
         FF_DBUS_ITER_CONTINUE(subIter);
     }
@@ -84,7 +87,7 @@ static bool getValue(DBusMessageIter* iter, FFstrbuf* result, DBusData* data)
 static DBusMessage* getReply(DBusMessage* request, DBusData* data)
 {
     DBusPendingCall* pendingCall = NULL;
-    dbus_bool_t succesfull = data->ffdbus_connection_send_with_reply(data->connection, request, &pendingCall, DBUS_TIMEOUT_USE_DEFAULT);
+    dbus_bool_t succesfull = data->ffdbus_connection_send_with_reply(data->connection, request, &pendingCall, FF_DBUS_TIMEOUT_MILLISECONDS);
     data->ffdbus_message_unref(request);
     if(!succesfull || pendingCall == NULL)
         return NULL;
@@ -209,6 +212,7 @@ static bool getBusProperties(const char* busName, FFMediaResult* result, DBusDat
     {
         ffStrbufClear(&result->artist);
         ffStrbufClear(&result->album);
+        ffStrbufClear(&result->url);
         return false;
     }
 
@@ -285,7 +289,7 @@ static void getMedia(FFinstance* instance, FFMediaResult* result)
 {
     DBusData data;
 
-    FF_LIBRARY_LOAD(dbus, instance->config.libDBus, , "libdbus-1.so", "libdbus-1.so.3");
+    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,)
@@ -316,28 +320,6 @@ static void getMedia(FFinstance* instance, FFMediaResult* result)
         getBestBus(result, &data);
 
     dlclose(dbus);
-
-    //If we are on a website, prepend the website name
-    if(ffStrbufStartsWithS(&result->url, "https://www."))
-        ffStrbufAppendS(&result->playerPretty, result->url.chars + 12);
-    else if(ffStrbufStartsWithS(&result->url, "http://www."))
-        ffStrbufAppendS(&result->playerPretty, result->url.chars + 11);
-    else if(ffStrbufStartsWithS(&result->url, "https://"))
-        ffStrbufAppendS(&result->playerPretty, result->url.chars + 8);
-    else if(ffStrbufStartsWithS(&result->url, "http://"))
-        ffStrbufAppendS(&result->playerPretty, result->url.chars + 7);
-
-    //If we found a website name, make it more pretty
-    if(result->playerPretty.length > 0)
-    {
-        ffStrbufSubstrBeforeFirstC(&result->playerPretty, '/'); //Remove the path
-        ffStrbufSubstrBeforeLastC(&result->playerPretty, '.'); //Remove the TLD
-    }
-
-    //Check again for length, as we may have removed everything.
-    //If we don't have subdomains, it is usually more pretty to capitalize the first letter.
-    if(result->playerPretty.length > 0 && ffStrbufFirstIndexC(&result->playerPretty, '.') == result->playerPretty.length)
-        result->playerPretty.chars[0] = (char) toupper(result->playerPretty.chars[0]);
 }
 
 #endif
@@ -358,7 +340,6 @@ const FFMediaResult* ffDetectMedia(FFinstance* instance)
 
     ffStrbufInit(&result.busNameShort);
     ffStrbufInit(&result.player);
-    ffStrbufInit(&result.playerPretty);
     ffStrbufInit(&result.song);
     ffStrbufInit(&result.artist);
     ffStrbufInit(&result.album);
@@ -381,16 +362,6 @@ const FFMediaResult* ffDetectMedia(FFinstance* instance)
     if(result.player.length == 0)
         ffStrbufAppend(&result.player, &result.busNameShort);
 
-    bool hasCustomPrettyName = result.playerPretty.length > 0;
-
-    if(hasCustomPrettyName)
-        ffStrbufAppendS(&result.playerPretty, " (");
-
-    ffStrbufAppend(&result.playerPretty, &result.player);
-
-    if(hasCustomPrettyName)
-        ffStrbufAppendC(&result.playerPretty, ')');
-
     pthread_mutex_unlock(&mutex);
     return &result;
 }

src/detection/os.c

@@ -1,15 +1,16 @@
 #include "fastfetch.h"
 
+#include <string.h>
 #include <pthread.h>
 
 #if !defined(__ANDROID__)
 
-static void parseFile(const char* fileName, FFOSResult* result)
+static bool parseFile(const char* fileName, FFOSResult* result)
 {
-    if(result->name.length > 0 && result->prettyName.length > 0)
-        return;
+    if(result->id.length > 0 && result->name.length > 0 && result->prettyName.length > 0)
+        return true;
 
-    ffParsePropFileValues(fileName, 13, (FFpropquery[]) {
+    return ffParsePropFileValues(fileName, 13, (FFpropquery[]) {
         {"NAME =", &result->name},
         {"DISTRIB_DESCRIPTION =", &result->prettyName},
         {"PRETTY_NAME =", &result->prettyName},
@@ -26,9 +27,70 @@ static void parseFile(const char* fileName, FFOSResult* result)
     });
 }
 
+static void getUbuntuFlavour(FFOSResult* result)
+{
+    const char* xdgConfigDirs = getenv("XDG_CONFIG_DIRS");
+    if(!ffStrSet(xdgConfigDirs))
+        return;
+
+    if(strstr(xdgConfigDirs, "kde") != NULL || strstr(xdgConfigDirs, "plasma") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Kubuntu");
+        ffStrbufSetS(&result->prettyName, "Kubuntu");
+        ffStrbufSetS(&result->id, "kubuntu");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "xfce") != NULL || strstr(xdgConfigDirs, "xubuntu") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Xubuntu");
+        ffStrbufSetS(&result->prettyName, "Xubuntu");
+        ffStrbufSetS(&result->id, "xubuntu");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "lxde") != NULL || strstr(xdgConfigDirs, "lubuntu") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Lubuntu");
+        ffStrbufSetS(&result->prettyName, "Lubuntu");
+        ffStrbufSetS(&result->id, "lubuntu");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "budgie") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Ubuntu Budgie");
+        ffStrbufSetS(&result->prettyName, "Ubuntu Budgie");
+        ffStrbufSetS(&result->id, "ubuntu-budgie");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "mate") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Ubuntu MATE");
+        ffStrbufSetS(&result->prettyName, "Ubuntu MATE");
+        ffStrbufSetS(&result->id, "ubuntu-mate");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+
+    if(strstr(xdgConfigDirs, "studio") != NULL)
+    {
+        ffStrbufSetS(&result->name, "Ubuntu Studio");
+        ffStrbufSetS(&result->prettyName, "Ubuntu Studio");
+        ffStrbufSetS(&result->id, "ubuntu-studio");
+        ffStrbufSetS(&result->idLike, "ubuntu");
+        return;
+    }
+}
+
 #endif
 
-const FFOSResult* ffDetectOS(FFinstance* instance)
+const FFOSResult* ffDetectOS(const FFinstance* instance)
 {
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
     static FFOSResult result;
@@ -62,12 +124,27 @@ const FFOSResult* ffDetectOS(FFinstance* instance)
     {
         parseFile(instance->config.osFile.chars, &result);
     }
+    else if(instance->config.escapeBedrock && parseFile(FASTFETCH_TARGET_DIR_ROOT"/bedrock/etc/bedrock-release", &result))
+    {
+        if(result.id.length == 0)
+            ffStrbufAppendS(&result.id, "bedrock");
+
+        if(result.name.length == 0)
+            ffStrbufAppendS(&result.name, "Bedrock");
+
+        if(result.prettyName.length == 0)
+            ffStrbufAppendS(&result.prettyName, "Bedrock Linux");
+    }
     else
     {
-        parseFile("/etc/os-release", &result);
-        parseFile("/usr/lib/os-release", &result);
-        parseFile("/etc/lsb-release", &result);
+        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(ffStrbufIgnCaseCompS(&result.id, "ubuntu") == 0)
+        getUbuntuFlavour(&result);
+
 #else
     ffStrbufSetS(&result.name, "Android");
     ffStrbufSetS(&result.id, "android");

src/detection/plasma.c

@@ -42,20 +42,20 @@ static bool detectFromConfigFile(const FFstrbuf* filename, FFPlasmaResult* resul
         }
 
         if(category == PLASMA_CATEGORY_KDE && result->widgetStyle.length == 0)
-            ffGetPropValue(line, "widgetStyle =", &result->widgetStyle);
+            ffParsePropLine(line, "widgetStyle =", &result->widgetStyle);
         else if(category == PLASMA_CATEGORY_ICONS && result->icons.length == 0)
-            ffGetPropValue(line, "Theme =", &result->icons);
+            ffParsePropLine(line, "Theme =", &result->icons);
         else if(category == PLASMA_CATEGORY_GENERAL)
         {
             if(result->colorScheme.length == 0)
-                ffGetPropValue(line, "ColorScheme =", &result->colorScheme);
+                ffParsePropLine(line, "ColorScheme =", &result->colorScheme);
 
             if(result->font.length == 0)
-                ffGetPropValue(line, "font =", &result->font);
+                ffParsePropLine(line, "font =", &result->font);
 
             //Before plasma 5.23, "Font" was the key instead of "font". Since a lot of distros ship older versions, we test for both.
             if(result->font.length == 0)
-                ffGetPropValue(line, "Font =", &result->font);
+                ffParsePropLine(line, "Font =", &result->font);
         }
     }
 

src/detection/vulkan.c

@@ -0,0 +1,225 @@
+#include "fastfetch.h"
+
+#include <pthread.h>
+
+#ifdef FF_HAVE_VULKAN
+#include <vulkan/vulkan.h>
+
+static inline void applyVulkanVersion(uint32_t vulkanVersion, FFVersion* ffVersion)
+{
+    ffVersion->major = VK_VERSION_MAJOR(vulkanVersion);
+    ffVersion->minor = VK_VERSION_MINOR(vulkanVersion);
+    ffVersion->patch = VK_VERSION_PATCH(vulkanVersion);
+}
+
+static void applyDriverName(VkPhysicalDeviceDriverProperties* properties, FFstrbuf* result)
+{
+    if(!ffStrSet(properties->driverName))
+        return;
+
+    ffStrbufAppendS(result, properties->driverName);
+
+    if(!ffStrSet(properties->driverInfo))
+        return;
+
+    ffStrbufAppendS(result, " [");
+    ffStrbufAppendS(result, properties->driverInfo);
+    ffStrbufAppendC(result, ']');
+}
+
+static void detectVulkan(const FFinstance* instance, FFVulkanResult* result)
+{
+    FF_LIBRARY_LOAD(vulkan, instance->config.libVulkan, , "libvulkan.so", 2)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkGetInstanceProcAddr,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkCreateInstance,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkDestroyInstance,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkEnumeratePhysicalDevices,)
+    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkGetPhysicalDeviceProperties,)
+
+    //Some drivers (nvdc) print messages to stdout
+    //and thats the best way i found to disable that
+    ffSuppressIO(true);
+
+    FFVersion instanceVersion = FF_VERSION_INIT;
+
+    //We need to get the function pointer this way, because it is only provided by vulkan 1.1 and higher.
+    //a dlsym would fail on 1.0 implementations
+    PFN_vkEnumerateInstanceVersion ffvkEnumerateInstanceVersion = (PFN_vkEnumerateInstanceVersion) ffvkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion");
+    if(ffvkEnumerateInstanceVersion != NULL)
+    {
+        uint32_t version;
+        if(ffvkEnumerateInstanceVersion(&version) == VK_SUCCESS)
+            applyVulkanVersion(version, &instanceVersion);
+    }
+
+    const uint32_t projectVersion = VK_MAKE_VERSION(
+        FASTFETCH_PROJECT_VERSION_MAJOR,
+        FASTFETCH_PROJECT_VERSION_MINOR,
+        FASTFETCH_PROJECT_VERSION_PATCH
+    );
+
+    //We need to request 1.2 to get physicalDeviceDriverProperties
+    uint32_t requestedVkVersion = VK_API_VERSION_1_0;
+    if(instanceVersion.minor >= 2)
+        requestedVkVersion = VK_API_VERSION_1_2;
+
+    const VkApplicationInfo applicationInfo = {
+        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+        .pNext = NULL,
+        .pApplicationName = FASTFETCH_PROJECT_NAME,
+        .applicationVersion = projectVersion,
+        .pEngineName = "vulkanPrintGPUs",
+        .engineVersion = projectVersion,
+        .apiVersion = requestedVkVersion
+    };
+
+    const VkInstanceCreateInfo instanceCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+        .pNext = NULL,
+        .pApplicationInfo = &applicationInfo,
+        .enabledLayerCount = 0,
+        .ppEnabledLayerNames = NULL,
+        .enabledExtensionCount = 0,
+        .ppEnabledExtensionNames = NULL,
+        .flags = 0
+    };
+
+    VkInstance vkInstance;
+    if(ffvkCreateInstance(&instanceCreateInfo, NULL, &vkInstance) != VK_SUCCESS)
+    {
+        dlclose(vulkan);
+        ffSuppressIO(false);
+        return;
+    }
+
+
+    //if instance creation succeeded, but vkEnumerateInstanceVersion didn't, this means we are running against a vulkan 1.0 implementation
+    //explicitly set this version, if no device is found, so we still have at least this info
+    if(instanceVersion.major == 0 && instanceVersion.minor == 0 && instanceVersion.patch == 0)
+        instanceVersion.major = 1;
+
+    uint32_t physicalDeviceCount;
+    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, NULL) != VK_SUCCESS)
+    {
+        ffvkDestroyInstance(vkInstance, NULL);
+        dlclose(vulkan);
+        ffSuppressIO(false);
+        return;
+    }
+
+    VkPhysicalDevice* physicalDevices = malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
+    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices) != VK_SUCCESS)
+    {
+        free(physicalDevices);
+        ffvkDestroyInstance(vkInstance, NULL);
+        dlclose(vulkan);
+        ffSuppressIO(false);
+        return;
+    }
+
+    PFN_vkGetPhysicalDeviceProperties2 ffvkGetPhysicalDeviceProperties2 = (PFN_vkGetPhysicalDeviceProperties2) ffvkGetInstanceProcAddr(vkInstance, "vkGetPhysicalDeviceProperties2");
+
+    FFVersion maxDeviceApiVersion = FF_VERSION_INIT;
+    FFVersion maxDeviceConformanceVersion = FF_VERSION_INIT;
+
+    for(uint32_t i = 0; i < physicalDeviceCount; i++)
+    {
+        //Get device properties.
+        //On VK 1.2 and up, we use vkGetPhysicalDeviceProperties2, so we can put VkPhysicalDeviceDriverProperties in the pNext chain.
+        //This is required to get the driver name and conformance version.
+
+        VkPhysicalDeviceDriverProperties driverProperties;
+        driverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+        driverProperties.pNext = NULL;
+        driverProperties.driverName[0] = '\0';
+        driverProperties.conformanceVersion = (VkConformanceVersion) {0, 0, 0, 0};
+
+        VkPhysicalDeviceProperties2 physicalDeviceProperties;
+        physicalDeviceProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+        physicalDeviceProperties.pNext = &driverProperties;
+
+        if(ffvkGetPhysicalDeviceProperties2 != NULL)
+            ffvkGetPhysicalDeviceProperties2(physicalDevices[i], &physicalDeviceProperties);
+        else
+            ffvkGetPhysicalDeviceProperties(physicalDevices[i], &physicalDeviceProperties.properties);
+
+        //If the device api version is higher than the current highest device api version, overwrite it
+        //In this case, also use the current device driver name as the shown driver name
+
+        FFVersion deviceAPIVersion = FF_VERSION_INIT;
+        applyVulkanVersion(physicalDeviceProperties.properties.apiVersion, &deviceAPIVersion);
+        if(ffVersionCompare(&deviceAPIVersion, &maxDeviceApiVersion) > 0)
+        {
+            maxDeviceApiVersion = deviceAPIVersion;
+            applyDriverName(&driverProperties, &result->driver);
+        }
+
+        //If the device conformance version is higher than the current highest device conformance version, overwrite it
+
+        FFVersion deviceConformanceVersion = FF_VERSION_INIT;
+        deviceConformanceVersion.major = driverProperties.conformanceVersion.major;
+        deviceConformanceVersion.minor = driverProperties.conformanceVersion.minor;
+        deviceConformanceVersion.patch = driverProperties.conformanceVersion.patch;
+
+        if(ffVersionCompare(&deviceConformanceVersion, &maxDeviceConformanceVersion) > 0)
+            maxDeviceConformanceVersion = deviceConformanceVersion;
+
+        //Add the device to the list of devices shown by the GPU module
+
+        //We don't want softare rasterizers to show up as physical gpu
+        if(physicalDeviceProperties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU)
+            continue;
+
+        FFGPUResult* gpu = ffListAdd(&result->devices);
+        ffStrbufInit(&gpu->vendor);
+        ffStrbufInit(&gpu->name);
+        ffStrbufInit(&gpu->driver);
+        ffStrbufAppendS(&gpu->name, physicalDeviceProperties.properties.deviceName);
+    }
+
+    //If the highest device version is lower than the instance version, use it as our vulkan version
+    //otherwise the instance version is the vulkan version
+    if(ffVersionCompare(&instanceVersion, &maxDeviceApiVersion) > 0)
+        ffVersionToPretty(&maxDeviceApiVersion, &result->apiVersion);
+    else
+        ffVersionToPretty(&instanceVersion, &result->apiVersion);
+
+    //Use the highest device conformace version as our conformance version
+    ffVersionToPretty(&maxDeviceConformanceVersion, &result->conformanceVersion);
+
+    free(physicalDevices);
+    ffvkDestroyInstance(vkInstance, NULL);
+    dlclose(vulkan);
+    ffSuppressIO(false);
+}
+
+#endif
+
+const FFVulkanResult* ffDetectVulkan(const FFinstance* instance)
+{
+    static FFVulkanResult 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.driver);
+    ffStrbufInit(&result.apiVersion);
+    ffStrbufInit(&result.conformanceVersion);
+    ffListInit(&result.devices, sizeof(FFGPUResult));
+
+    #ifdef FF_HAVE_VULKAN
+        detectVulkan(instance, &result);
+    #else
+        FF_UNUSED(instance);
+    #endif
+
+    pthread_mutex_unlock(&mutex);
+    return &result;
+}

src/fastfetch.c

@@ -12,8 +12,6 @@ typedef struct FFdata
 {
     FFvaluestore valuestore;
     FFstrbuf structure;
-    FFstrbuf logoName;
-    FFstrbuf logoColors[FASTFETCH_LOGO_MAX_COLORS];
     bool multithreading;
 } FFdata;
 
@@ -95,7 +93,7 @@ static inline void printCommandHelp(const char* command)
     }
     else if(strcasecmp(command, "packages-format") == 0)
     {
-        constructAndPrintCommandHelpFormat("packages", "{2} (pacman){?3}[{3}]{?}, {4} (dpkg), {5} (rpm), {6} (emerge), {7} (xps), {8}, (flatpak), {9} (snap)", 9,
+        constructAndPrintCommandHelpFormat("packages", "{2} (pacman){?3}[{3}]{?}, {4} (dpkg), {5} (rpm), {6} (emerge), {7} (xbps), {8} (nix-user), {9} (nix-default), {10} (flatpak), {11} (snap)", 11,
             "Number of all packages",
             "Number of pacman packages",
             "Pacman branch on manjaro",
@@ -103,6 +101,8 @@ static inline void printCommandHelp(const char* command)
             "Number of rpm packages",
             "Number of emerge packages",
             "Number of xbps packages",
+            "Number of nix-user packages",
+            "Number of nix-default packages",
             "Number of flatpak packages",
             "Number of snap packages"
         );
@@ -312,7 +312,8 @@ static inline void printCommandHelp(const char* command)
     }
     else if(strcasecmp(command, "song-format") == 0)
     {
-        constructAndPrintCommandHelpFormat("song", "{2} - {3} - {1}", 4,
+        constructAndPrintCommandHelpFormat("song", "{3} - {4} - {1}", 5,
+            "Song name pretty",
             "Song name",
             "Artist name",
             "Album name",
@@ -344,6 +345,31 @@ static inline void printCommandHelp(const char* command)
             "second with leading zero"
         );
     }
+    else if(strcasecmp(command, "vulkan-format") == 0)
+    {
+        constructAndPrintCommandHelpFormat("vulkan", "{} (driver), {} (api version)", 3,
+            "Driver name",
+            "API version",
+            "Conformance version"
+        );
+    }
+    else if(strcasecmp(command, "opengl-format") == 0)
+    {
+        constructAndPrintCommandHelpFormat("opengl", "{}", 3,
+            "version",
+            "renderer",
+            "vendor",
+            "shading language version"
+        );
+    }
+    else if(strcasecmp(command, "opencl-format") == 0)
+    {
+        constructAndPrintCommandHelpFormat("opencl", "{}", 3,
+            "version",
+            "device",
+            "vendor"
+        );
+    }
     else
         fprintf(stderr, "No specific help for command %s provided\n", command);
 }
@@ -394,7 +420,7 @@ static inline void listAvailablePresets(FFinstance* instance)
     ffStrbufAppendS(&folder, "/.local/share/fastfetch/presets/");
     listAvailablePresetsFromFolder(&folder, 0, NULL);
 
-    ffStrbufSetS(&folder, "/usr/share/fastfetch/presets/");
+    ffStrbufSetS(&folder, FASTFETCH_TARGET_DIR_USR"/share/fastfetch/presets/");
     listAvailablePresetsFromFolder(&folder, 0, NULL);
 
     ffStrbufDestroy(&folder);
@@ -489,7 +515,7 @@ static void optionParseConfigFile(FFinstance* instance, FFdata* data, const char
         return;
     }
 
-    ffStrbufSetS(&filename, "/usr/share/fastfetch/presets/");
+    ffStrbufSetS(&filename, FASTFETCH_TARGET_DIR_USR"/share/fastfetch/presets/");
     ffStrbufAppendS(&filename, value);
 
     file = fopen(filename.chars, "r");
@@ -607,8 +633,31 @@ static void optionParseColor(const char* key, const char* value, FFstrbuf* buffe
     }
 }
 
+static uint32_t optionParseUInt32(const char* key, const char* value)
+{
+    if(value == NULL)
+    {
+        fprintf(stderr, "Error: usage: %s <num>\n", key);
+        exit(480);
+    }
+
+    char* end;
+    uint32_t num = (uint32_t) strtoul(value, &end, 10);
+    if(*end != '\0')
+    {
+        fprintf(stderr, "Error: usage: %s <num>\n", key);
+        exit(479);
+    }
+
+    return num;
+}
+
 static void parseOption(FFinstance* instance, FFdata* data, const char* key, const char* value)
 {
+    ///////////////////////
+    //Informative options//
+    ///////////////////////
+
     if(strcasecmp(key, "-h") == 0 || strcasecmp(key, "--help") == 0)
     {
         printCommandHelp(value);
@@ -616,7 +665,7 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
     }
     else if(strcasecmp(key, "-v") == 0 || strcasecmp(key, "--version") == 0)
     {
-        puts("fastfetch "FASTFETCH_PROJECT_VERSION""FASTFETCH_PROJECT_VERSION_EXTRA);
+        puts("fastfetch "FASTFETCH_PROJECT_VERSION""FASTFETCH_PROJECT_VERSION_TWEAK);
         exit(0);
     }
     else if(strcasecmp(key, "--version-raw") == 0)
@@ -624,21 +673,6 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         puts(FASTFETCH_PROJECT_VERSION);
         exit(0);
     }
-    else if(strcasecmp(key, "--list-logos") == 0)
-    {
-        ffListLogos();
-        exit(0);
-    }
-    else if(strcasecmp(key, "--list-logos-autocompletion") == 0)
-    {
-        ffListLogosForAutocompletion();
-        exit(0);
-    }
-    else if(strcasecmp(key, "--print-logos") == 0)
-    {
-        ffPrintLogos(instance);
-        exit(0);
-    }
     else if(strcasecmp(key, "--print-config") == 0)
     {
         fputs(FASTFETCH_DATATEXT_CONFIG, stdout);
@@ -664,32 +698,163 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         ffListFeatures();
         exit(0);
     }
-    else if(strcasecmp(key, "--spacing") == 0)
+    else if(strcasecmp(key, "--list-logos") == 0)
+    {
+        ffLogoBuiltinList();
+        exit(0);
+    }
+    else if(strcasecmp(key, "--list-logos-autocompletion") == 0)
+    {
+        ffLogoBuiltinListAutocompletion();
+        exit(0);
+    }
+    else if(strcasecmp(key, "--print-logos") == 0)
+    {
+        ffLogoBuiltinPrint(instance);
+        exit(0);
+    }
+
+    ///////////////////
+    //General options//
+    ///////////////////
+
+    else if(strcasecmp(key, "-r") == 0 || strcasecmp(key, "--recache") == 0)
+    {
+        //Set cacheSave as well, because the user expects the values to be cached when expliciting using --recache
+        instance->config.recache = optionParseBoolean(value);
+        instance->config.cacheSave = instance->config.recache;
+    }
+    else if(strcasecmp(key, "--nocache") == 0)
+    {
+        instance->config.recache = optionParseBoolean(value);
+        instance->config.cacheSave = false;
+    }
+    else if(strcasecmp(key, "--load-config") == 0)
+        optionParseConfigFile(instance, data, key, value);
+    else if(strcasecmp(key, "--multithreading") == 0)
+        data->multithreading = optionParseBoolean(value);
+    else if(strcasecmp(key, "--allow-slow-operations") == 0)
+        instance->config.allowSlowOperations = optionParseBoolean(value);
+    else if(strcasecmp(key, "--escape-bedrock") == 0)
+        instance->config.escapeBedrock = optionParseBoolean(value);
+    else if(strcasecmp(key, "--pipe") == 0)
+        instance->config.pipe = optionParseBoolean(value);
+
+    ////////////////
+    //Logo options//
+    ////////////////
+
+    else if(strcasecmp(key, "-l") == 0 || strcasecmp(key, "--logo") == 0)
+    {
+        optionParseString(key, value, &instance->config.logoSource);
+
+        //this is usally wanted when using the none logo
+        if(strcasecmp(value, "none") == 0)
+        {
+            instance->config.logoPaddingRight = 0;
+            instance->config.logoPaddingLeft = 0;
+        }
+    }
+    else if(strcasecmp(key, "--logo-type") == 0)
     {
         if(value == NULL)
         {
-            fprintf(stderr, "Error: usage: %s <width>\n", key);
-            exit(404);
+            fprintf(stderr, "Error: usage: %s <type>\n", key);
+            exit(476);
         }
-        if(sscanf(value, "%hu", &instance->config.logoKeySpacing) != 1)
+
+        if(strcasecmp(value, "auto") == 0)
+            instance->config.logoType = FF_LOGO_TYPE_AUTO;
+        else if(strcasecmp(value, "builtin") == 0)
+            instance->config.logoType = FF_LOGO_TYPE_BUILTIN;
+        else if(strcasecmp(value, "file") == 0)
+            instance->config.logoType = FF_LOGO_TYPE_FILE;
+        else if(strcasecmp(value, "raw") == 0)
+            instance->config.logoType = FF_LOGO_TYPE_RAW;
+        else if(strcasecmp(value, "sixel") == 0)
+            instance->config.logoType = FF_LOGO_TYPE_SIXEL;
+        else if(strcasecmp(value, "kitty") == 0)
+            instance->config.logoType = FF_LOGO_TYPE_KITTY;
+        else if(strcasecmp(value, "chafa") == 0)
+            instance->config.logoType = FF_LOGO_TYPE_CHAFA;
+        else
         {
-            fprintf(stderr, "Error: couldn't parse %s to uint16_t\n", value);
-            exit(405);
+            fprintf(stderr, "Error: unknown logo type: %s\n", value);
+            exit(478);
         }
     }
-    else if(strcasecmp(key, "-x") == 0 || strcasecmp(key, "--offsetx") == 0)
+    else if(strncasecmp(key, "--logo-color-", 13) == 0 && key[13] != '\0' && key[14] == '\0') // matches "--logo-color-*"
     {
-        if(value == NULL)
+        //Map the number to an array index, so that '1' -> 0, '2' -> 1, etc.
+        int index = (int)key[13] - 49;
+
+        //Match only --logo-color-[1-9]
+        if(index < 0 || index >= FASTFETCH_LOGO_MAX_COLORS)
         {
-            fprintf(stderr, "Error: usage: %s <offset>\n", key);
-            exit(408);
-        }
-        if(sscanf(value, "%hi", &instance->config.offsetx) != 1)
-        {
-            fprintf(stderr, "Error: couldn't parse %s to int16_t\n", value);
-            exit(409);
+            fprintf(stderr, "Error: invalid --color-[1-9] index: %c\n", key[13]);
+            exit(472);
         }
+
+        optionParseColor(key, value, &instance->config.logoColors[index]);
     }
+    else if(strcasecmp(key, "--logo-width") == 0)
+        instance->config.logoWidth = optionParseUInt32(key, value);
+    else if(strcasecmp(key, "--logo-height") == 0)
+        instance->config.logoHeight = optionParseUInt32(key, value);
+    else if(strcasecmp(key, "--logo-padding") == 0)
+    {
+        uint32_t padding = optionParseUInt32(key, value);
+        instance->config.logoPaddingLeft = padding;
+        instance->config.logoPaddingRight = padding;
+    }
+    else if(strcasecmp(key, "--logo-padding-left") == 0)
+        instance->config.logoPaddingLeft = optionParseUInt32(key, value);
+    else if(strcasecmp(key, "--logo-padding-right") == 0)
+        instance->config.logoPaddingRight = optionParseUInt32(key, value);
+    else if(strcasecmp(key, "--logo-print-remaining") == 0)
+        instance->config.logoPrintRemaining = optionParseBoolean(value);
+    else if(strcasecmp(key, "--sixel") == 0)
+    {
+        optionParseString(key, value, &instance->config.logoSource);
+        instance->config.logoType = FF_LOGO_TYPE_SIXEL;
+    }
+    else if(strcasecmp(key, "--kitty") == 0)
+    {
+        optionParseString(key, value, &instance->config.logoSource);
+        instance->config.logoType = FF_LOGO_TYPE_KITTY;
+    }
+    else if(strcasecmp(key, "--file") == 0)
+    {
+        optionCheckString(key, value, &instance->config.logoSource);
+        instance->config.logoType = FF_LOGO_TYPE_FILE;
+    }
+    else if(strcasecmp(key, "--raw") == 0)
+    {
+        optionParseString(key, value, &instance->config.logoSource);
+        instance->config.logoType = FF_LOGO_TYPE_RAW;
+    }
+    else if(strcasecmp(key, "--chafa") == 0)
+    {
+        optionParseString(key, value, &instance->config.logoSource);
+        instance->config.logoType = FF_LOGO_TYPE_CHAFA;
+    }
+
+    ///////////////////
+    //Display options//
+    ///////////////////
+
+    else if(strcasecmp(key, "--show-errors") == 0)
+        instance->config.showErrors = optionParseBoolean(value);
+    else if(strcasecmp(key, "--disable-linewrap") == 0)
+        instance->config.disableLinewrap = optionParseBoolean(value);
+    else if(strcasecmp(key, "--hide-cursor") == 0)
+        instance->config.hideCursor = optionParseBoolean(value);
+    else if(strcasecmp(key, "-s") == 0 || strcasecmp(key, "--structure") == 0)
+        optionParseString(key, value, &data->structure);
+    else if(strcasecmp(key, "--separator") == 0)
+        optionParseString(key, value, &instance->config.separator);
+    else if(strcasecmp(key, "-c") == 0 || strcasecmp(key, "--color") == 0)
+        optionParseColor(key, value, &instance->config.mainColor);
     else if(strcasecmp(key, "--set") == 0)
     {
         if(value == NULL)
@@ -710,43 +875,11 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
 
         ffValuestoreSet(&data->valuestore, value, separator + 1);
     }
-    else if(strcasecmp(key, "-r") == 0 || strcasecmp(key, "--recache") == 0)
-    {
-        //Set cacheSave as well, beacuse the user expects the values to be cached when expliciting using --recache
-        instance->config.recache = optionParseBoolean(value);
-        instance->config.cacheSave = instance->config.recache;
-    }
-    else if(strcasecmp(key, "--nocache") == 0)
-    {
-        instance->config.recache = optionParseBoolean(value);
-        instance->config.cacheSave = false;
-    }
-    else if(strcasecmp(key, "--load-config") == 0)
-        optionParseConfigFile(instance, data, key, value);
-    else if(strcasecmp(key, "--show-errors") == 0)
-        instance->config.showErrors = optionParseBoolean(value);
-    else if(strcasecmp(key, "--color-logo") == 0)
-        instance->config.colorLogo = optionParseBoolean(value);
-    else if(strcasecmp(key, "--print-remaining-logo") == 0)
-        instance->config.printRemainingLogo = optionParseBoolean(value);
-    else if(strcasecmp(key, "--multithreading") == 0)
-        data->multithreading = optionParseBoolean(value);
-    else if(strcasecmp(key, "--allow-slow-operations") == 0)
-        instance->config.allowSlowOperations = optionParseBoolean(value);
-    else if(strcasecmp(key, "--disable-linewrap") == 0)
-        instance->config.disableLinewrap = optionParseBoolean(value);
-    else if(strcasecmp(key, "--hide-cursor") == 0)
-        instance->config.hideCursor = optionParseBoolean(value);
-    else if(strcasecmp(key, "--logo-raw") == 0)
-        instance->config.userLogoIsRaw = optionParseBoolean(value);
-    else if(strcasecmp(key, "--structure") == 0)
-        optionParseString(key, value, &data->structure);
-    else if(strcasecmp(key, "-l") == 0 || strcasecmp(key, "--logo") == 0)
-        optionParseString(key, value, &data->logoName);
-    else if(strcasecmp(key, "-s") == 0 || strcasecmp(key, "--separator") == 0)
-        optionParseString(key, value, &instance->config.separator);
-    else if(strcasecmp(key, "-c") == 0 || strcasecmp(key, "--color") == 0)
-        optionParseColor(key, value, &instance->config.color);
+
+    ////////////////////////
+    //Format + Key options//
+    ////////////////////////
+
     else if(strcasecmp(key, "--os-format") == 0)
         optionParseString(key, value, &instance->config.osFormat);
     else if(strcasecmp(key, "--os-key") == 0)
@@ -871,6 +1004,23 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         optionParseString(key, value, &instance->config.timeKey);
     else if(strcasecmp(key, "--time-format") == 0)
         optionParseString(key, value, &instance->config.timeFormat);
+    else if(strcasecmp(key, "--vulkan-key") == 0)
+        optionParseString(key, value, &instance->config.vulkanKey);
+    else if(strcasecmp(key, "--vulkan-format") == 0)
+        optionParseString(key, value, &instance->config.vulkanFormat);
+    else if(strcasecmp(key, "--opengl-key") == 0)
+        optionParseString(key, value, &instance->config.openGLKey);
+    else if(strcasecmp(key, "--opengl-format") == 0)
+        optionParseString(key, value, &instance->config.openGLFormat);
+    else if(strcasecmp(key, "--opencl-key") == 0)
+        optionParseString(key, value, &instance->config.openCLKey);
+    else if(strcasecmp(key, "--opencl-format") == 0)
+        optionParseString(key, value, &instance->config.openCLFormat);
+
+    ///////////////////
+    //Library options//
+    ///////////////////
+
     else if(strcasecmp(key, "--lib-PCI") == 0)
         optionParseString(key, value, &instance->config.libPCI);
     else if(strcasecmp(key, "--lib-vulkan") == 0)
@@ -893,8 +1043,29 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         optionParseString(key, value, &instance->config.libDBus);
     else if(strcasecmp(key, "--lib-XFConf") == 0)
         optionParseString(key, value, &instance->config.libXFConf);
+    else if(strcasecmp(key, "--lib-sqlite") == 0 || strcasecmp(key, "--lib-sqlite3") == 0)
+        optionParseString(key, value, &instance->config.libSQLite3);
     else if(strcasecmp(key, "--lib-rpm") == 0)
         optionParseString(key, value, &instance->config.librpm);
+    else if(strcasecmp(key, "--lib-imagemagick") == 0)
+        optionParseString(key, value, &instance->config.libImageMagick);
+    else if(strcasecmp(key, "--lib-z") == 0)
+        optionParseString(key, value, &instance->config.libZ);
+    else if(strcasecmp(key, "--lib-chafa") == 0)
+        optionParseString(key, value, &instance->config.libChafa);
+    else if(strcasecmp(key, "--lib-egl") == 0)
+        optionParseString(key, value, &instance->config.libEGL);
+    else if(strcasecmp(key, "--lib-glx") == 0)
+        optionParseString(key, value, &instance->config.libGLX);
+    else if(strcasecmp(key, "--lib-osmesa") == 0)
+        optionParseString(key, value, &instance->config.libOSMesa);
+    else if(strcasecmp(key, "--lib-opencl") == 0)
+        optionParseString(key, value, &instance->config.libOpenCL);
+
+    //////////////////
+    //Module options//
+    //////////////////
+
     else if(strcasecmp(key, "--disk-folders") == 0)
         optionParseString(key, value, &instance->config.diskFolders);
     else if(strcasecmp(key, "--battery-dir") == 0)
@@ -912,33 +1083,34 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
     else if(strcasecmp(key, "--player-name") == 0)
         optionParseString(key, value, &instance->config.playerName);
     else if(strcasecmp(key, "--public-ip-timeout") == 0)
+        instance->config.publicIpTimeout = optionParseUInt32(key, value);
+    else if(strcasecmp(key, "--gl") == 0)
     {
         if(value == NULL)
         {
-            fprintf(stderr, "Error: usage: %s <value>\n", key);
-            exit(465);
+            fprintf(stderr, "Error: usage: %s <type>\n", key);
+            exit(491);
         }
 
-        if(sscanf(value, "%u", &instance->config.publicIpTimeout) != 1)
+        if(strcasecmp(value, "auto") == 0)
+            instance->config.glType = FF_GL_TYPE_AUTO;
+        else if(strcasecmp(value, "egl") == 0)
+            instance->config.glType = FF_GL_TYPE_EGL;
+        else if(strcasecmp(value, "glx") == 0)
+            instance->config.glType = FF_GL_TYPE_GLX;
+        else if(strcasecmp(value, "osmesa") == 0)
+            instance->config.glType = FF_GL_TYPE_OSMESA;
+        else
         {
-            fprintf(stderr, "Error: couldn't parse %s to uint32_t\n", value);
-            exit(466);
+            fprintf(stderr, "Error: unknown gl type: %s\n", value);
+            exit(492);
         }
     }
-    else if(strncasecmp(key, "--color-", 7) == 0 && key[8] != '\0' && key[9] == '\0') // matches "--color-*"
-    {
-        //Map the number to an array index, so that '1' -> 0, '2' -> 1, etc.
-        int index = (int)key[8] - 49;
 
-        //Match only --color-[1-9]
-        if(index < 0 || index >= FASTFETCH_LOGO_MAX_COLORS)
-        {
-            fprintf(stderr, "Error: invalid --color-[1-9] index: %c\n", key[8]);
-            exit(472);
-        }
+    //////////////////
+    //Unknown option//
+    //////////////////
 
-        optionParseColor(key, value, &data->logoColors[index]);
-    }
     else
     {
         fprintf(stderr, "Error: unknown option: %s\n", key);
@@ -1075,6 +1247,12 @@ static void parseStructureCommand(FFinstance* instance, FFdata* data, const char
         ffPrintTime(instance);
     else if(strcasecmp(line, "colors") == 0)
         ffPrintColors(instance);
+    else if(strcasecmp(line, "vulkan") == 0)
+        ffPrintVulkan(instance);
+    else if(strcasecmp(line, "opengl") == 0)
+        ffPrintOpenGL(instance);
+    else if(strcasecmp(line, "opencl") == 0)
+        ffPrintOpenCL(instance);
     else
         ffPrintError(instance, line, 0, NULL, NULL, 0, "<no implementation provided>");
 }
@@ -1088,32 +1266,11 @@ int main(int argc, const char** argv)
     FFdata data;
     ffValuestoreInit(&data.valuestore);
     ffStrbufInitA(&data.structure, 256);
-    ffStrbufInitA(&data.logoName, 0);
     data.multithreading = true;
 
-    for(uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++)
-        ffStrbufInitA(&data.logoColors[i], 0);
-
     parseDefaultConfigFile(&instance, &data);
     parseArguments(&instance, &data, argc, argv);
 
-    //Load custom logo if it exists
-    if(data.logoName.length > 0)
-        ffLoadLogoSet(&instance, data.logoName.chars);
-    else
-        ffLoadLogo(&instance);
-
-    //If we haven't set key color, use primary color of logo
-    if(instance.config.color.length == 0)
-        ffStrbufSet(&instance.config.color, &instance.config.logoColors[0]);
-
-    //Overwrite logo colors with custom colors
-    for(uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++)
-    {
-        if(data.logoColors[i].length > 0)
-            ffStrbufSet(&instance.config.logoColors[i], &data.logoColors[i]);
-    }
-
     //Start detection threads
     if(data.multithreading)
         ffStartDetectionThreads(&instance);

src/fastfetch.h

@@ -31,32 +31,48 @@ static inline void ffUnused(int dummy, ...) { (void) dummy; }
 
 #define FASTFETCH_LOGO_MAX_COLORS 9 //two digits would make parsing much more complicated (index 1 - 9)
 
-typedef struct FFlogo
+typedef enum FFLogoType
 {
-    const char** names; //Null terminated
-    char* lines;
-    bool isFromUser;
-    const char** builtinColors; // [0] is used as key color, if not user specified
-} FFlogo;
+    FF_LOGO_TYPE_AUTO,    //If something is given, first try builtin, then file. Otherwise detect logo
+    FF_LOGO_TYPE_BUILTIN, //Builtin ascii art.
+    FF_LOGO_TYPE_FILE,    //Raw text file, printed as is.
+    FF_LOGO_TYPE_RAW,     //Raw text file, printed with color codes replacement.
+    FF_LOGO_TYPE_SIXEL,   //Image file, printed as sixel codes.
+    FF_LOGO_TYPE_KITTY,   //Image file, printed as kitty graphics protocol
+    FF_LOGO_TYPE_CHAFA    //Image file, printed as ascii art using libchafa
+} FFLogoType;
+
+typedef enum FFGLType
+{
+    FF_GL_TYPE_AUTO,
+    FF_GL_TYPE_EGL,
+    FF_GL_TYPE_GLX,
+    FF_GL_TYPE_OSMESA
+} FFGLType;
 
 typedef struct FFconfig
 {
-    const FFlogo* logo;
+    FFstrbuf logoSource;
+    FFLogoType logoType;
     FFstrbuf logoColors[FASTFETCH_LOGO_MAX_COLORS];
+    uint32_t logoWidth;
+    uint32_t logoHeight;
+    uint32_t logoPaddingLeft;
+    uint32_t logoPaddingRight;
+    bool logoPrintRemaining;
 
-    uint16_t logoKeySpacing;
+    FFstrbuf mainColor; //If this is empty, ffLogoPrint will set it to the main color of the logo
     FFstrbuf separator;
-    int16_t offsetx;
-    FFstrbuf color;
-    bool colorLogo;
+
     bool showErrors;
     bool recache;
     bool cacheSave;
-    bool printRemainingLogo;
     bool allowSlowOperations;
     bool disableLinewrap;
     bool hideCursor;
-    bool userLogoIsRaw;
+    bool escapeBedrock;
+    FFGLType glType;
+    bool pipe; //disables logo and all escape sequences
 
     FFstrbuf osFormat;
     FFstrbuf osKey;
@@ -120,6 +136,12 @@ typedef struct FFconfig
     FFstrbuf dateFormat;
     FFstrbuf timeKey;
     FFstrbuf timeFormat;
+    FFstrbuf vulkanKey;
+    FFstrbuf vulkanFormat;
+    FFstrbuf openGLKey;
+    FFstrbuf openGLFormat;
+    FFstrbuf openCLKey;
+    FFstrbuf openCLFormat;
 
     FFstrbuf libPCI;
     FFstrbuf libVulkan;
@@ -132,7 +154,15 @@ typedef struct FFconfig
     FFstrbuf libDConf;
     FFstrbuf libDBus;
     FFstrbuf libXFConf;
+    FFstrbuf libSQLite3;
     FFstrbuf librpm;
+    FFstrbuf libImageMagick;
+    FFstrbuf libZ;
+    FFstrbuf libChafa;
+    FFstrbuf libEGL;
+    FFstrbuf libGLX;
+    FFstrbuf libOSMesa;
+    FFstrbuf libOpenCL;
 
     FFstrbuf diskFolders;
 
@@ -154,7 +184,8 @@ typedef struct FFconfig
 typedef struct FFstate
 {
     uint32_t logoWidth;
-    char* logoLinesIndex;
+    uint32_t logoHeight;
+    uint32_t keysHeight;
 
     struct passwd* passwd;
     struct utsname utsname;
@@ -170,6 +201,14 @@ typedef struct FFinstance
     FFstate state;
 } FFinstance;
 
+typedef struct FFVersion
+{
+    uint32_t major;
+    uint32_t minor;
+    uint32_t patch;
+} FFVersion;
+#define FF_VERSION_INIT ((FFVersion) {0})
+
 typedef struct FFTitleResult
 {
     FFstrbuf userName;
@@ -225,6 +264,21 @@ typedef struct FFTerminalShellResult
     FFstrbuf userShellVersion;
 } FFTerminalShellResult;
 
+typedef struct FFGPUResult
+{
+    FFstrbuf vendor;
+    FFstrbuf name;
+    FFstrbuf driver;
+} FFGPUResult;
+
+typedef struct FFVulkanResult
+{
+    FFstrbuf driver;
+    FFstrbuf apiVersion;
+    FFstrbuf conformanceVersion;
+    FFlist devices; //List of FFGPUResult
+} FFVulkanResult;
+
 typedef struct FFResolutionResult
 {
     uint32_t width;
@@ -259,7 +313,6 @@ typedef struct FFMediaResult
 {
     FFstrbuf busNameShort; //e.g. plasma-browser-integration
     FFstrbuf player; // e.g. Google Chrome
-    FFstrbuf playerPretty; // e.g. YouTube (Google Chrome)
     FFstrbuf song;
     FFstrbuf artist;
     FFstrbuf album;
@@ -376,9 +429,9 @@ typedef enum FFInitState
 #define FF_LIBRARY_LOAD_SYMBOL(library, symbolName, returnValue) \
     __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADRESS(library, ff ## symbolName, symbolName, returnValue);
 
-/*************************/
-/* Common util functions */
-/*************************/
+//////////////////////
+// Common functions //
+//////////////////////
 
 //common/init.c
 void ffInitInstance(FFinstance* instance);
@@ -391,37 +444,37 @@ void ffListFeatures();
 void ffStartDetectionThreads(FFinstance* instance);
 
 //common/io.c
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat);
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numFormatArgs, const char* message, ...);
-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 ffGetCacheFilePath(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer);
-void ffReadCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* buffer);
-void ffWriteCacheFile(FFinstance* instance, const char* moduleName, const char* extension, FFstrbuf* content);
-bool ffPrintFromCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numArgs);
-void ffPrintAndSaveToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments);
-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 ffCacheValidate(FFinstance* instance);
-void ffCacheOpenWrite(FFinstance* instance, const char* moduleName, FFcache* cache);
-void ffCacheClose(FFcache* cache);
-
 void ffAppendFDContent(int fd, FFstrbuf* buffer);
 bool ffAppendFileContent(const char* fileName, FFstrbuf* buffer); //returns true if open() succeeds. This is used to differentiate between <file not found> and <empty file>
 bool ffGetFileContent(const char* fileName, FFstrbuf* buffer);
 bool ffWriteFDContent(int fd, const FFstrbuf* content);
-void ffWriteFileContent(const char* fileName, const FFstrbuf* buffer);
+bool ffWriteFileContent(const char* fileName, const FFstrbuf* buffer);
 
 bool ffFileExists(const char* fileName, mode_t mode);
+void ffSuppressIO(bool suppress); // Not thread safe!
 
-// Not thread safe!
-void ffSuppressIO(bool suppress);
+void ffGetTerminalResponse(const char* request, const char* format, ...);
 
+//common/printing.c
+void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat);
+void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t numFormatArgs, const char* message, ...);
+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 ffPrintColor(const FFstrbuf* colorValue);
+void ffPrintCharTimes(char c, uint32_t times);
 
-// They 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
+//common/caching.c
+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 FFstrbuf* customKeyFormat, const FFstrbuf* formatString, uint32_t 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 ffPrintAndWriteToCache(FFinstance* instance, const char* moduleName, const FFstrbuf* customKeyFormat, const FFstrbuf* value, const FFstrbuf* formatString, uint32_t numArgs, const FFformatarg* arguments);
+
+//common/properties.c
+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);
@@ -429,6 +482,24 @@ bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, c
 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);
 
+//common/font.c
+void ffFontInitQt(FFfont* font, const char* data);
+void ffFontInitPango(FFfont* font, const char* data);
+void ffFontInitCopy(FFfont* font, const char* name);
+void ffFontDestroy(FFfont* font);
+
+//common/format.c
+void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
+void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments);
+
+//common/parsing.c
+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);
+
 //common/processing.c
 void ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[]);
 
@@ -438,47 +509,36 @@ void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
 //common/networking.c
 void ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, FFstrbuf* buffer);
 
-//common/logo.c
-void ffLoadLogoSet(FFinstance* instance, const char* logo);
-void ffLoadLogo(FFinstance* instance);
-void ffPrintLogoLine(FFinstance* instance);
-void ffPrintRemainingLogo(FFinstance* instance);
-
-void ffPrintLogos(FFinstance* instance);
-void ffListLogos();
-void ffListLogosForAutocompletion();
-
-//common/format.c
-void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, const FFstrbuf* error, uint32_t numArgs, const FFformatarg* arguments);
-
-//common/parsing.c
-void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4);
-
-void ffFontInitQt(FFfont* font, const char* data);
-void ffFontInitPango(FFfont* font, const char* data);
-void ffFontInitCopy(FFfont* font, const char* name);
-void ffFontDestroy(FFfont* font);
-
-bool ffGetPropValue(const char* line, const char* start, FFstrbuf* buffer);
-bool ffGetPropValueFromLines(const char* lines, const char* start, FFstrbuf* buffer);
-
-void ffParseSemver(FFstrbuf* buffer, const FFstrbuf* major, const FFstrbuf* minor, const FFstrbuf* patch);
-
-bool ffStrSet(const char* str);
-
 //common/settings.c
 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__
 bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);
 #endif
 
+////////////////////
+// Logo functions //
+////////////////////
+
+void ffLogoPrint(FFinstance* instance);
+void ffLogoPrintRemaining(FFinstance* instance);
+void ffLogoPrintLine(FFinstance* instance);
+
+void ffLogoBuiltinPrint(FFinstance* instance);
+void ffLogoBuiltinList();
+void ffLogoBuiltinListAutocompletion();
+
+/////////////////////////
+// Detection functions //
+/////////////////////////
+
 //detection/os.c
-const FFOSResult* ffDetectOS(FFinstance* instance);
+const FFOSResult* ffDetectOS(const FFinstance* instance);
 
 //detection/plasma.c
 const FFPlasmaResult* ffDetectPlasma(FFinstance* instance);
@@ -503,9 +563,12 @@ const FFMediaResult* ffDetectMedia(FFinstance* instance);
 //detection/dateTime.c
 const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance);
 
-/********************/
-/* Module functions */
-/********************/
+//detection/vulkan.c
+const FFVulkanResult* ffDetectVulkan(const FFinstance* instance);
+
+//////////////////////
+// Module functions //
+//////////////////////
 
 //Common
 const FFTitleResult* ffDetectTitle(FFinstance* instance);
@@ -550,5 +613,8 @@ void ffPrintTime(FFinstance* instance);
 void ffPrintLocalIp(FFinstance* instance);
 void ffPrintPublicIp(FFinstance* instance);
 void ffPrintColors(FFinstance* instance);
+void ffPrintVulkan(FFinstance* instance);
+void ffPrintOpenGL(FFinstance* instance);
+void ffPrintOpenCL(FFinstance* instance);
 
 #endif

src/fastfetch_config.h.in

@@ -4,7 +4,13 @@
 #define FASTFETCH_PROJECT_NAME "@PROJECT_NAME@"
 #define FASTFETCH_PROJECT_VERSION "@PROJECT_VERSION@"
 #define FASTFETCH_PROJECT_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
-#define FASTFETCH_PROJECT_VERSION_EXTRA "@PROJECT_VERSION_EXTRA@"
+#define FASTFETCH_PROJECT_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define FASTFETCH_PROJECT_VERSION_PATCH @PROJECT_VERSION_PATCH@
+#define FASTFETCH_PROJECT_VERSION_TWEAK "@PROJECT_VERSION_TWEAK@"
+
+#define FASTFETCH_TARGET_DIR_ROOT "@TARGET_DIR_ROOT@"
+#define FASTFETCH_TARGET_DIR_USR "@TARGET_DIR_USR@"
+#define FASTFETCH_TARGET_DIR_HOME "@TARGET_DIR_HOME@"
 
 #define FASTFETCH_DATATEXT_STRUCTURE "@DATATEXT_STRUCTURE@"
 #define FASTFETCH_DATATEXT_CONFIG "@DATATEXT_CONFIG@" //Requires FASTFETCH_PROJECT_VERSION and FASTFETCH_DATATEXT_STRUCTURE to be set

src/flashfetch.c

@@ -10,9 +10,6 @@ int main(int argc, char** argv)
 
     //Modify instance.config here
 
-    ffLoadLogo(&instance); //ffLoadLogoSet(&instance, "my custom logo");
-    ffStrbufSet(&instance.config.color, &instance.config.logoColors[0]); //Use the primary color of the logo as key color
-
     //Multithreading --> better performance
     ffStartDetectionThreads(&instance);
 
@@ -53,6 +50,8 @@ int main(int argc, char** argv)
     //ffPrintDateTime(&instance);
     //ffPrintDate(&instance);
     //ffPrintTime(&instance);
+    //ffPrintVulkan(&instance);
+    //ffPrintOpenGL(&instance);
     ffPrintBreak(&instance);
     ffPrintColors(&instance);
 

src/logo/image/im6.c

@@ -0,0 +1,29 @@
+#ifdef FF_HAVE_IMAGEMAGICK6
+
+#include "image.h"
+#include <magick/MagickCore.h>
+
+static FF_LIBRARY_SYMBOL(ResizeImage);
+
+static void* logoResize(const void* image, size_t width, size_t height, void* exceptionInfo)
+{
+    return ffResizeImage(image, width, height, UndefinedFilter, 1.0, exceptionInfo);
+}
+
+FFLogoImageResult ffLogoPrintImageIM6(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    FF_LIBRARY_LOAD(imageMagick, instance->config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-6.Q16HDRI.so", 8, "libMagickCore-6.Q16.so", 8)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imageMagick, ffResizeImage, ResizeImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
+
+    FFIMData imData;
+    imData.resizeFunc = logoResize;
+    imData.library = imageMagick;
+
+    FFLogoImageResult result = ffLogoPrintImageImpl(instance, requestData, &imData);
+
+    dlclose(imageMagick);
+
+    return result;
+}
+
+#endif

src/logo/image/im7.c

@@ -0,0 +1,29 @@
+#ifdef FF_HAVE_IMAGEMAGICK7
+
+#include "image.h"
+#include <MagickCore/MagickCore.h>
+
+static FF_LIBRARY_SYMBOL(ResizeImage);
+
+static void* logoResize(const void* image, size_t width, size_t height, void* exceptionInfo)
+{
+    return ffResizeImage(image, width, height, UndefinedFilter, exceptionInfo);
+}
+
+FFLogoImageResult ffLogoPrintImageIM7(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    FF_LIBRARY_LOAD(imageMagick, instance->config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-7.Q16HDRI.so", 11, "libMagickCore-7.Q16.so", 11)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imageMagick, ffResizeImage, ResizeImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
+
+    FFIMData imData;
+    imData.resizeFunc = logoResize;
+    imData.library = imageMagick;
+
+    FFLogoImageResult result = ffLogoPrintImageImpl(instance, requestData, &imData);
+
+    dlclose(imageMagick);
+
+    return result;
+}
+
+#endif

src/logo/image/image.c

@@ -0,0 +1,571 @@
+#include "image.h"
+
+#if defined(FF_HAVE_IMAGEMAGICK7) || defined(FF_HAVE_IMAGEMAGICK6)
+
+#define FF_KITTY_MAX_CHUNK_SIZE 4096
+
+#define FF_CACHE_FILE_HEIGHT "height"
+#define FF_CACHE_FILE_WIDTH "width"
+#define FF_CACHE_FILE_SIXEL "sixel"
+#define FF_CACHE_FILE_KITTY_COMPRESSED "kittyc"
+#define FF_CACHE_FILE_KITTY_UNCOMPRESSED "kittyu"
+#define FF_CACHE_FILE_CHAFA "chafa"
+
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#ifdef FF_HAVE_ZLIB
+#include <zlib.h>
+
+static bool compressBlob(const FFinstance* instance, void** blob, size_t* length)
+{
+    FF_LIBRARY_LOAD(zlib, instance->config.libZ, false, "libz.so", 2)
+    FF_LIBRARY_LOAD_SYMBOL(zlib, compressBound, false)
+    FF_LIBRARY_LOAD_SYMBOL(zlib, compress2, false)
+
+    uLong compressedLength = ffcompressBound(*length);
+    void* compressed = malloc(compressedLength);
+    if(compressed == NULL)
+    {
+        dlclose(zlib);
+        return false;
+    }
+
+    int compressResult = ffcompress2(compressed, &compressedLength, *blob, *length, Z_BEST_COMPRESSION);
+    dlclose(zlib);
+    if(compressResult != Z_OK)
+    {
+        free(compressed);
+        return false;
+    }
+
+    free(*blob);
+
+    *length = (size_t) compressedLength;
+    *blob = compressed;
+    return true;
+}
+
+#endif // FF_HAVE_ZLIB
+
+//We use only the defines from here, that are exactly the same in both versions
+#ifdef FF_HAVE_IMAGEMAGICK7
+    #include <MagickCore/MagickCore.h>
+#else
+    #include <magick/MagickCore.h>
+#endif
+
+typedef struct ImageData
+{
+    FF_LIBRARY_SYMBOL(CopyMagickString)
+    FF_LIBRARY_SYMBOL(ImageToBlob)
+    FF_LIBRARY_SYMBOL(Base64Encode)
+
+    ImageInfo* imageInfo;
+    Image* image;
+    ExceptionInfo* exceptionInfo;
+} ImageData;
+
+static inline bool checkAllocationResult(void* data, size_t length)
+{
+    if(data == NULL)
+        return false;
+
+    if(length == 0)
+    {
+        free(data);
+        return false;
+    }
+
+    return true;
+}
+
+static inline uint32_t simpleCeil(double value)
+{
+    uint32_t result = (uint32_t) value;
+    return value == (double) result ? result : result + 1;
+}
+
+static void writeCacheStrbuf(FFLogoRequestData* requestData, const FFstrbuf* value, const char* cacheFileName)
+{
+    uint32_t cacheDirLength = requestData->cacheDir.length;
+    ffStrbufAppendS(&requestData->cacheDir, cacheFileName);
+    ffWriteFileContent(requestData->cacheDir.chars, value);
+    ffStrbufSubstrBefore(&requestData->cacheDir, cacheDirLength);
+}
+
+static void writeCacheUint32(FFLogoRequestData* requestData, uint32_t value, const char* cacheFileName)
+{
+    FFstrbuf content;
+    content.chars = (char*) &value;
+    content.length = sizeof(value);
+    writeCacheStrbuf(requestData, &content, cacheFileName);
+}
+
+static void printImagePixels(FFinstance* instance, FFLogoRequestData* requestData, const FFstrbuf* result, const char* cacheFileName)
+{
+    //Calculate character dimensions
+    instance->state.logoWidth = requestData->logoCharacterWidth + instance->config.logoPaddingLeft + instance->config.logoPaddingRight;
+
+    instance->state.logoHeight = requestData->logoCharacterHeight;
+    if(requestData->type == FF_LOGO_TYPE_KITTY)
+        instance->state.logoHeight -= 1;
+
+    //Write cache files
+    writeCacheStrbuf(requestData, result, cacheFileName);
+
+    if(instance->config.logoWidth == 0)
+        writeCacheUint32(requestData, instance->state.logoWidth, FF_CACHE_FILE_WIDTH);
+
+    if(instance->config.logoHeight == 0)
+        writeCacheUint32(requestData, instance->state.logoHeight, FF_CACHE_FILE_HEIGHT);
+
+    //Write result to stdout
+    ffPrintCharTimes(' ', instance->config.logoPaddingLeft);
+    fflush(stdout);
+    ffWriteFDContent(STDOUT_FILENO, result);
+
+    //Go to upper left corner
+    fputs("\033[9999999D", stdout);
+    printf("\033[%uA", instance->state.logoHeight);
+}
+
+static bool printImageSixel(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+{
+    imageData->ffCopyMagickString(imageData->imageInfo->magick, "SIXEL", 6);
+
+    size_t length;
+    void* blob = imageData->ffImageToBlob(imageData->imageInfo, imageData->image, &length, imageData->exceptionInfo);
+    if(!checkAllocationResult(blob, length))
+        return false;
+
+    FFstrbuf result;
+    result.chars = (char*) blob;
+    result.length = (uint32_t) length;
+
+    printImagePixels(instance, requestData, &result, FF_CACHE_FILE_SIXEL);
+
+    free(blob);
+    return true;
+}
+
+static void appendKittyChunk(FFstrbuf* result, const char** blob, size_t* length, bool printEscapeCode)
+{
+    uint32_t chunkSize = *length > FF_KITTY_MAX_CHUNK_SIZE ? FF_KITTY_MAX_CHUNK_SIZE : (uint32_t) *length;
+
+    if(printEscapeCode)
+        ffStrbufAppendS(result, "\033_G");
+    else
+        ffStrbufAppendC(result, ',');
+
+    ffStrbufAppendS(result, chunkSize != *length ? "m=1" : "m=0");
+    ffStrbufAppendC(result, ';');
+    ffStrbufAppendNS(result, chunkSize, *blob);
+    ffStrbufAppendS(result, "\033\\");
+    *length -= chunkSize;
+    *blob += chunkSize;
+}
+
+static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+{
+    imageData->ffCopyMagickString(imageData->imageInfo->magick, "RGBA", 5);
+
+    size_t length;
+    void* blob = imageData->ffImageToBlob(imageData->imageInfo, imageData->image, &length, imageData->exceptionInfo);
+    if(!checkAllocationResult(blob, length))
+        return false;
+
+    #ifdef FF_HAVE_ZLIB
+        bool isCompressed = compressBlob(instance, &blob, &length);
+    #else
+        bool isCompressed = false;
+    #endif
+
+    char* chars = imageData->ffBase64Encode(blob, length, &length);
+    free(blob);
+    if(!checkAllocationResult(chars, length))
+        return false;
+
+    FFstrbuf result;
+    ffStrbufInitA(&result, (uint32_t) (length + 1024));
+
+    const char* currentPos = chars;
+    size_t remainingLength = length;
+
+    ffStrbufAppendF(&result, "\033_Ga=T,f=32,s=%u,v=%u", requestData->logoPixelWidth, requestData->logoPixelHeight);
+    if(isCompressed)
+        ffStrbufAppendS(&result, ",o=z");
+    appendKittyChunk(&result, &currentPos, &remainingLength, false);
+    while(remainingLength > 0)
+        appendKittyChunk(&result, &currentPos, &remainingLength, true);
+
+    printImagePixels(instance, requestData, &result, isCompressed ? FF_CACHE_FILE_KITTY_COMPRESSED : FF_CACHE_FILE_KITTY_UNCOMPRESSED);
+
+    ffStrbufDestroy(&result);
+    free(chars);
+    return true;
+}
+
+#ifdef FF_HAVE_CHAFA
+#include <chafa/chafa.h>
+static bool printImageChafa(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+{
+    FF_LIBRARY_LOAD(chafa, instance->config.libChafa, false, "libchafa.so", 1)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_symbol_map_new, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_symbol_map_add_by_tags, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_new, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_set_geometry, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_set_symbol_map, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_new, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_draw_all_pixels, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_print, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_unref, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_canvas_config_unref, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, chafa_symbol_map_unref, false)
+    FF_LIBRARY_LOAD_SYMBOL(chafa, g_string_free, false)
+
+    imageData->ffCopyMagickString(imageData->imageInfo->magick, "RGBA", 5);
+    size_t length;
+    void* blob = imageData->ffImageToBlob(imageData->imageInfo, imageData->image, &length, imageData->exceptionInfo);
+    if(!checkAllocationResult(blob, length))
+        return false;
+
+    ChafaSymbolMap* symbolMap = ffchafa_symbol_map_new();
+    ffchafa_symbol_map_add_by_tags(symbolMap, CHAFA_SYMBOL_TAG_ALL);
+
+    ChafaCanvasConfig* canvasConfig = ffchafa_canvas_config_new();
+    ffchafa_canvas_config_set_geometry(canvasConfig, (gint) requestData->logoCharacterWidth, (gint) requestData->logoCharacterHeight);
+    ffchafa_canvas_config_set_symbol_map(canvasConfig, symbolMap);
+
+    ChafaCanvas* canvas = ffchafa_canvas_new(canvasConfig);
+    ffchafa_canvas_draw_all_pixels(
+        canvas,
+        CHAFA_PIXEL_RGBA8_UNASSOCIATED,
+        blob,
+        (gint) imageData->image->columns,
+        (gint) imageData->image->rows,
+        (gint) imageData->image->columns * 4
+    );
+
+    GString* str = ffchafa_canvas_print(canvas, NULL);
+    FFstrbuf result;
+    result.allocated = (uint32_t) str->allocated_len;
+    result.length = (uint32_t) str->len;
+    result.chars = str->str;
+
+    ffLogoPrintChars(instance, result.chars, false);
+    writeCacheStrbuf(requestData, &result, FF_CACHE_FILE_CHAFA);
+
+    ffg_string_free(str, TRUE);
+    ffchafa_canvas_unref(canvas);
+    ffchafa_canvas_config_unref(canvasConfig);
+    ffchafa_symbol_map_unref(symbolMap);
+
+    return true;
+}
+#endif
+
+FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData* requestData, const FFIMData* imData)
+{
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, AcquireExceptionInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, DestroyExceptionInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, AcquireImageInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, DestroyImageInfo, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, ReadImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL(imData->library, DestroyImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+
+    ImageData imageData;
+
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imData->library, imageData.ffCopyMagickString, CopyMagickString, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imData->library, imageData.ffImageToBlob, ImageToBlob, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(imData->library, imageData.ffBase64Encode, Base64Encode, FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+
+    imageData.exceptionInfo = ffAcquireExceptionInfo();
+    if(imageData.exceptionInfo == NULL)
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+
+    ImageInfo* imageInfoIn = ffAcquireImageInfo();
+    if(imageInfoIn == NULL)
+    {
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    //+1, because we need to copy the null byte too
+    imageData.ffCopyMagickString(imageInfoIn->filename, instance->config.logoSource.chars, instance->config.logoSource.length + 1);
+
+    imageData.image = ffReadImage(imageInfoIn, imageData.exceptionInfo);
+    ffDestroyImageInfo(imageInfoIn);
+    if(imageData.image == NULL)
+    {
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    if(requestData->logoPixelWidth == 0 && requestData->logoPixelHeight == 0)
+    {
+        requestData->logoPixelWidth = (uint32_t) imageData.image->columns;
+        requestData->logoPixelHeight = (uint32_t) imageData.image->rows;
+    }
+    else if(requestData->logoPixelWidth == 0)
+        requestData->logoPixelWidth = (uint32_t) ((double) imageData.image->columns / (double) imageData.image->rows * requestData->logoPixelHeight);
+    else if(requestData->logoPixelHeight == 0)
+        requestData->logoPixelHeight = (uint32_t) ((double) imageData.image->rows / (double) imageData.image->columns * requestData->logoPixelWidth);
+
+    requestData->logoCharacterWidth = simpleCeil((double) requestData->logoPixelWidth / requestData->characterPixelWidth);
+    requestData->logoCharacterHeight = simpleCeil((double) requestData->logoPixelHeight / requestData->characterPixelHeight);
+
+    if(requestData->logoPixelWidth == 0 || requestData->logoPixelHeight == 0 || requestData->logoCharacterWidth == 0 || requestData->logoCharacterHeight == 0)
+    {
+        ffDestroyImage(imageData.image);
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    Image* resized = imData->resizeFunc(imageData.image, requestData->logoPixelWidth, requestData->logoPixelHeight, imageData.exceptionInfo);
+    ffDestroyImage(imageData.image);
+    if(resized == NULL)
+    {
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+    imageData.image = resized;
+
+    imageData.imageInfo = ffAcquireImageInfo();
+    if(imageData.imageInfo == NULL)
+    {
+        ffDestroyImage(imageData.image);
+        ffDestroyExceptionInfo(imageData.exceptionInfo);
+        return FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+    }
+
+    bool printSuccessful = false;
+    if(requestData->type == FF_LOGO_TYPE_CHAFA)
+    {
+        #ifdef FF_HAVE_CHAFA
+            printSuccessful = printImageChafa(instance, requestData, &imageData);
+        #endif
+    }
+    else if(requestData->type == FF_LOGO_TYPE_KITTY)
+        printSuccessful = printImageKitty(instance, requestData, &imageData);
+    else if(requestData->type == FF_LOGO_TYPE_SIXEL)
+        printSuccessful = printImageSixel(instance, requestData, &imageData);
+
+    ffDestroyImageInfo(imageData.imageInfo);
+    ffDestroyImage(imageData.image);
+    ffDestroyExceptionInfo(imageData.exceptionInfo);
+
+    return printSuccessful ? FF_LOGO_IMAGE_RESULT_SUCCESS : FF_LOGO_IMAGE_RESULT_RUN_ERROR;
+}
+
+static int getCacheFD(FFLogoRequestData* requestData, const char* fileName)
+{
+    uint32_t cacheDirLength = requestData->cacheDir.length;
+    ffStrbufAppendS(&requestData->cacheDir, fileName);
+    int fd = open(requestData->cacheDir.chars, O_RDONLY);
+    ffStrbufSubstrBefore(&requestData->cacheDir, cacheDirLength);
+    return fd;
+}
+
+static void readCachedStrbuf(FFLogoRequestData* requestData, FFstrbuf* result, const char* cacheFileName)
+{
+    uint32_t cacheDirLength = requestData->cacheDir.length;
+    ffStrbufAppendS(&requestData->cacheDir, cacheFileName);
+    ffAppendFileContent(requestData->cacheDir.chars, result);
+    ffStrbufSubstrBefore(&requestData->cacheDir, cacheDirLength);
+}
+
+static uint32_t readCachedUint32(FFLogoRequestData* requestData, const char* cacheFileName)
+{
+    FFstrbuf content;
+    ffStrbufInit(&content);
+    readCachedStrbuf(requestData, &content, cacheFileName);
+
+    uint32_t result = 0;
+
+    if(content.length != sizeof(result))
+    {
+        ffStrbufDestroy(&content);
+        return 0;
+    }
+
+    memcpy(&result, content.chars, sizeof(result));
+
+    ffStrbufDestroy(&content);
+
+    return result;
+}
+
+static bool printCachedChars(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 32768);
+
+    if(requestData->type == FF_LOGO_TYPE_CHAFA)
+        readCachedStrbuf(requestData, &content, FF_CACHE_FILE_CHAFA);
+
+    if(content.length == 0)
+    {
+        ffStrbufDestroy(&content);
+        return false;
+    }
+
+    ffLogoPrintChars(instance, content.chars, false);
+    ffStrbufDestroy(&content);
+    return true;
+}
+
+static bool printCachedPixel(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    requestData->logoCharacterWidth = instance->config.logoWidth;
+    if(requestData->logoCharacterWidth == 0)
+    {
+        requestData->logoCharacterWidth = readCachedUint32(requestData, FF_CACHE_FILE_WIDTH);
+        if(requestData->logoCharacterWidth == 0)
+            return false;
+    }
+
+    requestData->logoCharacterHeight = instance->config.logoHeight;
+    if(requestData->logoCharacterHeight == 0)
+    {
+        requestData->logoCharacterHeight = readCachedUint32(requestData, FF_CACHE_FILE_HEIGHT);
+        if(requestData->logoCharacterHeight == 0)
+            return false;
+    }
+
+    int fd = -1;
+    if(requestData->type == FF_LOGO_TYPE_KITTY)
+    {
+        fd = getCacheFD(requestData, FF_CACHE_FILE_KITTY_COMPRESSED);
+        if(fd == -1)
+            fd = getCacheFD(requestData, FF_CACHE_FILE_KITTY_UNCOMPRESSED);
+    }
+    else if(requestData->type == FF_LOGO_TYPE_SIXEL)
+        fd = getCacheFD(requestData, FF_CACHE_FILE_SIXEL);
+
+    if(fd == -1)
+        return false;
+
+    ffPrintCharTimes(' ', instance->config.logoPaddingLeft);
+    fflush(stdout);
+
+    char buffer[32768];
+    ssize_t readBytes;
+    while((readBytes = read(fd, buffer, sizeof(buffer))) > 0)
+        FF_UNUSED(write(STDOUT_FILENO, buffer, (size_t) readBytes));
+
+    close(fd);
+
+    instance->state.logoWidth = requestData->logoCharacterWidth + instance->config.logoPaddingLeft + instance->config.logoPaddingRight;
+    instance->state.logoHeight = requestData->logoCharacterHeight;
+
+    //Go to upper left corner
+    fputs("\033[9999999D", stdout);
+    printf("\033[%uA", instance->state.logoHeight);
+    return true;
+}
+
+static bool printCached(FFinstance* instance, FFLogoRequestData* requestData)
+{
+    if(requestData->type == FF_LOGO_TYPE_CHAFA)
+        return printCachedChars(instance, requestData);
+    else
+        return printCachedPixel(instance, requestData);
+}
+
+static bool getCharacterPixelDimensions(FFLogoRequestData* requestData)
+{
+    struct winsize winsize;
+
+    //Initialize every member to 0, because it isn't guaranteed that every terminal sets them all
+    memset(&winsize, 0, sizeof(struct winsize));
+
+    ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
+
+    if(winsize.ws_row == 0 || winsize.ws_col == 0)
+        ffGetTerminalResponse("\033[18t", "\033[8;%hu;%hut", &winsize.ws_row, &winsize.ws_col);
+
+    if(winsize.ws_row == 0 || winsize.ws_col == 0)
+        return false;
+
+    if(winsize.ws_ypixel == 0 || winsize.ws_xpixel == 0)
+        ffGetTerminalResponse("\033[14t", "\033[4;%hu;%hut", &winsize.ws_ypixel, &winsize.ws_xpixel);
+
+    requestData->characterPixelWidth = winsize.ws_xpixel / (double) winsize.ws_col;
+    requestData->characterPixelHeight = winsize.ws_ypixel / (double) winsize.ws_row;
+
+    return requestData->characterPixelWidth > 1.0 && requestData->characterPixelHeight > 1.0;
+}
+
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type)
+{
+    //Performance optimisation
+    #ifndef FF_HAVE_CHAFA
+        if(type == FF_LOGO_TYPE_CHAFA)
+            return false;
+    #endif
+
+    FFLogoRequestData requestData;
+    requestData.type = type;
+    requestData.characterPixelWidth = 1;
+    requestData.characterPixelHeight = 1;
+
+    if(
+        (type != FF_LOGO_TYPE_CHAFA || instance->config.logoWidth == 0 || instance->config.logoHeight == 0) &&
+        !getCharacterPixelDimensions(&requestData)
+    )
+        return false;
+
+    requestData.logoPixelWidth = simpleCeil((double) instance->config.logoWidth * requestData.characterPixelWidth);
+    requestData.logoPixelHeight = simpleCeil((double) instance->config.logoHeight * requestData.characterPixelHeight);
+
+    ffStrbufInitA(&requestData.cacheDir, PATH_MAX * 2);
+    ffStrbufAppend(&requestData.cacheDir, &instance->state.cacheDir);
+    ffStrbufAppendS(&requestData.cacheDir, "images");
+
+    ffStrbufEnsureFree(&requestData.cacheDir, PATH_MAX);
+    if(realpath(instance->config.logoSource.chars, requestData.cacheDir.chars + requestData.cacheDir.length) == NULL)
+    {
+        //We can safely return here, because if realpath failed, we surely won't be able to read the file
+        ffStrbufDestroy(&requestData.cacheDir);
+        return false;
+    }
+    ffStrbufRecalculateLength(&requestData.cacheDir);
+    if(!ffStrbufEndsWithC(&requestData.cacheDir, '/'))
+        ffStrbufAppendC(&requestData.cacheDir, '/');
+
+    ffStrbufAppendF(&requestData.cacheDir, "%u", requestData.logoPixelWidth);
+    ffStrbufAppendC(&requestData.cacheDir, '*');
+    ffStrbufAppendF(&requestData.cacheDir, "%u", requestData.logoPixelHeight);
+    ffStrbufAppendC(&requestData.cacheDir, '/');
+
+    if(!instance->config.recache && printCached(instance, &requestData))
+    {
+        ffStrbufDestroy(&requestData.cacheDir);
+        return true;
+    }
+
+    FFLogoImageResult result = FF_LOGO_IMAGE_RESULT_INIT_ERROR;
+
+    #ifdef FF_HAVE_IMAGEMAGICK7
+        result = ffLogoPrintImageIM7(instance, &requestData);
+    #endif
+
+    #ifdef FF_HAVE_IMAGEMAGICK6
+        if(result == FF_LOGO_IMAGE_RESULT_INIT_ERROR)
+            result = ffLogoPrintImageIM6(instance, &requestData);
+    #endif
+
+    ffStrbufDestroy(&requestData.cacheDir);
+    return result == FF_LOGO_IMAGE_RESULT_SUCCESS;
+}
+
+#else //FF_HAVE_IMAGEMAGICK{6, 7}
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type)
+{
+    FF_UNUSED(instance, type);
+    return false;
+}
+#endif //FF_HAVE_IMAGEMAGICK{6, 7}

src/logo/image/image.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#ifndef FF_INCLUDED_LOGO_SIXEL_sixel
+#define FF_INCLUDED_LOGO_SIXEL_sixel
+
+#include "../logo.h"
+
+#if defined(FF_HAVE_IMAGEMAGICK7) || defined(FF_HAVE_IMAGEMAGICK6)
+
+#define MAGICKCORE_HDRI_ENABLE 1
+#define MAGICKCORE_QUANTUM_DEPTH 16
+
+typedef enum FFLogoImageResult
+{
+    FF_LOGO_IMAGE_RESULT_SUCCESS,    //Logo printed
+    FF_LOGO_IMAGE_RESULT_INIT_ERROR, //Failed to load library, try again with next IM version
+    FF_LOGO_IMAGE_RESULT_RUN_ERROR   //Failed to load / convert image, cancle whole sixel code
+} FFLogoImageResult;
+
+typedef struct FFLogoRequestData
+{
+    FFLogoType type;
+    FFstrbuf cacheDir;
+
+    double characterPixelWidth;
+    double characterPixelHeight;
+
+    uint32_t logoPixelWidth;
+    uint32_t logoPixelHeight;
+
+    uint32_t logoCharacterHeight;
+    uint32_t logoCharacterWidth;
+} FFLogoRequestData;
+
+typedef struct FFIMData
+{
+    void* library;
+    void*(*resizeFunc)(const void* image, size_t width, size_t height, void* exceptionInfo);
+} FFIMData;
+
+FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData* requestData, const FFIMData* imData);
+
+#endif
+
+#ifdef FF_HAVE_IMAGEMAGICK7
+FFLogoImageResult ffLogoPrintImageIM7(FFinstance* instance, FFLogoRequestData* requestData);
+#endif
+
+#ifdef FF_HAVE_IMAGEMAGICK6
+#include <math.h>
+FFLogoImageResult ffLogoPrintImageIM6(FFinstance* instance, FFLogoRequestData* requestData);
+#endif
+
+#endif

src/logo/logo.c

@@ -0,0 +1,413 @@
+#include "logo.h"
+
+#include <ctype.h>
+#include <string.h>
+
+void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement)
+{
+    uint32_t currentlineLength = 0;
+
+    fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
+    ffPrintCharTimes(' ', instance->config.logoPaddingLeft);
+
+    //Use logoColor[0] as the default color
+    if(doColorReplacement)
+        ffPrintColor(&instance->config.logoColors[0]);
+
+    while(*data != '\0')
+    {
+        //We are at the end of a line. Print paddings and update max line length
+        if(*data == '\n' || (*data == '\r' && *(data + 1) == '\n'))
+        {
+            ffPrintCharTimes(' ', instance->config.logoPaddingRight);
+
+            //We have \r\n, skip the \r
+            if(*data == '\r')
+                ++data;
+
+            putchar('\n');
+            ++data;
+
+            ffPrintCharTimes(' ', instance->config.logoPaddingLeft);
+
+            if(currentlineLength > instance->state.logoWidth)
+                instance->state.logoWidth = currentlineLength;
+
+            currentlineLength = 0;
+            ++instance->state.logoHeight;
+            continue;
+        }
+
+        //Always print tabs as 4 spaces, to have consistent spacing
+        if(*data == '\t')
+        {
+            ffPrintCharTimes(' ', 4);
+            ++data;
+            continue;
+        }
+
+        //We have an escape sequence direclty as bytes. We print it, but don't increase the line length
+        if(*data == '\033' && *(data + 1) == '[')
+        {
+            const char* start = data;
+
+            fputs("\033[", stdout);
+            data += 2;
+
+            while(isdigit(*data) || *data == ';')
+                putchar(*data++); // number
+
+            //We have a valid control sequence, print it and continue with next char
+            if(isascii(*data))
+            {
+                putchar(*data++); // single letter, end of control sequence
+                continue;
+            }
+
+            //Invalid control sequence, try to get most accurate length
+            currentlineLength += (uint32_t) (data - start - 1); //-1 for \033 which for sure doesn't take any space
+
+            //Don't continue here, print the char after the letters with the unicode printing
+        }
+
+        //We have a fastfetch color placeholder. Replace it with the esacape sequence, don't increase the line length
+        if(doColorReplacement && *data == '$')
+        {
+            ++data;
+
+            //If we have $$, or $\0, print it as single $
+            if(*data == '$' || *data == '\0')
+            {
+                putchar('$');
+                ++currentlineLength;
+                ++data;
+                continue;
+            }
+
+            //Map the number to an array index, so that '1' -> 0, '2' -> 1, etc.
+            int index = ((int) *data) - 49;
+
+            //If the index is valid, print the color. Otherwise continue as normal
+            if(index < 0 || index >= FASTFETCH_LOGO_MAX_COLORS)
+            {
+                putchar('$');
+                ++currentlineLength;
+                //Don't continue here, we want to print the current char as unicode
+            }
+            else
+            {
+                ffPrintColor(&instance->config.logoColors[index]);
+                ++data;
+                continue;
+            }
+        }
+
+        //Do the printing, respecting unicode
+
+        ++currentlineLength;
+
+        int codepoint = (unsigned char) *data;
+        uint8_t bytes;
+
+        if(codepoint <= 127)
+            bytes = 1;
+        else if((codepoint & 0xE0) == 0xC0)
+            bytes = 2;
+        else if((codepoint & 0xF0) == 0xE0)
+            bytes = 3;
+        else if((codepoint & 0xF8) == 0xF0)
+            bytes = 4;
+        else
+            bytes = 1; //Invalid utf8, print it as is, byte by byte
+
+        for(uint8_t i = 0; i < bytes; ++i)
+        {
+            if(*data == '\0')
+                break;
+
+            putchar(*data++);
+        }
+    }
+
+    ffPrintCharTimes(' ', instance->config.logoPaddingRight);
+    fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+    //Happens if the last line is the longest
+    if(currentlineLength > instance->state.logoWidth)
+        instance->state.logoWidth = currentlineLength;
+
+    instance->state.logoWidth += instance->config.logoPaddingLeft + instance->config.logoPaddingRight;
+
+    //Go to the leftmost position
+    fputs("\033[9999999D", stdout);
+
+    //If the logo height is > 1, go up the height
+    if(instance->state.logoHeight > 0)
+        printf("\033[%uA", instance->state.logoHeight);
+}
+
+static void logoApplyMainColor(FFinstance* instance, const FFlogo* logo)
+{
+    if(instance->config.mainColor.length == 0)
+        ffStrbufAppendS(&instance->config.mainColor, logo->builtinColors[0]);
+}
+
+static bool logoHasName(const FFlogo* logo, const char* name)
+{
+    const char** logoName = logo->names;
+
+    while(*logoName != NULL)
+    {
+        if(strcasecmp(*logoName, name) == 0)
+            return true;
+        ++logoName;
+    }
+
+    return false;
+}
+
+static const FFlogo* logoGetBuiltin(const char* name)
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+
+        if(logoHasName(logo, name))
+            return logo;
+
+        ++methods;
+    }
+
+    return NULL;
+}
+
+static const FFlogo* logoGetBuiltinDetected(FFinstance* instance)
+{
+    const FFOSResult* os = ffDetectOS(instance);
+
+    const FFlogo* logo = logoGetBuiltin(os->id.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->name.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->prettyName.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->idLike.chars);
+    if(logo != NULL)
+        return logo;
+
+    logo = logoGetBuiltin(os->systemName.chars);
+    if(logo != NULL)
+        return logo;
+
+    return ffLogoBuiltinGetUnknown();
+}
+
+static inline void logoApplyMainColorDetected(FFinstance* instance)
+{
+    logoApplyMainColor(instance, logoGetBuiltinDetected(instance));
+}
+
+static void logoPrintStruct(FFinstance* instance, const FFlogo* logo)
+{
+    logoApplyMainColor(instance, logo);
+
+    const char** colors = logo->builtinColors;
+    for(int i = 0; *colors != NULL && i < FASTFETCH_LOGO_MAX_COLORS; i++, colors++)
+    {
+        if(instance->config.logoColors[i].length == 0)
+            ffStrbufAppendS(&instance->config.logoColors[i], *colors);
+    }
+
+    ffLogoPrintChars(instance, logo->data, true);
+}
+
+static bool logoPrintBuiltinIfExists(FFinstance* instance, const char* name)
+{
+    const FFlogo* logo = logoGetBuiltin(name);
+    if(logo == NULL)
+        return false;
+
+    logoPrintStruct(instance, logo);
+    return true;
+}
+
+static inline void logoPrintDetected(FFinstance* instance)
+{
+    logoPrintStruct(instance, logoGetBuiltinDetected(instance));
+}
+
+static bool logoPrintFileIfExists(FFinstance* instance, bool doColorReplacement)
+{
+    FFstrbuf content;
+    ffStrbufInitA(&content, 2047);
+
+    if(!ffAppendFileContent(instance->config.logoSource.chars, &content))
+    {
+        ffStrbufDestroy(&content);
+        return false;
+    }
+
+    logoApplyMainColorDetected(instance);
+    ffLogoPrintChars(instance, content.chars, doColorReplacement);
+    ffStrbufDestroy(&content);
+    return true;
+}
+
+static bool logoPrintImageIfExists(FFinstance* instance, FFLogoType logoType)
+{
+    if(!ffLogoPrintImageIfExists(instance, logoType))
+        return false;
+
+    logoApplyMainColorDetected(instance);
+    return true;
+}
+
+static void logoPrintKnownType(FFinstance* instance)
+{
+    bool successfull;
+
+    if(instance->config.logoType == FF_LOGO_TYPE_BUILTIN)
+        successfull = logoPrintBuiltinIfExists(instance, instance->config.logoSource.chars);
+    else if(instance->config.logoType == FF_LOGO_TYPE_FILE)
+        successfull = logoPrintFileIfExists(instance, true);
+    else if(instance->config.logoType == FF_LOGO_TYPE_RAW)
+        successfull = logoPrintFileIfExists(instance, false);
+    else //image
+        successfull = logoPrintImageIfExists(instance, instance->config.logoType);
+
+    if(!successfull)
+        logoPrintDetected(instance);
+}
+
+void ffLogoPrint(FFinstance* instance)
+{
+    //In pipe mode, we don't have a logo or padding.
+    //We also don't need to set main color, because it won't be printed anyway.
+    //So we can return quickly here.
+    if(instance->config.pipe)
+    {
+        instance->state.logoHeight = 0;
+        instance->state.logoWidth = 0;
+        return;
+    }
+
+    //If the source is not set, we can directly print the detected logo.
+    if(instance->config.logoSource.length == 0)
+    {
+        logoPrintDetected(instance);
+        return;
+    }
+
+    //If the source and source type is set to something else than auto, always print with the set type.
+    if(instance->config.logoSource.length > 0 && instance->config.logoType != FF_LOGO_TYPE_AUTO)
+    {
+        logoPrintKnownType(instance);
+        return;
+    }
+
+    //If source matches the name of a builtin logo, print it and return.
+    if(logoPrintBuiltinIfExists(instance, instance->config.logoSource.chars))
+        return;
+
+    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell(instance);
+
+    //Terminal emulators that support kitty graphics protocol.
+    bool supportsKitty =
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "kitty") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "konsole") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wezterm") == 0 ||
+        ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wayst") == 0;
+
+    //Try to load the logo as an image. If it succeeds, print it and return.
+    if(logoPrintImageIfExists(instance, supportsKitty ? FF_LOGO_TYPE_KITTY : FF_LOGO_TYPE_CHAFA))
+        return;
+
+    //Try to load the logo as a file. If it succeeds, print it and return.
+    if(logoPrintFileIfExists(instance, true))
+        return;
+
+    logoPrintDetected(instance);
+}
+
+void ffLogoPrintLine(FFinstance* instance)
+{
+    if(instance->state.logoWidth > 0)
+        printf("\033[%uC", instance->state.logoWidth);
+
+    ++instance->state.keysHeight;
+}
+
+void ffLogoPrintRemaining(FFinstance* instance)
+{
+    while(instance->state.keysHeight < instance->state.logoHeight)
+    {
+        ffLogoPrintLine(instance);
+        putchar('\n');
+    }
+}
+
+void ffLogoBuiltinPrint(FFinstance* instance)
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+        printf("\033[%sm%s:\033[0m\n", logo->builtinColors[0], logo->names[0]);
+        logoPrintStruct(instance, logo);
+        ffLogoPrintRemaining(instance);
+
+        //reset everything
+        instance->state.logoHeight = 0;
+        instance->state.keysHeight = 0;
+        for(uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++)
+            ffStrbufClear(&instance->config.logoColors[i]);
+
+        puts("\n");
+        ++methods;
+    }
+}
+
+void ffLogoBuiltinList()
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    uint32_t counter = 0;
+
+    while(*methods != NULL)
+    {
+        const FFlogo* logo = (*methods)();
+        const char** names = logo->names;
+
+        printf("%u)%s ", counter, counter < 10 ? " " : "");
+        ++counter;
+
+        while(*names != NULL)
+        {
+            printf("\"%s\" ", *names);
+            ++names;
+        }
+
+        putchar('\n');
+        ++methods;
+    }
+}
+
+void ffLogoBuiltinListAutocompletion()
+{
+    GetLogoMethod* methods = ffLogoBuiltinGetAll();
+
+    while(*methods != NULL)
+    {
+        printf("%s\n", (*methods)()->names[0]);
+        ++methods;
+    }
+}

src/logo/logo.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef FASTFETCH_INCLUDED_LOGO_logo
+#define FASTFETCH_INCLUDED_LOGO_logo
+
+#include "fastfetch.h"
+
+typedef struct FFlogo
+{
+    const char* data;
+    const char** names; //Null terminated
+    const char** builtinColors; //Null terminated
+} FFlogo;
+
+typedef const FFlogo*(*GetLogoMethod)();
+
+//logo.c
+void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement);
+
+//builtin.c
+const FFlogo* ffLogoBuiltinGetUnknown();
+GetLogoMethod* ffLogoBuiltinGetAll();
+
+//image/image.c
+bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type);
+
+#endif

src/modules/break.c

@@ -2,6 +2,6 @@
 
 void ffPrintBreak(FFinstance* instance)
 {
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
     putchar('\n');
 }

src/modules/colors.c

@@ -2,7 +2,16 @@
 
 void ffPrintColors(FFinstance* instance)
 {
-    ffPrintLogoLine(instance);
+    if(instance->config.pipe)
+    {
+        ffLogoPrintLine(instance);
+        puts("████████████████████████");
+        ffLogoPrintLine(instance);
+        puts("████████████████████████");
+        return;
+    }
+
+    ffLogoPrintLine(instance);
 
     // 4%d: Set the background color
     // 3%d: Set the foreground color
@@ -11,7 +20,7 @@ void ffPrintColors(FFinstance* instance)
 
     puts(FASTFETCH_TEXT_MODIFIER_RESET);
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     // 1: Set everything to bolt. This causes normal colors on some systems to be bright.
     // 4%d: Set the backgound to the not bright color

src/modules/cpu.c

@@ -42,7 +42,7 @@ void ffPrintCPU(FFinstance* instance)
     FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
     if(cpuinfo == NULL)
     {
-        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &instance->config.cpuKey, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS, "fopen(\"/proc/cpuinfo\", \"r\") == NULL");
+        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &instance->config.cpuKey, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS, "fopen(\"""/proc/cpuinfo\", \"r\") == NULL");
         return;
     }
 
@@ -68,11 +68,11 @@ void ffPrintCPU(FFinstance* instance)
             break;
 
         (void)(
-            ffGetPropValue(line, "model name :", &name) ||
-            ffGetPropValue(line, "vendor_id :", &vendor) ||
-            ffGetPropValue(line, "cpu cores :", &physicalCoresString) ||
-            ffGetPropValue(line, "cpu MHz :", &procGhzString) ||
-            (name.length == 0 && ffGetPropValue(line, "Hardware :", &name)) //For Android devices
+            ffParsePropLine(line, "model name :", &name) ||
+            ffParsePropLine(line, "vendor_id :", &vendor) ||
+            ffParsePropLine(line, "cpu cores :", &physicalCoresString) ||
+            ffParsePropLine(line, "cpu MHz :", &procGhzString) ||
+            (name.length == 0 && ffParsePropLine(line, "Hardware :", &name)) //For Android devices
         );
     }
 
@@ -164,7 +164,7 @@ void ffPrintCPU(FFinstance* instance)
     if(ghz > 0)
         ffStrbufAppendF(&cpu, " @ %.9gGHz", ghz);
 
-    ffPrintAndSaveToCache(instance, FF_CPU_MODULE_NAME, &instance->config.cpuKey, &cpu, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
+    ffPrintAndWriteToCache(instance, FF_CPU_MODULE_NAME, &instance->config.cpuKey, &cpu, &instance->config.cpuFormat, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
         {FF_FORMAT_ARG_TYPE_STRBUF, &name},
         {FF_FORMAT_ARG_TYPE_STRBUF, &namePretty},
         {FF_FORMAT_ARG_TYPE_STRBUF, &vendor},

src/modules/cpuUsage.c

@@ -12,7 +12,7 @@ void ffPrintCPUUsage(FFinstance* instance)
     FILE* procStat = fopen("/proc/stat", "r");
     if(procStat == NULL)
     {
-        ffPrintError(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpuUsageKey, &instance->config.cpuUsageFormat, FF_CPU_USAGE_NUM_FORMAT_ARGS, "fopen(\"/proc/stat\", \"r\") == NULL");
+        ffPrintError(instance, FF_CPU_USAGE_MODULE_NAME, 0, &instance->config.cpuUsageKey, &instance->config.cpuUsageFormat, FF_CPU_USAGE_NUM_FORMAT_ARGS, "fopen(\"""/proc/stat\", \"r\") == NULL");
         return;
     }
     if (fscanf(procStat, "cpu%ld%ld%ld%ld%ld%ld%ld", &user, &nice, &system, &idle, &iowait, &irq, &softirq) < 0) goto exit;

src/modules/cursor.c

@@ -147,7 +147,7 @@ static bool printCursorFromXDG(FFinstance* instance, bool user)
     if(user)
         ffParsePropFileHome(instance, ".icons/default/index.theme", "Inherits =", &theme);
     else
-        ffParsePropFile("/usr/share/icons/default/index.theme", "Inherits =", &theme);
+        ffParsePropFile(FASTFETCH_TARGET_DIR_USR"/share/icons/default/index.theme", "Inherits =", &theme);
 
     if(theme.length == 0)
     {

src/modules/disk.c

@@ -79,18 +79,17 @@ void ffPrintDisk(FFinstance* instance)
 {
     if(instance->config.diskFolders.length == 0)
     {
-
         struct statvfs fsRoot;
         int rootRet = statvfs("/", &fsRoot);
 
         struct statvfs fsHome;
-        int homeRet = statvfs("/home", &fsHome);
+        int homeRet = statvfs(FASTFETCH_TARGET_DIR_HOME, &fsHome);
 
         if(rootRet != 0 && homeRet != 0)
         {
             FF_STRBUF_CREATE(key);
             getKey(instance, &key, "", false);
-            ffPrintError(instance, key.chars, 0, NULL, &instance->config.diskFormat, FF_DISK_NUM_FORMAT_ARGS, "statvfs failed for both / and /home");
+            ffPrintError(instance, key.chars, 0, NULL, &instance->config.diskFormat, FF_DISK_NUM_FORMAT_ARGS, "statvfs failed for both / and " FASTFETCH_TARGET_DIR_HOME);
             ffStrbufDestroy(&key);
             return;
         }
@@ -99,7 +98,7 @@ void ffPrintDisk(FFinstance* instance)
             printStatvfsCreateKey(instance, "/", &fsRoot);
 
         if(homeRet == 0 && (rootRet != 0 || fsRoot.f_fsid != fsHome.f_fsid))
-            printStatvfsCreateKey(instance, "/home", &fsHome);
+            printStatvfsCreateKey(instance, FASTFETCH_TARGET_DIR_HOME, &fsHome);
     }
     else
     {

src/modules/font.c

@@ -43,7 +43,7 @@ void ffPrintFont(FFinstance* instance)
 
     FFstrbuf gtk;
     ffStrbufInitA(&gtk, 64);
-    ffGetGtkPretty(&gtk, &gtk2.pretty, &gtk3.pretty, &gtk4.pretty);
+    ffParseGTK(&gtk, &gtk2.pretty, &gtk3.pretty, &gtk4.pretty);
 
     if(instance->config.fontFormat.length == 0)
     {

src/modules/gpu.c

@@ -5,181 +5,7 @@
 #define FF_GPU_MODULE_NAME "GPU"
 #define FF_GPU_NUM_FORMAT_ARGS 5
 
-typedef struct GPUResult
-{
-    FFstrbuf vendor;
-    FFstrbuf name;
-    FFstrbuf driver;
-} GPUResult;
-
-#ifdef FF_HAVE_VULKAN
-#include <vulkan/vulkan.h>
-
-static void vulkanFillGPUs(FFinstance* instance, FFlist* results)
-{
-    FF_LIBRARY_LOAD(vulkan, instance->config.libVulkan, , "libvulkan.so", "libvulkan.so.1")
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkCreateInstance,)
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkDestroyInstance,)
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkEnumeratePhysicalDevices,)
-    FF_LIBRARY_LOAD_SYMBOL(vulkan, vkGetPhysicalDeviceProperties,)
-
-    //Some drivers (nvdc) print messages to stdout
-    //and thats the best way i found to disable that
-    ffSuppressIO(true);
-
-    const VkApplicationInfo applicationInfo = {
-        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-        .pNext = NULL,
-        .pApplicationName = FASTFETCH_PROJECT_NAME,
-        .applicationVersion = VK_MAKE_VERSION(FASTFETCH_PROJECT_VERSION_MAJOR, 0, 0),
-        .pEngineName = "vulkanPrintGPUs",
-        .engineVersion = VK_MAKE_VERSION(FASTFETCH_PROJECT_VERSION_MAJOR, 0, 0),
-        .apiVersion = VK_API_VERSION_1_0,
-    };
-
-    const VkInstanceCreateInfo instanceCreateInfo = {
-        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-        .pNext = NULL,
-        .pApplicationInfo = &applicationInfo,
-        .enabledLayerCount = 0,
-        .ppEnabledLayerNames = NULL,
-        .enabledExtensionCount = 0,
-        .ppEnabledExtensionNames = NULL,
-        .flags = 0
-    };
-
-    VkInstance vkInstance;
-    if(ffvkCreateInstance(&instanceCreateInfo, NULL, &vkInstance) != VK_SUCCESS)
-    {
-        dlclose(vulkan);
-        ffSuppressIO(false);
-        return;
-    }
-
-    uint32_t physicalDeviceCount;
-    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, NULL) != VK_SUCCESS)
-    {
-        ffvkDestroyInstance(vkInstance, NULL);
-        dlclose(vulkan);
-        ffSuppressIO(false);
-        return;
-    }
-
-    VkPhysicalDevice* physicalDevices = malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
-    if(ffvkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices) != VK_SUCCESS)
-    {
-        free(physicalDevices);
-        ffvkDestroyInstance(vkInstance, NULL);
-        dlclose(vulkan);
-        ffSuppressIO(false);
-        return;
-    }
-
-    for(uint32_t i = 0; i < physicalDeviceCount; i++)
-    {
-        VkPhysicalDeviceProperties physicalDeviceProperties;
-        ffvkGetPhysicalDeviceProperties(physicalDevices[i], &physicalDeviceProperties);
-
-        //We don't want softare rasterizers
-        if(physicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU)
-            continue;
-
-        GPUResult* result = ffListAdd(results);
-        ffStrbufInit(&result->vendor);
-        ffStrbufInit(&result->name);
-        ffStrbufInit(&result->driver);
-
-        ffStrbufAppendS(&result->name, physicalDeviceProperties.deviceName);
-    }
-
-    free(physicalDevices);
-    ffvkDestroyInstance(vkInstance, NULL);
-    dlclose(vulkan);
-    ffSuppressIO(false);
-    return;
-}
-
-#endif
-
-#ifdef FF_HAVE_LIBPCI
-#include <pci/pci.h>
-#include <unistd.h>
-
-//see https://github.com/pciutils/pciutils/blob/5bdf63b6b1bc35b59c4b3f47f7ca83ca1868155b/ls-kernel.c#L220
-static void pciGetDriver(struct pci_dev* dev, FFstrbuf* driver, char*(*ffpci_get_param)(struct pci_access*, char*))
-{
-    if(dev->access->method != PCI_ACCESS_SYS_BUS_PCI)
-        return;
-
-    const char* base = ffpci_get_param(dev->access, "sysfs.path");
-    if(!ffStrSet(base))
-        return;
-
-    FFstrbuf path;
-    ffStrbufInitA(&path, 64);
-    ffStrbufAppendF(&path, "%s/devices/%04x:%02x:%02x.%d/driver", base, dev->domain, dev->bus, dev->dev, dev->func);
-
-    ffStrbufEnsureFree(driver, 1023);
-    ssize_t resultLength = readlink(path.chars, driver->chars, driver->allocated - 1); //-1 for null terminator
-    if(resultLength > 0)
-    {
-        driver->length = (uint32_t) resultLength;
-        driver->chars[resultLength] = '\0';
-        ffStrbufSubstrAfterLastC(driver, '/');
-    }
-
-    ffStrbufDestroy(&path);
-}
-
-static void pciFillGPUs(FFinstance* instance, FFlist* results)
-{
-    FF_LIBRARY_LOAD(pci, instance->config.libPCI, , "libpci.so", "libpci.so.3")
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_alloc,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_init,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_scan_bus,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_fill_info,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_lookup_name,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_get_param,)
-    FF_LIBRARY_LOAD_SYMBOL(pci, pci_cleanup,)
-
-    struct pci_access *pacc = ffpci_alloc();
-    ffpci_init(pacc);
-    ffpci_scan_bus(pacc);
-
-    struct pci_dev* dev;
-    for (dev=pacc->devices; dev; dev=dev->next)
-    {
-        ffpci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_CLASS);
-        char class[1024];
-        ffpci_lookup_name(pacc, class, sizeof(class), PCI_LOOKUP_CLASS, dev->device_class);
-        if(
-            strcasecmp("VGA compatible controller", class) == 0 ||
-            strcasecmp("3D controller", class)             == 0 ||
-            strcasecmp("Display controller", class)        == 0
-        ) {
-            GPUResult* result = ffListAdd(results);
-
-            ffStrbufInitA(&result->vendor, 256);
-            ffpci_lookup_name(pacc, result->vendor.chars, (int) result->vendor.allocated -1, PCI_LOOKUP_VENDOR, dev->vendor_id, dev->device_id);
-            ffStrbufRecalculateLength(&result->vendor);
-
-            ffStrbufInitA(&result->name, 256);
-            ffpci_lookup_name(pacc, result->name.chars, (int) result->name.allocated - 1, PCI_LOOKUP_DEVICE, dev->vendor_id, dev->device_id);
-            ffStrbufRecalculateLength(&result->name);
-
-            ffStrbufInit(&result->driver);
-            if(instance->config.gpuFormat.length > 0) //We only need it for the format string, so don't detect it if it isn't needed
-                pciGetDriver(dev, &result->driver, ffpci_get_param);
-        };
-    }
-
-    ffpci_cleanup(pacc);
-    dlclose(pci);
-}
-
-#endif
-
-static void printGPUResult(FFinstance* instance, uint8_t index, FFcache* cache, GPUResult* result)
+static void printGPUResult(FFinstance* instance, uint8_t index, FFcache* cache, FFGPUResult* result)
 {
     const char* vendorPretty;
     if(ffStrbufIgnCaseCompS(&result->vendor, "Advanced Micro Devices, Inc. [AMD/ATI]") == 0)
@@ -222,32 +48,131 @@ static void printGPUResult(FFinstance* instance, uint8_t index, FFcache* cache,
     ffStrbufDestroy(&namePretty);
 }
 
+static void printGPUList(FFinstance* instance, const FFlist* list)
+{
+    FFcache cache;
+    ffCacheOpenWrite(instance, FF_GPU_MODULE_NAME, &cache);
+
+    for(uint8_t i = 0; i < (uint8_t) list->length; i++)
+        printGPUResult(instance, list->length == 1 ? 0 : (uint8_t) (i + 1), &cache, ffListGet(list, i));
+
+    ffCacheClose(&cache);
+}
+
+#ifdef FF_HAVE_LIBPCI
+#include <pci/pci.h>
+#include <unistd.h>
+
+//see https://github.com/pciutils/pciutils/blob/5bdf63b6b1bc35b59c4b3f47f7ca83ca1868155b/ls-kernel.c#L220
+static void pciGetDriver(struct pci_dev* dev, FFstrbuf* driver, char*(*ffpci_get_param)(struct pci_access*, char*))
+{
+    if(dev->access->method != PCI_ACCESS_SYS_BUS_PCI)
+        return;
+
+    const char* base = ffpci_get_param(dev->access, "sysfs.path");
+    if(!ffStrSet(base))
+        return;
+
+    FFstrbuf path;
+    ffStrbufInitA(&path, 64);
+    ffStrbufAppendF(&path, "%s/devices/%04x:%02x:%02x.%d/driver", base, dev->domain, dev->bus, dev->dev, dev->func);
+
+    ffStrbufEnsureFree(driver, 1023);
+    ssize_t resultLength = readlink(path.chars, driver->chars, driver->allocated - 1); //-1 for null terminator
+    if(resultLength > 0)
+    {
+        driver->length = (uint32_t) resultLength;
+        driver->chars[resultLength] = '\0';
+        ffStrbufSubstrAfterLastC(driver, '/');
+    }
+
+    ffStrbufDestroy(&path);
+}
+
+static bool pciPrintGPUs(FFinstance* instance)
+{
+    FF_LIBRARY_LOAD(pci, instance->config.libPCI, false, "libpci.so", 4)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_alloc, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_init, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_scan_bus, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_fill_info, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_lookup_name, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_get_param, false)
+    FF_LIBRARY_LOAD_SYMBOL(pci, pci_cleanup, false)
+
+    FFlist results;
+    ffListInit(&results, sizeof(FFGPUResult));
+
+    struct pci_access *pacc = ffpci_alloc();
+    ffpci_init(pacc);
+    ffpci_scan_bus(pacc);
+
+    struct pci_dev* dev;
+    for (dev=pacc->devices; dev; dev=dev->next)
+    {
+        ffpci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_CLASS);
+        char class[1024];
+        ffpci_lookup_name(pacc, class, sizeof(class), PCI_LOOKUP_CLASS, dev->device_class);
+        if(
+            strcasecmp("VGA compatible controller", class) == 0 ||
+            strcasecmp("3D controller", class)             == 0 ||
+            strcasecmp("Display controller", class)        == 0
+        ) {
+            FFGPUResult* result = ffListAdd(&results);
+
+            ffStrbufInitA(&result->vendor, 256);
+            ffpci_lookup_name(pacc, result->vendor.chars, (int) result->vendor.allocated -1, PCI_LOOKUP_VENDOR, dev->vendor_id, dev->device_id);
+            ffStrbufRecalculateLength(&result->vendor);
+
+            ffStrbufInitA(&result->name, 256);
+            ffpci_lookup_name(pacc, result->name.chars, (int) result->name.allocated - 1, PCI_LOOKUP_DEVICE, dev->vendor_id, dev->device_id);
+            ffStrbufRecalculateLength(&result->name);
+
+            ffStrbufInit(&result->driver);
+            if(instance->config.gpuFormat.length > 0) //We only need it for the format string, so don't detect it if it isn't needed
+                pciGetDriver(dev, &result->driver, ffpci_get_param);
+        };
+    }
+
+    ffpci_cleanup(pacc);
+    dlclose(pci);
+
+    if(results.length == 0)
+    {
+        ffListDestroy(&results);
+        return false;
+    }
+
+    printGPUList(instance, &results);
+
+    ffListDestroy(&results);
+    return true;
+}
+
+#endif
+
+static bool vulkanPrintGPUs(FFinstance* instance)
+{
+    const FFVulkanResult* result = ffDetectVulkan(instance);
+    if(result->devices.length == 0)
+        return false;
+
+    printGPUList(instance, &result->devices);
+    return true;
+}
+
 void ffPrintGPU(FFinstance* instance)
 {
     if(ffPrintFromCache(instance, FF_GPU_MODULE_NAME, &instance->config.gpuKey, &instance->config.gpuFormat, FF_GPU_NUM_FORMAT_ARGS))
         return;
 
-    FFlist gpus;
-    ffListInitA(&gpus, sizeof(GPUResult), 4);
-
-    FFcache cache;
-    ffCacheOpenWrite(instance, FF_GPU_MODULE_NAME, &cache);
-
     #ifdef FF_HAVE_LIBPCI
-        pciFillGPUs(instance, &gpus);
+        if(pciPrintGPUs(instance))
+            return;
     #endif
 
-    #ifdef FF_HAVE_VULKAN
-        if(gpus.length == 0)
-            vulkanFillGPUs(instance, &gpus);
-    #endif
+    if(vulkanPrintGPUs(instance))
+        return;
 
-    for(uint8_t i = 0; i < (uint8_t) gpus.length; i++)
-        printGPUResult(instance, gpus.length == 1 ? 0 : (uint8_t) (i + 1), &cache, ffListGet(&gpus, i));
-
-    if(gpus.length == 0)
-        ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &instance->config.gpuKey, &instance->config.gpuFormat, FF_GPU_NUM_FORMAT_ARGS, "No GPUs found.");
-
-    ffCacheClose(&cache);
-    ffListDestroy(&gpus);
+    ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &instance->config.gpuKey, &instance->config.gpuFormat, FF_GPU_NUM_FORMAT_ARGS, "No GPUs found.");
 }

src/modules/host.c

@@ -119,7 +119,7 @@ void ffPrintHost(FFinstance* instance)
         ffStrbufAppend(&host, &version);
     }
 
-    ffPrintAndSaveToCache(instance, FF_HOST_MODULE_NAME, &instance->config.hostKey, &host, &instance->config.hostFormat, FF_HOST_NUM_FORMAT_ARGS, (FFformatarg[]) {
+    ffPrintAndWriteToCache(instance, FF_HOST_MODULE_NAME, &instance->config.hostKey, &host, &instance->config.hostFormat, FF_HOST_NUM_FORMAT_ARGS, (FFformatarg[]) {
         {FF_FORMAT_ARG_TYPE_STRBUF, &family},
         {FF_FORMAT_ARG_TYPE_STRBUF, &name},
         {FF_FORMAT_ARG_TYPE_STRBUF, &version}

src/modules/icons.c

@@ -30,7 +30,7 @@ void ffPrintIcons(FFinstance* instance)
     }
 
     FF_STRBUF_CREATE(gtkPretty);
-    ffGetGtkPretty(&gtkPretty, gtk2, gtk3, gtk4);
+    ffParseGTK(&gtkPretty, gtk2, gtk3, gtk4);
 
     if(instance->config.iconsFormat.length == 0)
     {

src/modules/locale.c

@@ -28,10 +28,20 @@ void ffPrintLocale(FFinstance* instance)
 	FFstrbuf locale;
     ffStrbufInit(&locale);
 
-    ffParsePropFile("/etc/locale.conf", "LANG =", &locale);
+    //Ubuntu (and deriviates) use a non standard locale file.
+    //Parse it first, because on distributions where it exists, it takes precedence.
+    //Otherwise use the standard /etc/locale.conf file.
+    ffParsePropFile(FASTFETCH_TARGET_DIR_ROOT"/etc/default/locale", "LANG =", &locale);
 
-	if (locale.length == 0)
+    if(locale.length == 0)
+    {
+        ffParsePropFile(FASTFETCH_TARGET_DIR_ROOT"/etc/locale.conf", "LANG =", &locale);
+    }
+
+	if(locale.length == 0)
+    {
         getLocaleFromEnv(&locale);
+    }
 
     if(locale.length == 0)
     {
@@ -39,7 +49,7 @@ void ffPrintLocale(FFinstance* instance)
         return;
     }
 
-    ffPrintAndSaveToCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.localeKey, &locale, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
+    ffPrintAndWriteToCache(instance, FF_LOCALE_MODULE_NAME, &instance->config.localeKey, &locale, &instance->config.localeFormat, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
         {FF_FORMAT_ARG_TYPE_STRBUF, &locale}
     });
 

src/modules/memory.c

@@ -8,7 +8,7 @@ void ffPrintMemory(FFinstance* instance)
 {
     FILE* meminfo = fopen("/proc/meminfo", "r");
     if(meminfo == NULL) {
-        ffPrintError(instance, FF_MEMORY_MODULE_NAME, 0, &instance->config.memoryKey, &instance->config.memoryFormat, FF_MEMORY_NUM_FORMAT_ARGS, "fopen(\"/proc/meminfo\", \"r\") == NULL");
+        ffPrintError(instance, FF_MEMORY_MODULE_NAME, 0, &instance->config.memoryKey, &instance->config.memoryFormat, FF_MEMORY_NUM_FORMAT_ARGS, "fopen(\"""/proc/meminfo\", \"r\") == NULL");
         return;
     }
 

src/modules/opencl.c

@@ -0,0 +1,91 @@
+#include "fastfetch.h"
+
+#define FF_OPENCL_MODULE_NAME "OpenCL"
+#define FF_OPENCL_NUM_FORMAT_ARGS 3
+
+#ifdef FF_HAVE_OPENCL
+#define CL_TARGET_OPENCL_VERSION 100
+#include <CL/cl.h>
+
+typedef struct OpenCLData
+{
+    FF_LIBRARY_SYMBOL(clGetPlatformIDs);
+    FF_LIBRARY_SYMBOL(clGetDeviceIDs);
+    FF_LIBRARY_SYMBOL(clGetDeviceInfo);
+} OpenCLData;
+
+static const char* openCLHandelData(FFinstance* instance, OpenCLData* data)
+{
+    cl_platform_id platformID;
+    cl_uint numPlatforms;
+    data->ffclGetPlatformIDs(1, &platformID, &numPlatforms);
+
+    if(numPlatforms == 0)
+        return "clGetPlatformIDs returned 0 platforms";
+
+    cl_device_id deviceID;
+    cl_uint numDevices;
+    data->ffclGetDeviceIDs(platformID, CL_DEVICE_TYPE_GPU, 1, &deviceID, &numDevices);
+
+    if(numDevices == 0)
+        data->ffclGetDeviceIDs(platformID, CL_DEVICE_TYPE_ALL, 1, &deviceID, &numDevices);
+
+    if(numDevices == 0)
+        return "clGetDeviceIDs returned 0 devices";
+
+    char version[64];
+    data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VERSION, sizeof(version), version, NULL);
+    if(!ffStrSet(version))
+        return "clGetDeviceInfo returned NULL or empty string";
+
+    char device[128];
+    data->ffclGetDeviceInfo(deviceID, CL_DEVICE_NAME, sizeof(device), device, NULL);
+
+    char vendor[32];
+    data->ffclGetDeviceInfo(deviceID, CL_DEVICE_VENDOR, sizeof(vendor), vendor, NULL);
+
+    if(instance->config.openCLFormat.length == 0)
+    {
+        ffPrintLogoAndKey(instance, FF_OPENCL_MODULE_NAME, 0, &instance->config.openCLKey);
+        puts(version);
+    }
+    else
+    {
+        ffPrintFormatString(instance, FF_OPENCL_MODULE_NAME, 0, &instance->config.openCLKey, &instance->config.openCLFormat, NULL, FF_OPENCL_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            {FF_FORMAT_ARG_TYPE_STRING, version},
+            {FF_FORMAT_ARG_TYPE_STRING, device},
+            {FF_FORMAT_ARG_TYPE_STRING, vendor}
+        });
+    }
+
+    return NULL;
+}
+
+static const char* printOpenCL(FFinstance* instance)
+{
+    OpenCLData data;
+
+    FF_LIBRARY_LOAD(opencl, instance->config.libOpenCL, "dlopen libOpenCL.so failed", "libOpenCL.so", 1);
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(opencl, data.ffclGetPlatformIDs, clGetPlatformIDs, "dlsym clGetPlatformIDs failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(opencl, data.ffclGetDeviceIDs, clGetDeviceIDs, "dlsym clGetDeviceIDs failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(opencl, data.ffclGetDeviceInfo, clGetDeviceInfo, "dlsym clGetDeviceInfo failed");
+
+    const char* error = openCLHandelData(instance, &data);
+    dlclose(opencl);
+    return error;
+}
+#endif
+
+void ffPrintOpenCL(FFinstance* instance)
+{
+    const char* error;
+
+    #ifdef FF_HAVE_OPENCL
+        error = printOpenCL(instance);
+    #else
+        error = "Fastfetch was build without OpenCL support";
+    #endif
+
+    if(error != NULL)
+        ffPrintError(instance, FF_OPENCL_MODULE_NAME, 0, &instance->config.openCLKey, &instance->config.openCLFormat, FF_OPENCL_NUM_FORMAT_ARGS, error);
+}

src/modules/opengl.c

@@ -0,0 +1,392 @@
+#include "fastfetch.h"
+
+#include <string.h>
+
+#define FF_OPENGL_MODULE_NAME "OpenGL"
+#define FF_OPENGL_NUM_FORMAT_ARGS 4
+
+#if defined(FF_HAVE_EGL) || defined(FF_HAVE_GLX) || defined(FF_HAVE_OSMESA)
+#define FF_HAVE_GL 1
+#include <GL/gl.h>
+
+#define FF_OPENGL_BUFFER_WIDTH 1
+#define FF_OPENGL_BUFFER_HEIGHT 1
+
+typedef struct GLData
+{
+    FF_LIBRARY_SYMBOL(glGetString);
+} GLData;
+
+static const char* glHandlePrint(FFinstance* instance, const GLData* data)
+{
+    const char* version = (const char*) data->ffglGetString(GL_VERSION);
+    if(!ffStrSet(version))
+        return "glGetString(GL_VERSION) returned NULL";
+
+    const char* renderer = (const char*) data->ffglGetString(GL_RENDERER);
+    const char* vendor = (const char*) data->ffglGetString(GL_VENDOR);
+    const char* slv = (const char*) data->ffglGetString(GL_SHADING_LANGUAGE_VERSION);
+
+    if(instance->config.openGLFormat.length == 0)
+    {
+        ffPrintLogoAndKey(instance, FF_OPENGL_MODULE_NAME, 0, &instance->config.openGLKey);
+        puts(version);
+    }
+    else
+    {
+        ffPrintFormatString(instance, FF_OPENGL_MODULE_NAME, 0, &instance->config.openGLKey, &instance->config.openGLFormat, NULL, FF_OPENGL_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            {FF_FORMAT_ARG_TYPE_STRING, version},
+            {FF_FORMAT_ARG_TYPE_STRING, renderer},
+            {FF_FORMAT_ARG_TYPE_STRING, vendor},
+            {FF_FORMAT_ARG_TYPE_STRING, slv}
+        });
+    }
+
+    return NULL;
+}
+
+#ifdef FF_HAVE_EGL
+#include <EGL/egl.h>
+
+typedef struct EGLData
+{
+    GLData glData;
+
+    FF_LIBRARY_SYMBOL(eglGetProcAddress);
+    FF_LIBRARY_SYMBOL(eglGetDisplay);
+    FF_LIBRARY_SYMBOL(eglInitialize);
+    FF_LIBRARY_SYMBOL(eglBindAPI);
+    FF_LIBRARY_SYMBOL(eglGetConfigs);
+    FF_LIBRARY_SYMBOL(eglCreatePbufferSurface);
+    FF_LIBRARY_SYMBOL(eglCreateContext);
+    FF_LIBRARY_SYMBOL(eglMakeCurrent);
+    FF_LIBRARY_SYMBOL(eglDestroyContext);
+    FF_LIBRARY_SYMBOL(eglDestroySurface);
+    FF_LIBRARY_SYMBOL(eglTerminate);
+
+    EGLDisplay display;
+    EGLConfig config;
+    EGLSurface surface;
+    EGLContext context;
+} EGLData;
+
+static const char* eglHandleContext(FFinstance* instance, EGLData* data)
+{
+    if(data->ffeglMakeCurrent(data->display, data->surface, data->surface, data->context) != EGL_TRUE)
+        return "eglMakeCurrent returned EGL_FALSE";
+
+    return glHandlePrint(instance, &data->glData);
+}
+
+static const char* eglHandleSurface(FFinstance* instance, EGLData* data)
+{
+    data->context = data->ffeglCreateContext(data->display, data->config, EGL_NO_CONTEXT, (EGLint[]){EGL_NONE});
+    if(data->context == EGL_NO_CONTEXT)
+        return "eglCreateContext returned EGL_NO_CONTEXT";
+
+    const char* error = eglHandleContext(instance, data);
+    data->ffeglDestroyContext(data->display, data->context);
+    return error;
+}
+
+static const char* eglHandleDisplay(FFinstance* instance, EGLData* data)
+{
+    if(data->ffeglBindAPI(EGL_OPENGL_API) != EGL_TRUE)
+        return "eglBindAPI returned EGL_FALSE";
+
+    EGLint eglConfigCount;
+    data->ffeglGetConfigs(data->display, &data->config, 1, &eglConfigCount);
+    if(eglConfigCount == 0)
+        return "eglGetConfigs returned 0 configs";
+
+    data->surface = data->ffeglCreatePbufferSurface(data->display, data->config, (EGLint[]){
+        EGL_WIDTH, FF_OPENGL_BUFFER_WIDTH,
+        EGL_HEIGHT, FF_OPENGL_BUFFER_HEIGHT,
+        EGL_NONE
+    });
+
+    if(data->surface == EGL_NO_SURFACE)
+        return "eglCreatePbufferSurface returned EGL_NO_SURFACE";
+
+    const char* error = eglHandleSurface(instance, data);
+    data->ffeglDestroySurface(data->display, data->surface);
+    return error;
+}
+
+static const char* eglHandleData(FFinstance* instance, EGLData* data)
+{
+    data->glData.ffglGetString = (__typeof__(data->glData.ffglGetString)) data->ffeglGetProcAddress("glGetString");
+    if(!data->glData.ffglGetString)
+        return "eglGetProcAddress(glGetString) returned NULL";
+
+    data->display = data->ffeglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if(data->display == EGL_NO_DISPLAY)
+        return "eglGetDisplay returned EGL_NO_DISPLAY";
+
+    EGLint major, minor;
+    if(data->ffeglInitialize(data->display, &major, &minor) == EGL_FALSE)
+        return "eglInitialize returned EGL_FALSE";
+
+    const char* error = eglHandleDisplay(instance, data);
+    data->ffeglTerminate(data->display);
+    return error;
+}
+
+static const char* eglPrint(FFinstance* instance)
+{
+    EGLData eglData;
+
+    FF_LIBRARY_LOAD(egl, instance->config.libEGL, "dlopen egl failed", "libEGL.so", 1);
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglGetProcAddress, eglGetProcAddress, "dlsym eglGetProcAddress failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglGetDisplay, eglGetDisplay, "dlsym eglGetDisplay failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglInitialize, eglInitialize, "dlsym eglInitialize failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglBindAPI, eglBindAPI, "dlsym eglBindAPI failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglGetConfigs, eglGetConfigs, "dlsym eglGetConfigs failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglCreatePbufferSurface, eglCreatePbufferSurface, "dlsym eglCreatePbufferSurface failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglCreateContext, eglCreateContext, "dlsym eglCreateContext failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglMakeCurrent, eglMakeCurrent, "dlsym eglMakeCurrent failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglDestroyContext, eglDestroyContext, "dlsym eglDestroyContext failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglDestroySurface, eglDestroySurface, "dlsym eglDestroySurface failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(egl, eglData.ffeglTerminate, eglTerminate, "dlsym eglTerminate failed");
+
+    const char* error = eglHandleData(instance, &eglData);
+    dlclose(egl);
+    return error;
+}
+
+#endif //FF_HAVE_EGL
+
+#ifdef FF_HAVE_GLX
+#include <GL/glx.h>
+
+typedef struct GLXData
+{
+    GLData glData;
+
+    FF_LIBRARY_SYMBOL(glXGetProcAddress);
+    FF_LIBRARY_SYMBOL(XOpenDisplay);
+    FF_LIBRARY_SYMBOL(glXChooseVisual);
+    FF_LIBRARY_SYMBOL(XCreatePixmap);
+    FF_LIBRARY_SYMBOL(glXCreateGLXPixmap);
+    FF_LIBRARY_SYMBOL(glXCreateContext);
+    FF_LIBRARY_SYMBOL(glXMakeCurrent);
+    FF_LIBRARY_SYMBOL(glXDestroyContext);
+    FF_LIBRARY_SYMBOL(glXDestroyGLXPixmap);
+    FF_LIBRARY_SYMBOL(XFreePixmap);
+    FF_LIBRARY_SYMBOL(XCloseDisplay);
+
+    Display* display;
+    XVisualInfo* visualInfo;
+    Pixmap pixmap;
+    GLXPixmap glxPixmap;
+    GLXContext context;
+} GLXData;
+
+static const char* glxHandleContext(FFinstance* instance, GLXData* data)
+{
+    if(data->ffglXMakeCurrent(data->display, data->glxPixmap, data->context) != True)
+        return "glXMakeCurrent returned False";
+
+    return glHandlePrint(instance, &data->glData);
+}
+
+static const char* glxHandleGLXPixmap(FFinstance* instance, GLXData* data)
+{
+    data->context = data->ffglXCreateContext(data->display, data->visualInfo, NULL, True);
+    if(data->context == NULL)
+        return "glXCreateContext returned NULL";
+
+    const char* error = glxHandleContext(instance, data);
+    data->ffglXDestroyContext(data->display, data->context);
+    return error;
+}
+
+static const char* glxHandlePixmap(FFinstance* instance, GLXData* data)
+{
+    data->glxPixmap = data->ffglXCreateGLXPixmap(data->display, data->visualInfo, data->pixmap);
+    if(data->glxPixmap == None)
+        return "glXCreateGLXPixmap returned None";
+
+    const char* error = glxHandleGLXPixmap(instance, data);
+    data->ffglXDestroyGLXPixmap(data->display, data->glxPixmap);
+    return error;
+}
+
+static const char* glxHandleVisualInfo(FFinstance* instance, GLXData* data)
+{
+    data->pixmap = data->ffXCreatePixmap(data->display, DefaultRootWindow(data->display), FF_OPENGL_BUFFER_WIDTH, FF_OPENGL_BUFFER_HEIGHT, (unsigned int) data->visualInfo->depth);
+    if(data->pixmap == None)
+        return "XCreatePixmap returned None";
+
+    const char* error = glxHandlePixmap(instance, data);
+    data->ffXFreePixmap(data->display, data->pixmap);
+    return error;
+}
+
+static const char* glxHandleDisplay(FFinstance* instance, GLXData* data)
+{
+    data->visualInfo = data->ffglXChooseVisual(data->display, DefaultScreen(data->display), (int[]){None});
+    if(data->visualInfo == NULL)
+        return "glXChooseVisual returned NULL";
+
+    return glxHandleVisualInfo(instance, data);
+}
+
+static const char* glxHandleData(FFinstance* instance, GLXData* data)
+{
+    data->glData.ffglGetString = (__typeof__(data->glData.ffglGetString)) data->ffglXGetProcAddress((const GLubyte*) "glGetString");
+    if(data->glData.ffglGetString == NULL)
+        return "glXGetProcAddress(glGetString) returned NULL";
+
+    data->display = data->ffXOpenDisplay(NULL);
+    if(data->display == NULL)
+        return "XOpenDisplay returned NULL";
+
+    const char* error = glxHandleDisplay(instance, data);
+    data->ffXCloseDisplay(data->display);
+    return error;
+}
+
+static const char* glxPrint(FFinstance* instance)
+{
+    GLXData data;
+
+    FF_LIBRARY_LOAD(glx, instance->config.libGLX, "dlopen glx failed", "libGLX.so", 1);
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffglXGetProcAddress, glXGetProcAddress, "dlsym glXGetProcAddress failed");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffXOpenDisplay, XOpenDisplay, "dlsym XOpenDisplay returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffglXChooseVisual, glXChooseVisual, "dlsym glXChooseVisual returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffXCreatePixmap, XCreatePixmap, "dlsym XCreatePixmap returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffglXCreateGLXPixmap, glXCreateGLXPixmap, "dlsym glXCreateGLXPixmap returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffglXCreateContext, glXCreateContext, "dlsym glXCreateContext returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffglXMakeCurrent, glXMakeCurrent, "dlsym glXMakeCurrent returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffglXDestroyContext, glXDestroyContext, "dlsym glXDestroyContext returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffglXDestroyGLXPixmap, glXDestroyGLXPixmap, "dlsym glXDestroyGLXPixmap returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffXFreePixmap, XFreePixmap, "dlsym XFreePixmap returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(glx, data.ffXCloseDisplay, XCloseDisplay, "dlsym XCloseDisplay returned NULL");
+
+    const char* error = glxHandleData(instance, &data);
+    dlclose(glx);
+    return error;
+}
+
+#endif //FF_HAVE_GLX
+
+#ifdef FF_HAVE_OSMESA
+#include <GL/osmesa.h>
+
+typedef struct OSMesaData
+{
+    GLData glData;
+
+    FF_LIBRARY_SYMBOL(OSMesaGetProcAddress);
+    FF_LIBRARY_SYMBOL(OSMesaCreateContext);
+    FF_LIBRARY_SYMBOL(OSMesaMakeCurrent);
+    FF_LIBRARY_SYMBOL(OSMesaDestroyContext);
+
+    OSMesaContext context;
+} OSMesaData;
+
+static const char* osMesaHandleContext(FFinstance* instance, OSMesaData* data)
+{
+    unsigned char buffer[FF_OPENGL_BUFFER_WIDTH * FF_OPENGL_BUFFER_HEIGHT * sizeof(uint32_t)]; // 4 bytes per pixel (RGBA)
+
+    if(data->ffOSMesaMakeCurrent(data->context, buffer, GL_UNSIGNED_BYTE, FF_OPENGL_BUFFER_WIDTH, FF_OPENGL_BUFFER_HEIGHT) != GL_TRUE)
+        return "OSMesaMakeCurrent returned GL_FALSE";
+
+    return glHandlePrint(instance, &data->glData);
+}
+
+static const char* osMesaHandleData(FFinstance* instance, OSMesaData* data)
+{
+    //The case to void* is required here, because OSMESAproc can't be cast to (__typeof__(data->glData.ffglGetString)) without a warning, even though it is the actual type.
+    data->glData.ffglGetString = (__typeof__(data->glData.ffglGetString)) (void*) data->ffOSMesaGetProcAddress("glGetString");
+    if(data->glData.ffglGetString == NULL)
+        return "OSMesaGetProcAddress(glGetString) returned NULL";
+
+    data->context = data->ffOSMesaCreateContext(OSMESA_RGBA, NULL);
+    if(data->context == NULL)
+        return "OSMesaCreateContext returned NULL";
+
+    const char* error = osMesaHandleContext(instance, data);
+    data->ffOSMesaDestroyContext(data->context);
+    return error;
+}
+
+static const char* osMesaPrint(FFinstance* instance)
+{
+    OSMesaData data;
+
+    FF_LIBRARY_LOAD(osmesa, instance->config.libOSMesa, "dlopen osmesa failed", "libOSMesa.so", 8);
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(osmesa, data.ffOSMesaGetProcAddress, OSMesaGetProcAddress, "dlsym OSMesaGetProcAddress returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(osmesa, data.ffOSMesaCreateContext, OSMesaCreateContext, "dlsym OSMesaCreateContext returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(osmesa, data.ffOSMesaMakeCurrent, OSMesaMakeCurrent, "dlsym OSMesaMakeCurrent returned NULL");
+    FF_LIBRARY_LOAD_SYMBOL_ADRESS(osmesa, data.ffOSMesaDestroyContext, OSMesaDestroyContext, "dlsym OSMesaDestroyContext returned NULL");
+
+    const char* error = osMesaHandleData(instance, &data);
+    dlclose(osmesa);
+    return error;
+}
+
+#endif //FF_HAVE_OSMESA
+
+static const char* glPrint(FFinstance* instance)
+{
+    if(instance->config.glType == FF_GL_TYPE_GLX)
+    {
+        #ifdef FF_HAVE_GLX
+            return glxPrint(instance);
+        #else
+            return "fastfetch was compiled without glx support";
+        #endif
+    }
+
+    if(instance->config.glType == FF_GL_TYPE_EGL)
+    {
+        #ifdef FF_HAVE_EGL
+            return eglPrint(instance);
+        #else
+            return "fastfetch was compiled without egl support";
+        #endif
+    }
+
+    if(instance->config.glType == FF_GL_TYPE_OSMESA)
+    {
+        #ifdef FF_HAVE_OSMESA
+            return osMesaPrint(instance);
+        #else
+            return "fastfetch was compiled without osmesa support";
+        #endif
+    }
+
+    const char* error = ""; // not NULL dummy value
+
+    #ifdef FF_HAVE_EGL
+        error = eglPrint(instance);
+    #endif
+
+    #ifdef FF_HAVE_GLX
+        if(error != NULL)
+            error = glxPrint(instance);
+    #endif
+
+    //We don't use osmesa in auto mode here, because it is a software implementation,
+    //that doesn't reflect the opengl supported by the hardware
+
+    return error;
+}
+
+#endif // FF_HAVE_GL
+
+void ffPrintOpenGL(FFinstance* instance)
+{
+    const char* error;
+
+    #ifndef FF_HAVE_GL
+        error = "Fastfetch was built without gl support.";
+    #else
+       error = glPrint(instance);
+    #endif
+
+    if(error != NULL)
+        ffPrintError(instance, FF_OPENGL_MODULE_NAME, 0, &instance->config.openGLKey, &instance->config.openGLFormat, FF_OPENGL_NUM_FORMAT_ARGS, error);
+}

src/modules/os.c

@@ -5,9 +5,6 @@
 
 void ffPrintOS(FFinstance* instance)
 {
-    if(ffPrintFromCache(instance, FF_OS_MODULE_NAME, &instance->config.osKey, &instance->config.osFormat, FF_OS_NUM_FORMAT_ARGS))
-        return;
-
     const FFOSResult* result = ffDetectOS(instance);
 
     if(result->name.length == 0 && result->prettyName.length == 0)
@@ -69,20 +66,28 @@ void ffPrintOS(FFinstance* instance)
         ffStrbufAppendC(&os, ']');
     }
 
-    ffPrintAndSaveToCache(instance, FF_OS_MODULE_NAME, &instance->config.osKey, &os, &instance->config.osFormat, FF_OS_NUM_FORMAT_ARGS, (FFformatarg[]){
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->systemName},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->name},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->prettyName},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->id},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->idLike},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->variant},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->variantID},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->version},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->versionID},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->codename},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->buildID},
-        {FF_FORMAT_ARG_TYPE_STRBUF, &result->architecture}
-    });
+    if(instance->config.osFormat.length == 0)
+    {
+        ffPrintLogoAndKey(instance, FF_OS_MODULE_NAME, 0, &instance->config.osKey);
+        ffStrbufPutTo(&os, stdout);
+    }
+    else
+    {
+        ffPrintFormatString(instance, FF_OS_MODULE_NAME, 0, &instance->config.osKey, &instance->config.osFormat, NULL, FF_OS_NUM_FORMAT_ARGS, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->systemName},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->name},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->prettyName},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->id},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->idLike},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->variant},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->variantID},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->version},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->versionID},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->codename},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->buildID},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &result->architecture}
+        });
+    }
 
     ffStrbufDestroy(&os);
 }

src/modules/packages.c

@@ -4,45 +4,21 @@
 #include <dirent.h>
 
 #define FF_PACKAGES_MODULE_NAME "Packages"
-#define FF_PACKAGES_NUM_FORMAT_ARGS 9
+#define FF_PACKAGES_NUM_FORMAT_ARGS 11
 
-#ifdef FF_HAVE_RPM
-#include <rpm/rpmlib.h>
-#include <rpm/rpmts.h>
-#include <rpm/rpmdb.h>
-#include <rpm/rpmlog.h>
-
-static uint32_t getRpmPackageCount(FFinstance* instance)
+typedef struct PackageCounts
 {
-    FF_LIBRARY_LOAD(rpm, instance->config.librpm, 0, "librpm.so", "librpm.so.4")
-    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmReadConfigFiles, 0)
-    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsCreate, 0)
-    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsInitIterator, 0)
-    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmdbGetIteratorCount, 0)
-    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmdbFreeIterator, 0)
-    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsFree, 0)
-    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmlogSetMask, 0)
+    uint32_t pacman;
+    uint32_t dpkg;
+    uint32_t rpm;
+    uint32_t emerge;
+    uint32_t xbps;
+    uint32_t nixDefault;
+    uint32_t flatpak;
+    uint32_t snap;
 
-    // Don't print any error messages
-    ffrpmlogSetMask(RPMLOG_MASK(RPMLOG_EMERG));
-
-    uint32_t count = 0;
-    rpmts ts = NULL;
-    rpmdbMatchIterator mi = NULL;
-
-    if (ffrpmReadConfigFiles(NULL, NULL)) goto exit;
-    if (!(ts = ffrpmtsCreate())) goto exit;
-    if (!(mi = ffrpmtsInitIterator(ts, RPMDBI_LABEL, NULL, 0))) goto exit;
-    count = (uint32_t) ffrpmdbGetIteratorCount(mi);
-
-exit:
-    if (mi) ffrpmdbFreeIterator(mi);
-    if (ts) ffrpmtsFree(ts);
-    dlclose(rpm);
-    return count;
-}
-
-#endif
+    FFstrbuf pacmanBranch;
+} PackageCounts;
 
 static uint32_t getNumElements(const char* dirname, unsigned char type)
 {
@@ -126,78 +102,236 @@ static uint32_t countFilesRecursive(FFstrbuf* baseDirPath, const char* filename)
     return sum;
 }
 
-static uint32_t countFilesIn(const char* dirname, const char* filename)
+static uint32_t getNixPackages(char* path)
 {
-    FFstrbuf baseDirPath;
-    ffStrbufInitA(&baseDirPath, 128);
-    ffStrbufAppendS(&baseDirPath, dirname);
-    uint32_t result = countFilesRecursive(&baseDirPath, filename);
-    ffStrbufDestroy(&baseDirPath);
+    //Nix detection is kinda slow, so we only do it if the dir exists
+    if(!ffFileExists(path, S_IFDIR))
+        return 0;
+
+    FFstrbuf output;
+    ffStrbufInitA(&output, 128);
+
+    ffProcessAppendStdOut(&output, (char* const[]) {
+        "nix-store",
+        "-qR",
+        path,
+        NULL
+    });
+
+    //Each package is a new line in the output. If at least one line is found, add 1 for the last line.
+    uint32_t result = ffStrbufCountC(&output, '\n');
+    if(result > 0)
+        result++;
+
+    ffStrbufDestroy(&output);
     return result;
 }
 
+#ifdef FF_HAVE_RPM
+#include <rpm/rpmlib.h>
+#include <rpm/rpmts.h>
+#include <rpm/rpmdb.h>
+#include <rpm/rpmlog.h>
+
+static uint32_t getRpmFromLibrpm(const FFinstance* instance)
+{
+    FF_LIBRARY_LOAD(rpm, instance->config.librpm, 0, "librpm.so", 12)
+    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmReadConfigFiles, 0)
+    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsCreate, 0)
+    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsInitIterator, 0)
+    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmdbGetIteratorCount, 0)
+    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmdbFreeIterator, 0)
+    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsFree, 0)
+    FF_LIBRARY_LOAD_SYMBOL(rpm, rpmlogSetMask, 0)
+
+    // Don't print any error messages
+    ffrpmlogSetMask(RPMLOG_MASK(RPMLOG_EMERG));
+
+    if(ffrpmReadConfigFiles(NULL, NULL) != 0)
+    {
+        dlclose(rpm);
+        return 0;
+    }
+
+    rpmts ts = ffrpmtsCreate();
+    if(ts == NULL)
+    {
+        dlclose(rpm);
+        return 0;
+    }
+
+    rpmdbMatchIterator mi = ffrpmtsInitIterator(ts, RPMDBI_LABEL, NULL, 0);
+    if(mi == NULL)
+    {
+        ffrpmtsFree(ts);
+        dlclose(rpm);
+        return 0;
+    }
+
+    int count = ffrpmdbGetIteratorCount(mi);
+
+    ffrpmdbFreeIterator(mi);
+    ffrpmtsFree(ts);
+    dlclose(rpm);
+
+    return count > 0 ? (uint32_t) count : 0;
+}
+#endif
+
+static void getPackageCounts(const FFinstance* instance, FFstrbuf* baseDir, PackageCounts* packageCounts)
+{
+    uint32_t baseDirLength = baseDir->length;
+
+    //pacman
+    ffStrbufAppendS(baseDir, "/var/lib/pacman/local");
+    packageCounts->pacman += getNumElements(baseDir->chars, DT_DIR);
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //dpkg
+    ffStrbufAppendS(baseDir, "/var/lib/dpkg/status");
+    packageCounts->dpkg += getNumStrings(baseDir->chars, "Status: ");
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //rpm
+    ffStrbufAppendS(baseDir, "/var/lib/rpm/rmpdb.sqlite");
+    packageCounts->rpm += (uint32_t) ffSettingsGetSQLite3Int(instance, baseDir->chars, "SELECT count(blob) FROM Packages");
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //emerge
+    ffStrbufAppendS(baseDir, "/var/db/pkg");
+    packageCounts->emerge += countFilesRecursive(baseDir, "SIZE");
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //xps
+    ffStrbufAppendS(baseDir, "/var/db/xbps");
+    packageCounts->xbps += getNumElements(baseDir->chars, DT_REG);
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //flatpak
+    ffStrbufAppendS(baseDir, "/var/lib/flatpak/app");
+    packageCounts->flatpak += getNumElements(baseDir->chars, DT_DIR);
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //nix default
+    ffStrbufAppendS(baseDir, "/var/nix/profiles/default");
+    packageCounts->nixDefault += getNixPackages(baseDir->chars);
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //snap
+    ffStrbufAppendS(baseDir, "/snap");
+    uint32_t snap = getNumElements(baseDir->chars, DT_DIR);
+    if(snap > 0)
+        packageCounts->snap += (snap - 1); //Accounting for the /snap/bin folder
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+
+    //pacman branch
+    ffStrbufAppendS(baseDir, "/etc/pacman-mirrors.conf");
+    if(ffParsePropFile(baseDir->chars, "Branch =", &packageCounts->pacmanBranch) && packageCounts->pacmanBranch.length == 0)
+        ffStrbufAppendS(&packageCounts->pacmanBranch, "stable");
+    ffStrbufSubstrBefore(baseDir, baseDirLength);
+}
+
+static void getPackageCountsBedrock(const FFinstance* instance, FFstrbuf* baseDir, PackageCounts* packageCounts)
+{
+    ffStrbufAppendS(baseDir, "/bedrock/strata");
+
+    DIR* dir = opendir(baseDir->chars);
+    if(dir == NULL)
+        return;
+
+    ffStrbufAppendC(baseDir, '/');
+
+    uint32_t baseDirLength = baseDir->length;
+
+    struct dirent* entry;
+    while((entry = readdir(dir)) != NULL)
+    {
+        if(entry->d_type != DT_DIR)
+            continue;
+
+        ffStrbufAppendS(baseDir, entry->d_name);
+        getPackageCounts(instance, baseDir, packageCounts);
+        ffStrbufSubstrBefore(baseDir, baseDirLength);
+    }
+
+    closedir(dir);
+}
+
 void ffPrintPackages(FFinstance* instance)
 {
-    uint32_t pacman = getNumElements("/var/lib/pacman/local", DT_DIR);
-    uint32_t dpkg = getNumStrings("/var/lib/dpkg/status", "Status: ");
+    PackageCounts counts = {0};
+    ffStrbufInit(&counts.pacmanBranch);
 
-    #if __ANDROID__
-        dpkg += getNumStrings("/data/data/com.termux/files/usr/var/lib/dpkg/status", "Status: ");
-    #endif
+    FFstrbuf baseDir;
+    ffStrbufInitA(&baseDir, 512);
+    ffStrbufAppendS(&baseDir, FASTFETCH_TARGET_DIR_ROOT);
 
+    if(ffStrbufIgnCaseCompS(&ffDetectOS(instance)->id, "bedrock") == 0)
+        getPackageCountsBedrock(instance, &baseDir, &counts);
+    else
+        getPackageCounts(instance, &baseDir, &counts);
+
+    // If SQL failed, we can still try with librpm.
+    // This is needed on openSUSE, which seems to use a proprietary database file
+    // This method doesn't work on bedrock, so we do it here.
     #ifdef FF_HAVE_RPM
-        uint32_t rpm = getRpmPackageCount(instance);
-    #else
-        uint32_t rpm = 0;
+        if(counts.rpm == 0)
+            counts.rpm = getRpmFromLibrpm(instance);
     #endif
 
-    uint32_t emerge = countFilesIn("/var/db/pkg", "SIZE");
-    uint32_t xbps = getNumElements("/var/db/xbps", DT_REG);
-    uint32_t flatpak = getNumElements("/var/lib/flatpak/app", DT_DIR);
-    uint32_t snap = getNumElements("/snap", DT_DIR);
+    //nix user
+    ffStrbufSetS(&baseDir, instance->state.passwd->pw_dir);
+    ffStrbufAppendS(&baseDir, "/.nix-profile");
+    uint32_t nixUser = getNixPackages(baseDir.chars);
 
-    //Accounting for the /snap/bin folder
-    if(snap > 0)
-        --snap;
-
-    uint32_t all = pacman + dpkg + rpm + emerge + xbps + flatpak + snap;
+    ffStrbufDestroy(&baseDir);
 
+    uint32_t all = counts.dpkg + counts.emerge + counts.flatpak + counts.nixDefault + nixUser + counts.pacman + counts.rpm + counts.snap + counts.xbps;
     if(all == 0)
     {
         ffPrintError(instance, FF_PACKAGES_MODULE_NAME, 0, &instance->config.packagesKey, &instance->config.packagesFormat, FF_PACKAGES_NUM_FORMAT_ARGS, "No packages from known package managers found");
         return;
     }
 
-    FFstrbuf manjaroBranch;
-    ffStrbufInit(&manjaroBranch);
-    if(ffParsePropFile("/etc/pacman-mirrors.conf", "Branch =", &manjaroBranch) && manjaroBranch.length == 0)
-        ffStrbufSetS(&manjaroBranch, "stable");
-
     if(instance->config.packagesFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_PACKAGES_MODULE_NAME, 0, &instance->config.batteryKey);
+        ffPrintLogoAndKey(instance, FF_PACKAGES_MODULE_NAME, 0, &instance->config.packagesKey);
 
         #define FF_PRINT_PACKAGE(name) \
-        if(name > 0) \
+        if(counts.name > 0) \
         { \
-            printf("%u ("#name")", name); \
-            if((all = all - name) > 0) \
+            printf("%u ("#name")", counts.name); \
+            if((all = all - counts.name) > 0) \
                 printf(", "); \
         };
 
-        if(pacman > 0)
+        if(counts.pacman > 0)
         {
-            printf("%u (pacman)", pacman);
-            if(manjaroBranch.length > 0)
-                printf("[%s]", manjaroBranch.chars);
-            if((all = all - pacman) > 0)
+            printf("%u (pacman)", counts.pacman);
+            if(counts.pacmanBranch.length > 0)
+                printf("[%s]", counts.pacmanBranch.chars);
+            if((all = all - counts.pacman) > 0)
                 printf(", ");
         };
 
         FF_PRINT_PACKAGE(dpkg)
         FF_PRINT_PACKAGE(rpm)
         FF_PRINT_PACKAGE(emerge)
-        FF_PRINT_PACKAGE(xbps)
+
+        if(nixUser > 0)
+        {
+            printf("%u (nix-user)", nixUser);
+            if((all = all - nixUser) > 0)
+                printf(", ");
+        }
+
+        if(counts.nixDefault > 0)
+        {
+            printf("%u (nix-default)", counts.nixDefault);
+            if((all = all - counts.nixDefault) > 0)
+                printf(", ");
+        }
+
         FF_PRINT_PACKAGE(flatpak)
         FF_PRINT_PACKAGE(snap)
 
@@ -212,16 +346,18 @@ void ffPrintPackages(FFinstance* instance)
     {
         ffPrintFormatString(instance, FF_PACKAGES_MODULE_NAME, 0, &instance->config.packagesKey, &instance->config.packagesFormat, NULL, FF_PACKAGES_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_UINT, &all},
-            {FF_FORMAT_ARG_TYPE_UINT, &pacman},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &manjaroBranch},
-            {FF_FORMAT_ARG_TYPE_UINT, &dpkg},
-            {FF_FORMAT_ARG_TYPE_UINT, &rpm},
-            {FF_FORMAT_ARG_TYPE_UINT, &emerge},
-            {FF_FORMAT_ARG_TYPE_UINT, &xbps},
-            {FF_FORMAT_ARG_TYPE_UINT, &flatpak},
-            {FF_FORMAT_ARG_TYPE_UINT, &snap}
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.pacman},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &counts.pacmanBranch},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.dpkg},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.rpm},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.emerge},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.xbps},
+            {FF_FORMAT_ARG_TYPE_UINT, &nixUser},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.nixDefault},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.flatpak},
+            {FF_FORMAT_ARG_TYPE_UINT, &counts.snap}
         });
     }
 
-    ffStrbufDestroy(&manjaroBranch);
+    ffStrbufDestroy(&counts.pacmanBranch);
 }

src/modules/player.c

@@ -1,5 +1,7 @@
 #include "fastfetch.h"
 
+#include <ctype.h>
+
 #define FF_PLAYER_MODULE_NAME "Media Player"
 #define FF_PLAYER_NUM_FORMAT_ARGS 3
 
@@ -13,15 +15,50 @@ void ffPrintPlayer(FFinstance* instance)
         return;
     }
 
+    FFstrbuf playerPretty;
+    ffStrbufInit(&playerPretty);
+
+    //If we are on a website, prepend the website name
+    if(ffStrbufStartsWithS(&media->url, "https://www."))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 12);
+    else if(ffStrbufStartsWithS(&media->url, "http://www."))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 11);
+    else if(ffStrbufStartsWithS(&media->url, "https://"))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 8);
+    else if(ffStrbufStartsWithS(&media->url, "http://"))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 7);
+
+    //If we found a website name, make it more pretty
+    if(playerPretty.length > 0)
+    {
+        ffStrbufSubstrBeforeFirstC(&playerPretty, '/'); //Remove the path
+        ffStrbufSubstrBeforeLastC(&playerPretty, '.'); //Remove the TLD
+    }
+
+    //Check again for length, as we may have removed everything.
+    bool playerPrettyIsCustom = playerPretty.length > 0;
+
+    //If we don't have subdomains, it is usually more pretty to capitalize the first letter.
+    if(playerPrettyIsCustom && ffStrbufFirstIndexC(&playerPretty, '.') == playerPretty.length)
+        playerPretty.chars[0] = (char) toupper(playerPretty.chars[0]);
+
+    if(playerPrettyIsCustom)
+        ffStrbufAppendS(&playerPretty, " (");
+
+    ffStrbufAppend(&playerPretty, &media->player);
+
+    if(playerPrettyIsCustom)
+        ffStrbufAppendC(&playerPretty, ')');
+
     if(instance->config.playerFormat.length == 0)
     {
         ffPrintLogoAndKey(instance, FF_PLAYER_MODULE_NAME, 0, &instance->config.playerKey);
-        ffStrbufPutTo(&media->playerPretty, stdout);
+        ffStrbufPutTo(&playerPretty, stdout);
     }
     else
     {
         ffPrintFormatString(instance, FF_PLAYER_MODULE_NAME, 0, &instance->config.playerKey, &instance->config.playerFormat, NULL, FF_PLAYER_NUM_FORMAT_ARGS, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_STRBUF, &media->playerPretty},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &playerPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->player},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->busNameShort}
         });

src/modules/separator.c

@@ -5,7 +5,7 @@ void ffPrintSeparator(FFinstance* instance)
     const FFTitleResult* result = ffDetectTitle(instance);
     uint32_t titleLength = result->userName.length + 1 + result->hostname.length;
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     if(instance->config.separatorString.length == 0)
     {

src/modules/song.c

@@ -1,7 +1,44 @@
 #include "fastfetch.h"
 
+#include <ctype.h>
+
 #define FF_SONG_MODULE_NAME "Song"
-#define FF_SONG_NUM_FORMAT_ARGS 4
+#define FF_SONG_NUM_FORMAT_ARGS 5
+
+static bool shouldIgoreChar(char c)
+{
+    return isblank(c) || c == '-' || c == '.';
+}
+
+static bool artistInSongTitle(const FFstrbuf* song, const FFstrbuf* artist)
+{
+    uint32_t artistIndex = 0;
+    uint32_t songIndex = 0;
+
+    while(true)
+    {
+        while(shouldIgoreChar(song->chars[songIndex]))
+            ++songIndex;
+
+        while(shouldIgoreChar(artist->chars[artistIndex]))
+            ++artistIndex;
+
+        if(artist->chars[artistIndex] == '\0')
+            return true;
+
+        if(song->chars[songIndex] == '\0')
+            return false;
+
+        if(tolower(song->chars[songIndex]) != tolower(artist->chars[artistIndex]))
+            return false;
+
+        ++artistIndex;
+        ++songIndex;
+    }
+
+    //Unreachable
+    return false;
+}
 
 void ffPrintSong(FFinstance* instance)
 {
@@ -13,27 +50,56 @@ void ffPrintSong(FFinstance* instance)
         return;
     }
 
+    FFstrbuf songPretty;
+    ffStrbufInitCopy(&songPretty, &media->song);
+    const char* removeStrings[] = {
+        "(Official Music Video)", "(Official Video)", "(Music Video)",
+        "[Official Music Video]", "[Official Video]", "[Music Video]",
+        "| Official Music Video", "| Official Video", "| Music Video",
+        "[Official Audio]", "[Audio]", "(Audio)", "| Official Audio", "| Audio", "| OFFICIAL AUDIO",
+        "(Lyric Video)", "(Official Lyric Video)", "(Lyrics)",
+        "[Lyric Video]", "[Official Lyric Video]", "[Lyrics]",
+        "| Lyric Video", "| Official Lyric Video", "| Lyrics",
+    };
+    ffStrbufRemoveStringsA(&songPretty, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
+    ffStrbufTrimRight(&songPretty, ' ');
+
+    if(songPretty.length == 0)
+        ffStrbufAppend(&songPretty, &media->song);
+
     if(instance->config.songFormat.length == 0)
     {
+        //We don't expose artistPretty to the format, as it might be empty (when the think that the artist is already in the song title)
+        FFstrbuf artistPretty;
+        ffStrbufInitCopy(&artistPretty, &media->artist);
+        ffStrbufRemoveIgnCaseEndS(&artistPretty, " - Topic");
+        ffStrbufRemoveIgnCaseEndS(&artistPretty, "VEVO");
+        ffStrbufTrimRight(&artistPretty, ' ');
+
+        if(artistInSongTitle(&songPretty, &artistPretty))
+            ffStrbufClear(&artistPretty);
+
         ffPrintLogoAndKey(instance, FF_SONG_MODULE_NAME, 0, &instance->config.songKey);
 
-        if(media->artist.length > 0)
+        if(artistPretty.length > 0)
         {
-            ffStrbufWriteTo(&media->artist, stdout);
+            ffStrbufWriteTo(&artistPretty, stdout);
             fputs(" - ", stdout);
         }
 
-        if(media->album.length > 0)
+        //Some sites (e.g. reddit) expose their url as album. We don't want to show that
+        if(media->album.length > 0 && !ffStrbufStartsWithIgnCaseS(&media->album, "http"))
         {
             ffStrbufWriteTo(&media->album, stdout);
             fputs(" - ", stdout);
         }
 
-        ffStrbufPutTo(&media->song, stdout);
+        ffStrbufPutTo(&songPretty, stdout);
     }
     else
     {
         ffPrintFormatString(instance, FF_SONG_MODULE_NAME, 0, &instance->config.songKey, &instance->config.songFormat, NULL, FF_SONG_NUM_FORMAT_ARGS, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_STRBUF, &songPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->song},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->artist},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->album},

src/modules/terminalfont.c

@@ -184,7 +184,7 @@ static void printTTY(FFinstance* instance)
     FFstrbuf fontName;
     ffStrbufInit(&fontName);
 
-    ffParsePropFile("/etc/vconsole.conf", "Font =", &fontName);
+    ffParsePropFile(FASTFETCH_TARGET_DIR_ROOT"/etc/vconsole.conf", "Font =", &fontName);
 
     if(fontName.length == 0)
     {

src/modules/theme.c

@@ -38,7 +38,7 @@ void ffPrintTheme(FFinstance* instance)
     ffStrbufTrim(&plasmaColorPretty, ' ');
 
     FF_STRBUF_CREATE(gtkPretty);
-    ffGetGtkPretty(&gtkPretty, gtk2, gtk3, gtk4);
+    ffParseGTK(&gtkPretty, gtk2, gtk3, gtk4);
 
     if(instance->config.themeFormat.length == 0)
     {

src/modules/title.c

@@ -30,17 +30,23 @@ const FFTitleResult* ffDetectTitle(FFinstance* instance)
 
 static inline void printTitlePart(FFinstance* instance, const FFstrbuf* content)
 {
-    fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-    ffPrintColor(&instance->config.color);
+    if(!instance->config.pipe)
+    {
+        fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
+        ffPrintColor(&instance->config.mainColor);
+    }
+
     ffStrbufWriteTo(content, stdout);
-    fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+    if(!instance->config.pipe)
+        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 }
 
 void ffPrintTitle(FFinstance* instance)
 {
     const FFTitleResult* result = ffDetectTitle(instance);
 
-    ffPrintLogoLine(instance);
+    ffLogoPrintLine(instance);
 
     printTitlePart(instance, &result->userName);
     putchar('@');

src/modules/uptime.c

@@ -17,17 +17,43 @@ void ffPrintUptime(FFinstance* instance)
         if(days == 0 && hours == 0 && minutes == 0)
         {
             printf("%u seconds\n", seconds);
+            return;
         }
-        else
+
+        if(days > 0)
         {
-            if(days > 0)
-                printf("%u day%s%s, ", days, days <= 1 ? "" : "s", days < 100 ? "" : "(!)");
-            if(hours > 0)
-                printf("%u hour%s, ", hours, hours <= 1 ? "" : "s");
-            if(minutes > 0)
-                printf("%u min%s", minutes, minutes <= 1 ? "" : "s");
-            putchar('\n');
+            printf("%u day", days);
+
+            if(days > 1)
+                putchar('s');
+
+            if(days >= 100)
+                fputs("(!)", stdout);
+
+            if(hours > 0 || minutes > 0)
+                fputs(", ", stdout);
         }
+
+        if(hours > 0)
+        {
+            printf("%u hour", hours);
+
+            if(hours > 1)
+                putchar('s');
+
+            if(minutes > 0)
+                fputs(", ", stdout);
+        }
+
+        if(minutes > 0)
+        {
+            printf("%u min", minutes);
+
+            if(minutes > 1)
+                putchar('s');
+        }
+
+        putchar('\n');
     }
     else
     {

src/modules/vulkan.c

@@ -0,0 +1,41 @@
+#include "fastfetch.h"
+
+#define FF_VULKAN_MODULE_NAME "Vulkan"
+#define FF_VULKAN_NUM_FORMAT_ARGS 3
+
+void ffPrintVulkan(FFinstance* instance)
+{
+    const FFVulkanResult* vulkan = ffDetectVulkan(instance);
+
+    if(vulkan->apiVersion.length == 0 && vulkan->driver.length == 0)
+    {
+        ffPrintError(instance, FF_VULKAN_MODULE_NAME, 0, &instance->config.vulkanKey, &instance->config.vulkanFormat, FF_VULKAN_NUM_FORMAT_ARGS, "Failed to detect vulkan");
+        return;
+    }
+
+    if(instance->config.vulkanFormat.length == 0)
+    {
+        ffPrintLogoAndKey(instance, FF_VULKAN_MODULE_NAME, 0, &instance->config.vulkanKey);
+
+        if(vulkan->driver.length > 0)
+        {
+            printf("%s (driver)", vulkan->driver.chars);
+
+            if(vulkan->apiVersion.length > 0)
+                fputs(", ", stdout);
+        }
+
+        if(vulkan->apiVersion.length > 0)
+            printf("%s (api version)", vulkan->apiVersion.chars);
+
+        putchar('\n');
+    }
+    else
+    {
+        ffPrintFormatString(instance, FF_VULKAN_MODULE_NAME, 0, &instance->config.vulkanKey, &instance->config.vulkanFormat, NULL, FF_VULKAN_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            {FF_FORMAT_ARG_TYPE_STRBUF, &vulkan->driver},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &vulkan->apiVersion},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &vulkan->conformanceVersion}
+        });
+    }
+}

src/util/FFstrbuf.c

@@ -29,31 +29,12 @@ void ffStrbufInitCopy(FFstrbuf* strbuf, const FFstrbuf* src)
     ffStrbufAppend(strbuf, src);
 }
 
-static void setCapacity(FFstrbuf* strbuf, uint32_t capacity)
+uint32_t ffStrbufGetFree(const FFstrbuf* strbuf)
 {
     if(strbuf->allocated == 0)
-    {
-        strbuf->chars = malloc(sizeof(*strbuf->chars) * capacity);
-        strbuf->chars[0] = '\0';
-    }
-    else
-        strbuf->chars = realloc(strbuf->chars, sizeof(*strbuf->chars) * capacity);
+        return 0;
 
-    strbuf->allocated = capacity;
-}
-
-void ffStrbufEnsureCapacity(FFstrbuf* strbuf, uint32_t capacity)
-{
-    if(strbuf->allocated > capacity || capacity == 0)
-        return;
-
-    if(capacity == UINT32_MAX)
-    {
-        fputs("Warning: ffStrbufEnsureCapacity called with UINT32_MAX. Highest allowed value is UINT32_MAX - 1. Exiting.\n", stderr);
-        exit(812);
-    }
-
-    setCapacity(strbuf, capacity + 1); // + 1 for the null byte
+    return strbuf->allocated - strbuf->length - 1; // - 1 for the null byte
 }
 
 void ffStrbufEnsureFree(FFstrbuf* strbuf, uint32_t free)
@@ -68,15 +49,15 @@ void ffStrbufEnsureFree(FFstrbuf* strbuf, uint32_t free)
     while((strbuf->length + free + 1) > allocate) // + 1 for the null byte
         allocate *= 2;
 
-    setCapacity(strbuf, allocate);
-}
-
-uint32_t ffStrbufGetFree(const FFstrbuf* strbuf)
-{
     if(strbuf->allocated == 0)
-        return 0;
+    {
+        strbuf->chars = malloc(sizeof(*strbuf->chars) * allocate);
+        strbuf->chars[0] = '\0';
+    }
+    else
+        strbuf->chars = realloc(strbuf->chars, sizeof(*strbuf->chars) * allocate);
 
-    return strbuf->allocated - strbuf->length - 1; // - 1 for the null byte
+    strbuf->allocated = allocate;
 }
 
 void ffStrbufClear(FFstrbuf* strbuf)
@@ -495,6 +476,17 @@ bool ffStrbufEndsWithS(const FFstrbuf* strbuf, const char* end)
     return true;
 }
 
+uint32_t ffStrbufCountC(const FFstrbuf* strbuf, char c)
+{
+    uint32_t result = 0;
+    for(uint32_t i = 0; i < strbuf->length; i++)
+    {
+        if(strbuf->chars[i] == c)
+            result++;
+    }
+    return result;
+}
+
 static bool testEndsWithIgnCaseS(const FFstrbuf* strbuf, const char* end, uint32_t* endLength)
 {
     *endLength = (uint32_t) strlen(end);

src/util/FFstrbuf.h

@@ -23,7 +23,6 @@ void ffStrbufInit(FFstrbuf* strbuf);
 void ffStrbufInitA(FFstrbuf* strbuf, uint32_t allocate);
 void ffStrbufInitCopy(FFstrbuf* strbuf, const FFstrbuf* src);
 
-void ffStrbufEnsureCapacity(FFstrbuf* strbuf, uint32_t capacity);
 void ffStrbufEnsureFree(FFstrbuf* strbuf, uint32_t free);
 
 uint32_t ffStrbufGetFree(const FFstrbuf* strbuf);
@@ -87,6 +86,8 @@ bool ffStrbufStartsWithIgnCaseS(const FFstrbuf* strbuf, const char* start);
 bool ffStrbufEndsWithC(const FFstrbuf* strbuf, char c);
 bool ffStrbufEndsWithS(const FFstrbuf* strbuf, const char* end);
 
+uint32_t ffStrbufCountC(const FFstrbuf* strbuf, char c);
+
 bool ffStrbufRemoveIgnCaseEndS(FFstrbuf* strbuf, const char* end);
 
 void ffStrbufWriteTo(const FFstrbuf* strbuf, FILE* file);

tests/performance.c

@@ -25,12 +25,6 @@ int main(int argc, char** argv)
         ffInitInstance(&instance);
     )
 
-    FASTFETCH_TEST_PERFORMANCE(
-        puts("Configuration");
-        ffLoadLogo(&instance);
-    )
-
-    ffStrbufSet(&instance.config.color, &instance.config.logoColors[0]);
     instance.config.showErrors = true;
     instance.config.recache = argc == 1;
     instance.config.cacheSave = false;
@@ -41,6 +35,11 @@ int main(int argc, char** argv)
         ffStartDetectionThreads(&instance);
     )
 
+    FASTFETCH_TEST_PERFORMANCE(
+        puts("Starting");
+        ffStart(&instance);
+    )
+
     FASTFETCH_TEST_PERFORMANCE(ffPrintTitle(&instance))
     FASTFETCH_TEST_PERFORMANCE(ffPrintSeparator(&instance))
     FASTFETCH_TEST_PERFORMANCE(ffPrintOS(&instance))
@@ -74,5 +73,10 @@ int main(int argc, char** argv)
     FASTFETCH_TEST_PERFORMANCE(ffPrintBreak(&instance))
     FASTFETCH_TEST_PERFORMANCE(ffPrintColors(&instance))
 
+    FASTFETCH_TEST_PERFORMANCE(
+        puts("Finishing");
+        ffFinish(&instance);
+    )
+
     return 0;
 }