Global: make FFinstance instance a global variable

As discussed in https://github.com/fastfetch-cli/fastfetch/discussions/473

src/common/bar.c

@@ -3,7 +3,7 @@
 
 // green, yellow, red: print the color on nth (0~9) block
 // set its value == 10 means the color will not be printed
-void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red)
+void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red)
 {
     assert(green <= 10 && yellow <= 10 && red <= 10);
 
@@ -15,14 +15,14 @@ void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
     percent = (uint8_t)(percent + 5) / 10;
     assert(percent <= 10);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         ffStrbufAppendS(buffer, "\033[97m[ ");
     else
         ffStrbufAppendS(buffer, "[ ");
 
     for (uint8_t i = 0; i < percent; ++i)
     {
-        if(!instance->config.pipe)
+        if(!instance.config.pipe)
         {
             if (i == green)
                 ffStrbufAppendS(buffer, "\033[32m");
@@ -36,13 +36,13 @@ void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
 
     if (percent < 10)
     {
-        if(!instance->config.pipe)
+        if(!instance.config.pipe)
             ffStrbufAppendS(buffer, "\033[97m");
         for (uint8_t i = percent; i < 10; ++i)
             ffStrbufAppendS(buffer, "-");
     }
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         ffStrbufAppendS(buffer, "\033[97m ]" FASTFETCH_TEXT_MODIFIER_RESET);
     else
         ffStrbufAppendS(buffer, " ]");
@@ -57,16 +57,16 @@ void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
 // [green, 100]: print green
 // [yellow, green): print yellow
 // [0, yellow): PRINT RED
-void ffAppendPercentNum(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses)
+void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses)
 {
     assert(green <= 100 && yellow <= 100);
 
-    bool colored = !!(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
+    bool colored = !!(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
 
     if (parentheses)
         ffStrbufAppendC(buffer, '(');
 
-    if (colored && !instance->config.pipe)
+    if (colored && !instance.config.pipe)
     {
         if(green < yellow)
         {
@@ -89,7 +89,7 @@ void ffAppendPercentNum(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
     }
     ffStrbufAppendF(buffer, "%u%%", (unsigned) percent);
 
-    if (colored && !instance->config.pipe)
+    if (colored && !instance.config.pipe)
     {
         ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
     }

src/common/bar.h

@@ -13,7 +13,7 @@ enum
     FF_PERCENTAGE_TYPE_NUM_COLOR_BIT = 1 << 3,
 };
 
-void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red);
-void ffAppendPercentNum(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses);
+void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red);
+void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses);
 
 #endif

src/common/dbus.c

@@ -5,9 +5,9 @@
 #include "common/thread.h"
 #include "util/stringUtils.h"
 
-static bool loadLibSymbols(const FFinstance* instance, FFDBusLibrary* lib)
+static bool loadLibSymbols(FFDBusLibrary* lib)
 {
-    FF_LIBRARY_LOAD(dbus, &instance->config.libDBus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_LOAD(dbus, &instance.config.libDBus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_bus_get, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_new_method_call, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_init, false)
@@ -28,7 +28,7 @@ static bool loadLibSymbols(const FFinstance* instance, FFDBusLibrary* lib)
     return true;
 }
 
-static const FFDBusLibrary* loadLib(const FFinstance* instance)
+static const FFDBusLibrary* loadLib(void)
 {
     static FFDBusLibrary lib;
     static bool loaded = false;
@@ -40,16 +40,16 @@ static const FFDBusLibrary* loadLib(const FFinstance* instance)
     if(!loaded)
     {
         loaded = true;
-        loadSuccess = loadLibSymbols(instance, &lib);
+        loadSuccess = loadLibSymbols(&lib);
     }
 
     ffThreadMutexUnlock(&mutex);
     return loadSuccess ? &lib : NULL;
 }
 
-const char* ffDBusLoadData(const FFinstance* instance, DBusBusType busType, FFDBusData* data)
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data)
 {
-    data->lib = loadLib(instance);
+    data->lib = loadLib();
     if(data->lib == NULL)
         return "Failed to load DBus library";
 

src/common/dbus.h

@@ -45,7 +45,7 @@ typedef struct FFDBusData
     DBusConnection* connection;
 } FFDBusData;
 
-const char* ffDBusLoadData(const FFinstance* instance, DBusBusType busType, FFDBusData* data); //Returns an error message or NULL on success
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data); //Returns an error message or NULL on success
 bool ffDBusGetValue(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result);
 bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result);
 bool ffDBusGetByte(FFDBusData* dbus, DBusMessageIter* iter, uint8_t* result);

src/common/init.c

@@ -17,6 +17,8 @@
 
 #include "modules/modules.h"
 
+FFinstance instance; // Global singleton
+
 static void initState(FFstate* state)
 {
     state->logoWidth = 0;
@@ -28,119 +30,119 @@ static void initState(FFstate* state)
     state->configDoc = NULL;
 }
 
-static void defaultConfig(FFinstance* instance)
+static void defaultConfig(void)
 {
-    ffInitLogoOptions(&instance->config.logo);
+    ffInitLogoOptions(&instance.config.logo);
 
-    ffStrbufInit(&instance->config.colorKeys);
-    ffStrbufInit(&instance->config.colorTitle);
-    ffStrbufInitS(&instance->config.keyValueSeparator, ": ");
+    ffStrbufInit(&instance.config.colorKeys);
+    ffStrbufInit(&instance.config.colorTitle);
+    ffStrbufInitS(&instance.config.keyValueSeparator, ": ");
 
     #if defined(__linux__) || defined(__FreeBSD__)
-    ffStrbufInit(&instance->config.playerName);
-    ffStrbufInit(&instance->config.osFile);
+    ffStrbufInit(&instance.config.playerName);
+    ffStrbufInit(&instance.config.osFile);
     #endif
 
-    instance->config.showErrors = false;
-    instance->config.recache = false;
-    instance->config.allowSlowOperations = false;
-    instance->config.pipe = !isatty(STDOUT_FILENO);
-    instance->config.disableLinewrap = !instance->config.pipe;
-    instance->config.hideCursor = !instance->config.pipe;
-    instance->config.escapeBedrock = true;
-    instance->config.binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
-    instance->config.multithreading = true;
-    instance->config.stat = false;
-    instance->config.noBuffer = false;
+    instance.config.showErrors = false;
+    instance.config.recache = false;
+    instance.config.allowSlowOperations = false;
+    instance.config.pipe = !isatty(STDOUT_FILENO);
+    instance.config.disableLinewrap = !instance.config.pipe;
+    instance.config.hideCursor = !instance.config.pipe;
+    instance.config.escapeBedrock = true;
+    instance.config.binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
+    instance.config.multithreading = true;
+    instance.config.stat = false;
+    instance.config.noBuffer = false;
 
-    ffInitTitleOptions(&instance->config.title);
-    ffInitOSOptions(&instance->config.os);
-    ffInitHostOptions(&instance->config.host);
-    ffInitBiosOptions(&instance->config.bios);
-    ffInitBoardOptions(&instance->config.board);
-    ffInitBrightnessOptions(&instance->config.brightness);
-    ffInitChassisOptions(&instance->config.chassis);
-    ffInitCommandOptions(&instance->config.command);
-    ffInitCustomOptions(&instance->config.custom);
-    ffInitKernelOptions(&instance->config.kernel);
-    ffInitUptimeOptions(&instance->config.uptime);
-    ffInitProcessesOptions(&instance->config.processes);
-    ffInitPackagesOptions(&instance->config.packages);
-    ffInitShellOptions(&instance->config.shell);
-    ffInitDisplayOptions(&instance->config.display);
-    ffInitDEOptions(&instance->config.de);
-    ffInitWMOptions(&instance->config.wm);
-    ffInitWMThemeOptions(&instance->config.wmTheme);
-    ffInitThemeOptions(&instance->config.theme);
-    ffInitIconsOptions(&instance->config.icons);
-    ffInitFontOptions(&instance->config.font);
-    ffInitCursorOptions(&instance->config.cursor);
-    ffInitTerminalOptions(&instance->config.terminal);
-    ffInitTerminalFontOptions(&instance->config.terminalFont);
-    ffInitCPUOptions(&instance->config.cpu);
-    ffInitCPUUsageOptions(&instance->config.cpuUsage);
-    ffInitGPUOptions(&instance->config.gpu);
-    ffInitMemoryOptions(&instance->config.memory);
-    ffInitSwapOptions(&instance->config.swap);
-    ffInitDiskOptions(&instance->config.disk);
-    ffInitBatteryOptions(&instance->config.battery);
-    ffInitPowerAdapterOptions(&instance->config.powerAdapter);
-    ffInitLMOptions(&instance->config.lm);
-    ffInitLocaleOptions(&instance->config.locale);
-    ffInitLocalIpOptions(&instance->config.localIP);
-    ffInitPublicIpOptions(&instance->config.publicIP);
-    ffInitWeatherOptions(&instance->config.weather);
-    ffInitWifiOptions(&instance->config.wifi);
-    ffInitPlayerOptions(&instance->config.player);
-    ffInitMediaOptions(&instance->config.media);
-    ffInitDateTimeOptions(&instance->config.dateTime);
-    ffInitVulkanOptions(&instance->config.vulkan);
-    ffInitWallpaperOptions(&instance->config.wallpaper);
-    ffInitOpenGLOptions(&instance->config.openGL);
-    ffInitOpenCLOptions(&instance->config.openCL);
-    ffInitUsersOptions(&instance->config.users);
-    ffInitBluetoothOptions(&instance->config.bluetooth);
-    ffInitSoundOptions(&instance->config.sound);
-    ffInitSeparatorOptions(&instance->config.separator);
-    ffInitGamepadOptions(&instance->config.gamepad);
-    ffInitColorsOptions(&instance->config.colors);
+    ffInitTitleOptions(&instance.config.title);
+    ffInitOSOptions(&instance.config.os);
+    ffInitHostOptions(&instance.config.host);
+    ffInitBiosOptions(&instance.config.bios);
+    ffInitBoardOptions(&instance.config.board);
+    ffInitBrightnessOptions(&instance.config.brightness);
+    ffInitChassisOptions(&instance.config.chassis);
+    ffInitCommandOptions(&instance.config.command);
+    ffInitCustomOptions(&instance.config.custom);
+    ffInitKernelOptions(&instance.config.kernel);
+    ffInitUptimeOptions(&instance.config.uptime);
+    ffInitProcessesOptions(&instance.config.processes);
+    ffInitPackagesOptions(&instance.config.packages);
+    ffInitShellOptions(&instance.config.shell);
+    ffInitDisplayOptions(&instance.config.display);
+    ffInitDEOptions(&instance.config.de);
+    ffInitWMOptions(&instance.config.wm);
+    ffInitWMThemeOptions(&instance.config.wmTheme);
+    ffInitThemeOptions(&instance.config.theme);
+    ffInitIconsOptions(&instance.config.icons);
+    ffInitFontOptions(&instance.config.font);
+    ffInitCursorOptions(&instance.config.cursor);
+    ffInitTerminalOptions(&instance.config.terminal);
+    ffInitTerminalFontOptions(&instance.config.terminalFont);
+    ffInitCPUOptions(&instance.config.cpu);
+    ffInitCPUUsageOptions(&instance.config.cpuUsage);
+    ffInitGPUOptions(&instance.config.gpu);
+    ffInitMemoryOptions(&instance.config.memory);
+    ffInitSwapOptions(&instance.config.swap);
+    ffInitDiskOptions(&instance.config.disk);
+    ffInitBatteryOptions(&instance.config.battery);
+    ffInitPowerAdapterOptions(&instance.config.powerAdapter);
+    ffInitLMOptions(&instance.config.lm);
+    ffInitLocaleOptions(&instance.config.locale);
+    ffInitLocalIpOptions(&instance.config.localIP);
+    ffInitPublicIpOptions(&instance.config.publicIP);
+    ffInitWeatherOptions(&instance.config.weather);
+    ffInitWifiOptions(&instance.config.wifi);
+    ffInitPlayerOptions(&instance.config.player);
+    ffInitMediaOptions(&instance.config.media);
+    ffInitDateTimeOptions(&instance.config.dateTime);
+    ffInitVulkanOptions(&instance.config.vulkan);
+    ffInitWallpaperOptions(&instance.config.wallpaper);
+    ffInitOpenGLOptions(&instance.config.openGL);
+    ffInitOpenCLOptions(&instance.config.openCL);
+    ffInitUsersOptions(&instance.config.users);
+    ffInitBluetoothOptions(&instance.config.bluetooth);
+    ffInitSoundOptions(&instance.config.sound);
+    ffInitSeparatorOptions(&instance.config.separator);
+    ffInitGamepadOptions(&instance.config.gamepad);
+    ffInitColorsOptions(&instance.config.colors);
 
-    ffStrbufInit(&instance->config.libPCI);
-    ffStrbufInit(&instance->config.libVulkan);
-    ffStrbufInit(&instance->config.libWayland);
-    ffStrbufInit(&instance->config.libXcbRandr);
-    ffStrbufInit(&instance->config.libXcb);
-    ffStrbufInit(&instance->config.libXrandr);
-    ffStrbufInit(&instance->config.libX11);
-    ffStrbufInit(&instance->config.libGIO);
-    ffStrbufInit(&instance->config.libDConf);
-    ffStrbufInit(&instance->config.libDBus);
-    ffStrbufInit(&instance->config.libXFConf);
-    ffStrbufInit(&instance->config.libSQLite3);
-    ffStrbufInit(&instance->config.librpm);
-    ffStrbufInit(&instance->config.libImageMagick);
-    ffStrbufInit(&instance->config.libZ);
-    ffStrbufInit(&instance->config.libChafa);
-    ffStrbufInit(&instance->config.libEGL);
-    ffStrbufInit(&instance->config.libGLX);
-    ffStrbufInit(&instance->config.libOSMesa);
-    ffStrbufInit(&instance->config.libOpenCL);
-    ffStrbufInit(&instance->config.libfreetype);
-    ffStrbufInit(&instance->config.libPulse);
-    ffStrbufInit(&instance->config.libnm);
+    ffStrbufInit(&instance.config.libPCI);
+    ffStrbufInit(&instance.config.libVulkan);
+    ffStrbufInit(&instance.config.libWayland);
+    ffStrbufInit(&instance.config.libXcbRandr);
+    ffStrbufInit(&instance.config.libXcb);
+    ffStrbufInit(&instance.config.libXrandr);
+    ffStrbufInit(&instance.config.libX11);
+    ffStrbufInit(&instance.config.libGIO);
+    ffStrbufInit(&instance.config.libDConf);
+    ffStrbufInit(&instance.config.libDBus);
+    ffStrbufInit(&instance.config.libXFConf);
+    ffStrbufInit(&instance.config.libSQLite3);
+    ffStrbufInit(&instance.config.librpm);
+    ffStrbufInit(&instance.config.libImageMagick);
+    ffStrbufInit(&instance.config.libZ);
+    ffStrbufInit(&instance.config.libChafa);
+    ffStrbufInit(&instance.config.libEGL);
+    ffStrbufInit(&instance.config.libGLX);
+    ffStrbufInit(&instance.config.libOSMesa);
+    ffStrbufInit(&instance.config.libOpenCL);
+    ffStrbufInit(&instance.config.libfreetype);
+    ffStrbufInit(&instance.config.libPulse);
+    ffStrbufInit(&instance.config.libnm);
 
-    instance->config.percentType = 1;
+    instance.config.percentType = 1;
 }
 
-void ffInitInstance(FFinstance* instance)
+void ffInitInstance(void)
 {
     #ifdef WIN32
         //https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendations&view=msvc-170#utf-8-support
         setlocale(LC_ALL, ".UTF8");
     #endif
 
-    initState(&instance->state);
-    defaultConfig(instance);
+    initState(&instance.state);
+    defaultConfig();
 }
 
 #if defined(FF_HAVE_THREADS) && !(defined(__APPLE__) || defined(_WIN32) || defined(__ANDROID__))
@@ -149,19 +151,19 @@ void ffInitInstance(FFinstance* instance)
 
 #define FF_START_DETECTION_THREADS
 
-FF_THREAD_ENTRY_DECL_WRAPPER(ffConnectDisplayServer, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectQt, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK2, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK3, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK4, FFinstance*)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffConnectDisplayServer)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectQt)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectGTK2)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectGTK3)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectGTK4)
 
-void startDetectionThreads(FFinstance* instance)
+void startDetectionThreads(void)
 {
-    ffThreadDetach(ffThreadCreate(ffConnectDisplayServerThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectQtThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK2ThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK3ThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK4ThreadMain, instance));
+    ffThreadDetach(ffThreadCreate(ffConnectDisplayServerThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectQtThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK2ThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK3ThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK4ThreadMain, NULL));
 }
 
 #endif //FF_HAVE_THREADS
@@ -169,7 +171,7 @@ void startDetectionThreads(FFinstance* instance)
 static volatile bool ffDisableLinewrap = true;
 static volatile bool ffHideCursor = true;
 
-static void resetConsole()
+static void resetConsole(void)
 {
     if(ffDisableLinewrap)
         fputs("\033[?7h", stdout);
@@ -198,18 +200,18 @@ static void exitSignalHandler(int signal)
 }
 #endif
 
-void ffStart(FFinstance* instance)
+void ffStart(void)
 {
     #ifdef FF_START_DETECTION_THREADS
-        if(instance->config.multithreading)
-            startDetectionThreads(instance);
+        if(instance.config.multithreading)
+            startDetectionThreads();
     #endif
 
-    ffDisableLinewrap = instance->config.disableLinewrap && !instance->config.pipe;
-    ffHideCursor = instance->config.hideCursor && !instance->config.pipe;
+    ffDisableLinewrap = instance.config.disableLinewrap && !instance.config.pipe;
+    ffHideCursor = instance.config.hideCursor && !instance.config.pipe;
 
     #ifdef _WIN32
-    if (!instance->config.noBuffer) setvbuf(stdout, NULL, _IOFBF, 4096);
+    if (!instance.config.noBuffer) setvbuf(stdout, NULL, _IOFBF, 4096);
     SetConsoleCtrlHandler(consoleHandler, TRUE);
     HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
     DWORD mode = 0;
@@ -217,7 +219,7 @@ void ffStart(FFinstance* instance)
     SetConsoleMode(hStdout, mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
     SetConsoleOutputCP(CP_UTF8);
     #else
-    if (instance->config.noBuffer) setvbuf(stdout, NULL, _IONBF, 0);
+    if (instance.config.noBuffer) setvbuf(stdout, NULL, _IONBF, 0);
     struct sigaction action = { .sa_handler = exitSignalHandler };
     sigaction(SIGINT, &action, NULL);
     sigaction(SIGTERM, &action, NULL);
@@ -225,7 +227,7 @@ void ffStart(FFinstance* instance)
     #endif
 
     //reset everything to default before we start printing
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
     if(ffHideCursor)
@@ -234,121 +236,121 @@ void ffStart(FFinstance* instance)
     if(ffDisableLinewrap)
         fputs("\033[?7l", stdout);
 
-    ffLogoPrint(instance);
+    ffLogoPrint();
 }
 
-void ffFinish(FFinstance* instance)
+void ffFinish(void)
 {
-    if(instance->config.logo.printRemaining)
-        ffLogoPrintRemaining(instance);
+    if(instance.config.logo.printRemaining)
+        ffLogoPrintRemaining();
 
     resetConsole();
 }
 
-static void destroyConfig(FFinstance* instance)
+static void destroyConfig(void)
 {
-    ffDestroyLogoOptions(&instance->config.logo);
+    ffDestroyLogoOptions(&instance.config.logo);
 
-    ffStrbufDestroy(&instance->config.colorKeys);
-    ffStrbufDestroy(&instance->config.colorTitle);
-    ffStrbufDestroy(&instance->config.keyValueSeparator);
+    ffStrbufDestroy(&instance.config.colorKeys);
+    ffStrbufDestroy(&instance.config.colorTitle);
+    ffStrbufDestroy(&instance.config.keyValueSeparator);
 
     #if defined(__linux__) || defined(__FreeBSD__)
-    ffStrbufDestroy(&instance->config.playerName);
-    ffStrbufDestroy(&instance->config.osFile);
+    ffStrbufDestroy(&instance.config.playerName);
+    ffStrbufDestroy(&instance.config.osFile);
     #endif
 
-    ffDestroyTitleOptions(&instance->config.title);
-    ffDestroyOSOptions(&instance->config.os);
-    ffDestroyHostOptions(&instance->config.host);
-    ffDestroyBiosOptions(&instance->config.bios);
-    ffDestroyBoardOptions(&instance->config.board);
-    ffDestroyBrightnessOptions(&instance->config.brightness);
-    ffDestroyChassisOptions(&instance->config.chassis);
-    ffDestroyCommandOptions(&instance->config.command);
-    ffDestroyCustomOptions(&instance->config.custom);
-    ffDestroyKernelOptions(&instance->config.kernel);
-    ffDestroyUptimeOptions(&instance->config.uptime);
-    ffDestroyProcessesOptions(&instance->config.processes);
-    ffDestroyPackagesOptions(&instance->config.packages);
-    ffDestroyShellOptions(&instance->config.shell);
-    ffDestroyDisplayOptions(&instance->config.display);
-    ffDestroyDEOptions(&instance->config.de);
-    ffDestroyWMOptions(&instance->config.wm);
-    ffDestroyWMThemeOptions(&instance->config.wmTheme);
-    ffDestroyThemeOptions(&instance->config.theme);
-    ffDestroyIconsOptions(&instance->config.icons);
-    ffDestroyFontOptions(&instance->config.font);
-    ffDestroyCursorOptions(&instance->config.cursor);
-    ffDestroyTerminalOptions(&instance->config.terminal);
-    ffDestroyTerminalFontOptions(&instance->config.terminalFont);
-    ffDestroyCPUOptions(&instance->config.cpu);
-    ffDestroyCPUUsageOptions(&instance->config.cpuUsage);
-    ffDestroyGPUOptions(&instance->config.gpu);
-    ffDestroyMemoryOptions(&instance->config.memory);
-    ffDestroySwapOptions(&instance->config.swap);
-    ffDestroyDiskOptions(&instance->config.disk);
-    ffDestroyBatteryOptions(&instance->config.battery);
-    ffDestroyPowerAdapterOptions(&instance->config.powerAdapter);
-    ffDestroyLMOptions(&instance->config.lm);
-    ffDestroyLocaleOptions(&instance->config.locale);
-    ffDestroyLocalIpOptions(&instance->config.localIP);
-    ffDestroyPublicIpOptions(&instance->config.publicIP);
-    ffDestroyWallpaperOptions(&instance->config.wallpaper);
-    ffDestroyWeatherOptions(&instance->config.weather);
-    ffDestroyWifiOptions(&instance->config.wifi);
-    ffDestroyPlayerOptions(&instance->config.player);
-    ffDestroyMediaOptions(&instance->config.media);
-    ffDestroyDateTimeOptions(&instance->config.dateTime);
-    ffDestroyVulkanOptions(&instance->config.vulkan);
-    ffDestroyOpenGLOptions(&instance->config.openGL);
-    ffDestroyOpenCLOptions(&instance->config.openCL);
-    ffDestroyUsersOptions(&instance->config.users);
-    ffDestroyBluetoothOptions(&instance->config.bluetooth);
-    ffDestroySeparatorOptions(&instance->config.separator);
-    ffDestroySoundOptions(&instance->config.sound);
-    ffDestroyGamepadOptions(&instance->config.gamepad);
-    ffDestroyColorsOptions(&instance->config.colors);
+    ffDestroyTitleOptions(&instance.config.title);
+    ffDestroyOSOptions(&instance.config.os);
+    ffDestroyHostOptions(&instance.config.host);
+    ffDestroyBiosOptions(&instance.config.bios);
+    ffDestroyBoardOptions(&instance.config.board);
+    ffDestroyBrightnessOptions(&instance.config.brightness);
+    ffDestroyChassisOptions(&instance.config.chassis);
+    ffDestroyCommandOptions(&instance.config.command);
+    ffDestroyCustomOptions(&instance.config.custom);
+    ffDestroyKernelOptions(&instance.config.kernel);
+    ffDestroyUptimeOptions(&instance.config.uptime);
+    ffDestroyProcessesOptions(&instance.config.processes);
+    ffDestroyPackagesOptions(&instance.config.packages);
+    ffDestroyShellOptions(&instance.config.shell);
+    ffDestroyDisplayOptions(&instance.config.display);
+    ffDestroyDEOptions(&instance.config.de);
+    ffDestroyWMOptions(&instance.config.wm);
+    ffDestroyWMThemeOptions(&instance.config.wmTheme);
+    ffDestroyThemeOptions(&instance.config.theme);
+    ffDestroyIconsOptions(&instance.config.icons);
+    ffDestroyFontOptions(&instance.config.font);
+    ffDestroyCursorOptions(&instance.config.cursor);
+    ffDestroyTerminalOptions(&instance.config.terminal);
+    ffDestroyTerminalFontOptions(&instance.config.terminalFont);
+    ffDestroyCPUOptions(&instance.config.cpu);
+    ffDestroyCPUUsageOptions(&instance.config.cpuUsage);
+    ffDestroyGPUOptions(&instance.config.gpu);
+    ffDestroyMemoryOptions(&instance.config.memory);
+    ffDestroySwapOptions(&instance.config.swap);
+    ffDestroyDiskOptions(&instance.config.disk);
+    ffDestroyBatteryOptions(&instance.config.battery);
+    ffDestroyPowerAdapterOptions(&instance.config.powerAdapter);
+    ffDestroyLMOptions(&instance.config.lm);
+    ffDestroyLocaleOptions(&instance.config.locale);
+    ffDestroyLocalIpOptions(&instance.config.localIP);
+    ffDestroyPublicIpOptions(&instance.config.publicIP);
+    ffDestroyWallpaperOptions(&instance.config.wallpaper);
+    ffDestroyWeatherOptions(&instance.config.weather);
+    ffDestroyWifiOptions(&instance.config.wifi);
+    ffDestroyPlayerOptions(&instance.config.player);
+    ffDestroyMediaOptions(&instance.config.media);
+    ffDestroyDateTimeOptions(&instance.config.dateTime);
+    ffDestroyVulkanOptions(&instance.config.vulkan);
+    ffDestroyOpenGLOptions(&instance.config.openGL);
+    ffDestroyOpenCLOptions(&instance.config.openCL);
+    ffDestroyUsersOptions(&instance.config.users);
+    ffDestroyBluetoothOptions(&instance.config.bluetooth);
+    ffDestroySeparatorOptions(&instance.config.separator);
+    ffDestroySoundOptions(&instance.config.sound);
+    ffDestroyGamepadOptions(&instance.config.gamepad);
+    ffDestroyColorsOptions(&instance.config.colors);
 
-    ffStrbufDestroy(&instance->config.libPCI);
-    ffStrbufDestroy(&instance->config.libVulkan);
-    ffStrbufDestroy(&instance->config.libWayland);
-    ffStrbufDestroy(&instance->config.libXcbRandr);
-    ffStrbufDestroy(&instance->config.libXcb);
-    ffStrbufDestroy(&instance->config.libXrandr);
-    ffStrbufDestroy(&instance->config.libX11);
-    ffStrbufDestroy(&instance->config.libGIO);
-    ffStrbufDestroy(&instance->config.libDConf);
-    ffStrbufDestroy(&instance->config.libDBus);
-    ffStrbufDestroy(&instance->config.libXFConf);
-    ffStrbufDestroy(&instance->config.libSQLite3);
-    ffStrbufDestroy(&instance->config.librpm);
-    ffStrbufDestroy(&instance->config.libImageMagick);
-    ffStrbufDestroy(&instance->config.libZ);
-    ffStrbufDestroy(&instance->config.libChafa);
-    ffStrbufDestroy(&instance->config.libEGL);
-    ffStrbufDestroy(&instance->config.libGLX);
-    ffStrbufDestroy(&instance->config.libOSMesa);
-    ffStrbufDestroy(&instance->config.libOpenCL);
-    ffStrbufDestroy(&instance->config.libfreetype);
-    ffStrbufDestroy(&instance->config.libPulse);
-    ffStrbufDestroy(&instance->config.libnm);
+    ffStrbufDestroy(&instance.config.libPCI);
+    ffStrbufDestroy(&instance.config.libVulkan);
+    ffStrbufDestroy(&instance.config.libWayland);
+    ffStrbufDestroy(&instance.config.libXcbRandr);
+    ffStrbufDestroy(&instance.config.libXcb);
+    ffStrbufDestroy(&instance.config.libXrandr);
+    ffStrbufDestroy(&instance.config.libX11);
+    ffStrbufDestroy(&instance.config.libGIO);
+    ffStrbufDestroy(&instance.config.libDConf);
+    ffStrbufDestroy(&instance.config.libDBus);
+    ffStrbufDestroy(&instance.config.libXFConf);
+    ffStrbufDestroy(&instance.config.libSQLite3);
+    ffStrbufDestroy(&instance.config.librpm);
+    ffStrbufDestroy(&instance.config.libImageMagick);
+    ffStrbufDestroy(&instance.config.libZ);
+    ffStrbufDestroy(&instance.config.libChafa);
+    ffStrbufDestroy(&instance.config.libEGL);
+    ffStrbufDestroy(&instance.config.libGLX);
+    ffStrbufDestroy(&instance.config.libOSMesa);
+    ffStrbufDestroy(&instance.config.libOpenCL);
+    ffStrbufDestroy(&instance.config.libfreetype);
+    ffStrbufDestroy(&instance.config.libPulse);
+    ffStrbufDestroy(&instance.config.libnm);
 }
 
-static void destroyState(FFinstance* instance)
+static void destroyState(void)
 {
-    ffPlatformDestroy(&instance->state.platform);
-    yyjson_doc_free(instance->state.configDoc);
+    ffPlatformDestroy(&instance.state.platform);
+    yyjson_doc_free(instance.state.configDoc);
 }
 
-void ffDestroyInstance(FFinstance* instance)
+void ffDestroyInstance(void)
 {
-    destroyConfig(instance);
-    destroyState(instance);
+    destroyConfig();
+    destroyState();
 }
 
 //Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
-void ffListFeatures()
+void ffListFeatures(void)
 {
     fputs(
         #ifdef FF_HAVE_THREADS

src/common/jsonconfig.c

@@ -65,154 +65,154 @@ const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair p
         return "Invalid enum value type; must be a string or integer";
 }
 
-static inline bool tryModule(FFinstance* instance, const char* type, yyjson_val* module, const char* moduleName, void (*const f)(FFinstance *instance, yyjson_val *module))
+static inline bool tryModule(const char* type, yyjson_val* module, const char* moduleName, void (*const f)(yyjson_val *module))
 {
     if (ffStrEqualsIgnCase(type, moduleName))
     {
-        f(instance, module);
+        f(module);
         return true;
     }
     return false;
 }
 
-static bool parseModuleJsonObject(FFinstance* instance, const char* type, yyjson_val* module)
+static bool parseModuleJsonObject(const char* type, yyjson_val* module)
 {
     switch (toupper(type[0]))
     {
         case 'B': {
             return
-                tryModule(instance, type, module, FF_BATTERY_MODULE_NAME, ffParseBatteryJsonObject) ||
-                tryModule(instance, type, module, FF_BIOS_MODULE_NAME, ffParseBiosJsonObject) ||
-                tryModule(instance, type, module, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothJsonObject) ||
-                tryModule(instance, type, module, FF_BOARD_MODULE_NAME, ffParseBoardJsonObject) ||
-                tryModule(instance, type, module, FF_BREAK_MODULE_NAME, ffParseBreakJsonObject) ||
-                tryModule(instance, type, module, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessJsonObject) ||
+                tryModule(type, module, FF_BATTERY_MODULE_NAME, ffParseBatteryJsonObject) ||
+                tryModule(type, module, FF_BIOS_MODULE_NAME, ffParseBiosJsonObject) ||
+                tryModule(type, module, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothJsonObject) ||
+                tryModule(type, module, FF_BOARD_MODULE_NAME, ffParseBoardJsonObject) ||
+                tryModule(type, module, FF_BREAK_MODULE_NAME, ffParseBreakJsonObject) ||
+                tryModule(type, module, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessJsonObject) ||
                 false;
         }
 
         case 'C': {
             return
-                tryModule(instance, type, module, FF_CHASSIS_MODULE_NAME, ffParseChassisJsonObject) ||
-                tryModule(instance, type, module, FF_CPU_MODULE_NAME, ffParseCPUJsonObject) ||
-                tryModule(instance, type, module, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageJsonObject) ||
-                tryModule(instance, type, module, FF_COMMAND_MODULE_NAME, ffParseCommandJsonObject) ||
-                tryModule(instance, type, module, FF_COLORS_MODULE_NAME, ffParseColorsJsonObject) ||
-                tryModule(instance, type, module, FF_CURSOR_MODULE_NAME, ffParseCursorJsonObject) ||
-                tryModule(instance, type, module, FF_CUSTOM_MODULE_NAME, ffParseCustomJsonObject) ||
+                tryModule(type, module, FF_CHASSIS_MODULE_NAME, ffParseChassisJsonObject) ||
+                tryModule(type, module, FF_CPU_MODULE_NAME, ffParseCPUJsonObject) ||
+                tryModule(type, module, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageJsonObject) ||
+                tryModule(type, module, FF_COMMAND_MODULE_NAME, ffParseCommandJsonObject) ||
+                tryModule(type, module, FF_COLORS_MODULE_NAME, ffParseColorsJsonObject) ||
+                tryModule(type, module, FF_CURSOR_MODULE_NAME, ffParseCursorJsonObject) ||
+                tryModule(type, module, FF_CUSTOM_MODULE_NAME, ffParseCustomJsonObject) ||
                 false;
         }
 
         case 'D': {
             return
-                tryModule(instance, type, module, FF_DATETIME_MODULE_NAME, ffParseDateTimeJsonObject) ||
-                tryModule(instance, type, module, FF_DISPLAY_MODULE_NAME, ffParseDisplayJsonObject) ||
-                tryModule(instance, type, module, FF_DISK_MODULE_NAME, ffParseDiskJsonObject) ||
-                tryModule(instance, type, module, FF_DE_MODULE_NAME, ffParseDEJsonObject) ||
+                tryModule(type, module, FF_DATETIME_MODULE_NAME, ffParseDateTimeJsonObject) ||
+                tryModule(type, module, FF_DISPLAY_MODULE_NAME, ffParseDisplayJsonObject) ||
+                tryModule(type, module, FF_DISK_MODULE_NAME, ffParseDiskJsonObject) ||
+                tryModule(type, module, FF_DE_MODULE_NAME, ffParseDEJsonObject) ||
                 false;
         }
 
         case 'F': {
             return
-                tryModule(instance, type, module, FF_FONT_MODULE_NAME, ffParseFontJsonObject) ||
+                tryModule(type, module, FF_FONT_MODULE_NAME, ffParseFontJsonObject) ||
                 false;
         }
 
         case 'G': {
             return
-                tryModule(instance, type, module, FF_GAMEPAD_MODULE_NAME, ffParseGamepadJsonObject) ||
-                tryModule(instance, type, module, FF_GPU_MODULE_NAME, ffParseGPUJsonObject) ||
+                tryModule(type, module, FF_GAMEPAD_MODULE_NAME, ffParseGamepadJsonObject) ||
+                tryModule(type, module, FF_GPU_MODULE_NAME, ffParseGPUJsonObject) ||
                 false;
         }
 
         case 'H': {
             return
-                tryModule(instance, type, module, FF_HOST_MODULE_NAME, ffParseHostJsonObject) ||
+                tryModule(type, module, FF_HOST_MODULE_NAME, ffParseHostJsonObject) ||
                 false;
         }
 
         case 'I': {
             return
-                tryModule(instance, type, module, FF_ICONS_MODULE_NAME, ffParseIconsJsonObject) ||
+                tryModule(type, module, FF_ICONS_MODULE_NAME, ffParseIconsJsonObject) ||
                 false;
         }
 
         case 'K': {
             return
-                tryModule(instance, type, module, FF_KERNEL_MODULE_NAME, ffParseKernelJsonObject) ||
+                tryModule(type, module, FF_KERNEL_MODULE_NAME, ffParseKernelJsonObject) ||
                 false;
         }
 
         case 'L': {
             return
-                tryModule(instance, type, module, FF_LM_MODULE_NAME, ffParseLMJsonObject) ||
-                tryModule(instance, type, module, FF_LOCALE_MODULE_NAME, ffParseLocaleJsonObject) ||
-                tryModule(instance, type, module, FF_LOCALIP_MODULE_NAME, ffParseLocalIpJsonObject) ||
+                tryModule(type, module, FF_LM_MODULE_NAME, ffParseLMJsonObject) ||
+                tryModule(type, module, FF_LOCALE_MODULE_NAME, ffParseLocaleJsonObject) ||
+                tryModule(type, module, FF_LOCALIP_MODULE_NAME, ffParseLocalIpJsonObject) ||
                 false;
         }
 
         case 'M': {
             return
-                tryModule(instance, type, module, FF_MEDIA_MODULE_NAME, ffParseMediaJsonObject) ||
-                tryModule(instance, type, module, FF_MEMORY_MODULE_NAME, ffParseMemoryJsonObject) ||
+                tryModule(type, module, FF_MEDIA_MODULE_NAME, ffParseMediaJsonObject) ||
+                tryModule(type, module, FF_MEMORY_MODULE_NAME, ffParseMemoryJsonObject) ||
                 false;
         }
 
         case 'O': {
             return
-                tryModule(instance, type, module, FF_OPENCL_MODULE_NAME, ffParseOpenCLJsonObject) ||
-                tryModule(instance, type, module, FF_OPENGL_MODULE_NAME, ffParseOpenGLJsonObject) ||
-                tryModule(instance, type, module, FF_OS_MODULE_NAME, ffParseOSJsonObject) ||
+                tryModule(type, module, FF_OPENCL_MODULE_NAME, ffParseOpenCLJsonObject) ||
+                tryModule(type, module, FF_OPENGL_MODULE_NAME, ffParseOpenGLJsonObject) ||
+                tryModule(type, module, FF_OS_MODULE_NAME, ffParseOSJsonObject) ||
                 false;
         }
 
         case 'P': {
             return
-                tryModule(instance, type, module, FF_PACKAGES_MODULE_NAME, ffParsePackagesJsonObject) ||
-                tryModule(instance, type, module, FF_PLAYER_MODULE_NAME, ffParsePlayerJsonObject) ||
-                tryModule(instance, type, module, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterJsonObject) ||
-                tryModule(instance, type, module, FF_PROCESSES_MODULE_NAME, ffParseProcessesJsonObject) ||
-                tryModule(instance, type, module, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpJsonObject) ||
+                tryModule(type, module, FF_PACKAGES_MODULE_NAME, ffParsePackagesJsonObject) ||
+                tryModule(type, module, FF_PLAYER_MODULE_NAME, ffParsePlayerJsonObject) ||
+                tryModule(type, module, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterJsonObject) ||
+                tryModule(type, module, FF_PROCESSES_MODULE_NAME, ffParseProcessesJsonObject) ||
+                tryModule(type, module, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpJsonObject) ||
                 false;
         }
 
         case 'S': {
             return
-                tryModule(instance, type, module, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorJsonObject) ||
-                tryModule(instance, type, module, FF_SHELL_MODULE_NAME, ffParseShellJsonObject) ||
-                tryModule(instance, type, module, FF_SOUND_MODULE_NAME, ffParseSoundJsonObject) ||
-                tryModule(instance, type, module, FF_SWAP_MODULE_NAME, ffParseSwapJsonObject) ||
+                tryModule(type, module, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorJsonObject) ||
+                tryModule(type, module, FF_SHELL_MODULE_NAME, ffParseShellJsonObject) ||
+                tryModule(type, module, FF_SOUND_MODULE_NAME, ffParseSoundJsonObject) ||
+                tryModule(type, module, FF_SWAP_MODULE_NAME, ffParseSwapJsonObject) ||
                 false;
         }
 
         case 'T': {
             return
-                tryModule(instance, type, module, FF_TERMINAL_MODULE_NAME, ffParseTerminalJsonObject) ||
-                tryModule(instance, type, module, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontJsonObject) ||
-                tryModule(instance, type, module, FF_TITLE_MODULE_NAME, ffParseTitleJsonObject) ||
-                tryModule(instance, type, module, FF_THEME_MODULE_NAME, ffParseThemeJsonObject) ||
+                tryModule(type, module, FF_TERMINAL_MODULE_NAME, ffParseTerminalJsonObject) ||
+                tryModule(type, module, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontJsonObject) ||
+                tryModule(type, module, FF_TITLE_MODULE_NAME, ffParseTitleJsonObject) ||
+                tryModule(type, module, FF_THEME_MODULE_NAME, ffParseThemeJsonObject) ||
                 false;
         }
 
         case 'U': {
             return
-                tryModule(instance, type, module, FF_UPTIME_MODULE_NAME, ffParseUptimeJsonObject) ||
-                tryModule(instance, type, module, FF_USERS_MODULE_NAME, ffParseUsersJsonObject) ||
+                tryModule(type, module, FF_UPTIME_MODULE_NAME, ffParseUptimeJsonObject) ||
+                tryModule(type, module, FF_USERS_MODULE_NAME, ffParseUsersJsonObject) ||
                 false;
         }
 
         case 'V': {
             return
-                tryModule(instance, type, module, FF_VULKAN_MODULE_NAME, ffParseVulkanJsonObject) ||
+                tryModule(type, module, FF_VULKAN_MODULE_NAME, ffParseVulkanJsonObject) ||
                 false;
         }
 
         case 'W': {
             return
-                tryModule(instance, type, module, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperJsonObject) ||
-                tryModule(instance, type, module, FF_WEATHER_MODULE_NAME, ffParseWeatherJsonObject) ||
-                tryModule(instance, type, module, FF_WM_MODULE_NAME, ffParseWMJsonObject) ||
-                tryModule(instance, type, module, FF_WIFI_MODULE_NAME, ffParseWifiJsonObject) ||
-                tryModule(instance, type, module, FF_WMTHEME_MODULE_NAME, ffParseWMThemeJsonObject) ||
+                tryModule(type, module, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperJsonObject) ||
+                tryModule(type, module, FF_WEATHER_MODULE_NAME, ffParseWeatherJsonObject) ||
+                tryModule(type, module, FF_WM_MODULE_NAME, ffParseWMJsonObject) ||
+                tryModule(type, module, FF_WIFI_MODULE_NAME, ffParseWifiJsonObject) ||
+                tryModule(type, module, FF_WMTHEME_MODULE_NAME, ffParseWMThemeJsonObject) ||
                 false;
         }
 
@@ -221,9 +221,9 @@ static bool parseModuleJsonObject(FFinstance* instance, const char* type, yyjson
     }
 }
 
-static const char* printJsonConfig(FFinstance* instance)
+static const char* printJsonConfig(void)
 {
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -238,7 +238,7 @@ static const char* printJsonConfig(FFinstance* instance)
     yyjson_arr_foreach(modules, idx, max, item)
     {
         uint64_t ms = 0;
-        if(__builtin_expect(instance->config.stat, false))
+        if(__builtin_expect(instance.config.stat, false))
             ms = ffTimeGetTick();
 
         yyjson_val* module = item;
@@ -255,32 +255,32 @@ static const char* printJsonConfig(FFinstance* instance)
         else
             return "modules must be an array of strings or objects";
 
-        if(!parseModuleJsonObject(instance, type, module))
+        if(!parseModuleJsonObject(type, module))
             return "Unknown module type";
 
-        if(__builtin_expect(instance->config.stat, false))
+        if(__builtin_expect(instance.config.stat, false))
         {
             char str[32];
             int len = snprintf(str, sizeof str, "%" PRIu64 "ms", ffTimeGetTick() - ms);
-            if(instance->config.pipe)
+            if(instance.config.pipe)
                 puts(str);
             else
                 printf("\033[s\033[1A\033[9999999C\033[%dD%s\033[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
         }
 
         #if defined(_WIN32)
-        if (!instance->config.noBuffer) fflush(stdout);
+        if (!instance.config.noBuffer) fflush(stdout);
         #endif
     }
 
     return NULL;
 }
 
-const char* ffParseGeneralJsonConfig(FFinstance* instance)
+const char* ffParseGeneralJsonConfig(void)
 {
-    FFconfig* config = &instance->config;
+    FFconfig* config = &instance.config;
 
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -321,11 +321,11 @@ const char* ffParseGeneralJsonConfig(FFinstance* instance)
     return NULL;
 }
 
-const char* ffParseDisplayJsonConfig(FFinstance* instance)
+const char* ffParseDisplayJsonConfig(void)
 {
-    FFconfig* config = &instance->config;
+    FFconfig* config = &instance.config;
 
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -391,11 +391,11 @@ const char* ffParseDisplayJsonConfig(FFinstance* instance)
     return NULL;
 }
 
-const char* ffParseLibraryJsonConfig(FFinstance* instance)
+const char* ffParseLibraryJsonConfig(void)
 {
-    FFconfig* config = &instance->config;
+    FFconfig* config = &instance.config;
 
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -464,9 +464,9 @@ const char* ffParseLibraryJsonConfig(FFinstance* instance)
     return NULL;
 }
 
-void ffPrintJsonConfig(FFinstance* instance)
+void ffPrintJsonConfig(void)
 {
-    const char* error = printJsonConfig(instance);
+    const char* error = printJsonConfig();
     if (error)
-        ffPrintErrorString(instance, "JsonConfig", 0, NULL, NULL, "%s", error);
+        ffPrintErrorString("JsonConfig", 0, NULL, NULL, "%s", error);
 }

src/common/jsonconfig.h

@@ -4,7 +4,7 @@
 
 bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* moduleArgs);
 const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair pairs[]);
-void ffPrintJsonConfig(FFinstance* instance);
-const char* ffParseGeneralJsonConfig(FFinstance* instance);
-const char* ffParseDisplayJsonConfig(FFinstance* instance);
-const char* ffParseLibraryJsonConfig(FFinstance* instance);
+void ffPrintJsonConfig();
+const char* ffParseGeneralJsonConfig();
+const char* ffParseDisplayJsonConfig();
+const char* ffParseLibraryJsonConfig();

src/common/printing.c

@@ -2,21 +2,21 @@
 #include "common/printing.h"
 #include "util/textModifier.h"
 
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor)
+void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor)
 {
-    ffLogoPrintLine(instance);
+    ffLogoPrintLine();
 
     //This is used by --set-keyless, in this case we wan't neither the module name nor the separator
     if(moduleName == NULL)
         return;
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
     {
         fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
         if(customKeyColor != NULL && customKeyColor->length > 0)
             ffPrintColor(customKeyColor);
         else
-            ffPrintColor(&instance->config.colorKeys);
+            ffPrintColor(&instance.config.colorKeys);
     }
 
     //NULL check is required for modules with custom keys, e.g. disk with the folder path
@@ -36,64 +36,64 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
         ffPrintUserString(key.chars);
     }
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
-    ffStrbufWriteTo(&instance->config.keyValueSeparator, stdout);
+    ffStrbufWriteTo(&instance.config.keyValueSeparator, stdout);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 }
 
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
 {
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(256);
     ffParseFormatString(&buffer, format, numArgs, arguments);
 
     if(buffer.length > 0)
     {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat, customKeyColor);
+        ffPrintLogoAndKey(moduleName, moduleIndex, customKeyFormat, customKeyColor);
         ffPrintUserString(buffer.chars);
         putchar('\n');
     }
 }
 
-void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
 {
-    ffPrintFormatString(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, &moduleArgs->outputFormat, numArgs, arguments);
+    ffPrintFormatString(moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, &moduleArgs->outputFormat, numArgs, arguments);
 }
 
-static void printError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, va_list arguments)
+static void printError(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, va_list arguments)
 {
-    if(!instance->config.showErrors)
+    if(!instance.config.showErrors)
         return;
 
-    ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat, customKeyColor);
+    ffPrintLogoAndKey(moduleName, moduleIndex, customKeyFormat, customKeyColor);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
 
     vprintf(message, arguments);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
     putchar('\n');
 }
 
-void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...)
+void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...)
 {
     va_list arguments;
     va_start(arguments, message);
-    printError(instance, moduleName, moduleIndex, customKeyFormat, customKeyColor, message, arguments);
+    printError(moduleName, moduleIndex, customKeyFormat, customKeyColor, message, arguments);
     va_end(arguments);
 }
 
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
+void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
 {
     va_list arguments;
     va_start(arguments, message);
-    printError(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, message, arguments);
+    printError(moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, message, arguments);
     va_end(arguments);
 }
 

src/common/printing.h

@@ -6,11 +6,11 @@
 #include "fastfetch.h"
 #include "common/format.h"
 
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor);
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments);
-void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments);
-FF_C_PRINTF(6, 7) void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...);
-FF_C_PRINTF(5, 6) void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
+void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor);
+void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments);
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments);
+FF_C_PRINTF(5, 6) void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...);
+FF_C_PRINTF(4, 5) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
 void ffPrintColor(const FFstrbuf* colorValue);
 void ffPrintCharTimes(char c, uint32_t times);
 void ffPrintUserString(const char* str);

src/common/properties.c

@@ -144,9 +144,9 @@ done:
     return true;
 }
 
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+bool ffParsePropFileHomeValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateF("%s/%s", instance->state.platform.homeDir.chars, relativeFile);
+    FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateF("%s/%s", instance.state.platform.homeDir.chars, relativeFile);
     return ffParsePropFileValues(absolutePath.chars, numQueries, queries);
 }
 

src/common/properties.h

@@ -14,7 +14,7 @@ typedef struct FFpropquery
 bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer);
 bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer);
 bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries);
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFileHomeValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
 bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
 
 static inline bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
@@ -22,9 +22,9 @@ static inline bool ffParsePropFile(const char* filename, const char* start, FFst
     return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileHome(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileHomeValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
 static inline bool ffParsePropFileList(const FFlist* list, const char* relativeFile, const char* start, FFstrbuf* buffer)
@@ -32,24 +32,24 @@ static inline bool ffParsePropFileList(const FFlist* list, const char* relativeF
     return ffParsePropFileListValues(list, relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+static inline bool ffParsePropFileConfigValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    return ffParsePropFileListValues(&instance->state.platform.configDirs, relativeFile, numQueries, queries);
+    return ffParsePropFileListValues(&instance.state.platform.configDirs, relativeFile, numQueries, queries);
 }
 
-static inline bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileConfig(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileConfigValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileDataValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+static inline bool ffParsePropFileDataValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    return ffParsePropFileListValues(&instance->state.platform.dataDirs, relativeFile, numQueries, queries);
+    return ffParsePropFileListValues(&instance.state.platform.dataDirs, relativeFile, numQueries, queries);
 }
 
-static inline bool ffParsePropFileData(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileData(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileDataValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileDataValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
 #endif

src/common/settings.c

@@ -97,9 +97,9 @@ typedef struct GSettingsData
     GVariantGetters variantGetters;
 } GSettingsData;
 
-static const GSettingsData* getGSettingsData(const FFinstance* instance)
+static const GSettingsData* getGSettingsData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance.config.libGIO, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_lookup)
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_has_key)
@@ -123,9 +123,9 @@ static const GSettingsData* getGSettingsData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
-    const GSettingsData* data = getGSettingsData(instance);
+    const GSettingsData* data = getGSettingsData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -152,9 +152,9 @@ FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaN
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_GIO
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
-    FF_UNUSED(instance, schemaName, path, key, type)
+    FF_UNUSED(schemaName, path, key, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_GIO
@@ -170,9 +170,9 @@ typedef struct DConfData
     DConfClient* client;
 } DConfData;
 
-static const DConfData* getDConfData(const FFinstance* instance)
+static const DConfData* getDConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf" FF_LIBRARY_EXTENSION, 2);
+    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance.config.libDConf, "libdconf" FF_LIBRARY_EXTENSION, 2);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_read_full)
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_new)
@@ -191,9 +191,9 @@ static const DConfData* getDConfData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type)
 {
-    const DConfData* data = getDConfData(instance);
+    const DConfData* data = getDConfData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -209,23 +209,23 @@ FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvari
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_DCONF
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type)
 {
-    FF_UNUSED(instance, key, type)
+    FF_UNUSED(key, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_DCONF
 
-FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
+FFvariant ffSettingsGet(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
 {
-    FFvariant gsettings = ffSettingsGetGSettings(instance, gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
+    FFvariant gsettings = ffSettingsGetGSettings(gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
 
     if(
         (type == FF_VARIANT_TYPE_BOOL && gsettings.boolValueSet) ||
         (type != FF_VARIANT_TYPE_BOOL && gsettings.strValue != NULL)
     ) return gsettings;
 
-    return ffSettingsGetDConf(instance, dconfKey, type);
+    return ffSettingsGetDConf(dconfKey, type);
 }
 
 #ifdef FF_HAVE_XFCONF
@@ -241,9 +241,9 @@ typedef struct XFConfData
     FF_LIBRARY_SYMBOL(xfconf_init)
 } XFConfData;
 
-static const XFConfData* getXFConfData(const FFinstance* instance)
+static const XFConfData* getXFConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance.config.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get)
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_has_property)
@@ -258,9 +258,9 @@ static const XFConfData* getXFConfData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type)
 {
-    const XFConfData* data = getXFConfData(instance);
+    const XFConfData* data = getXFConfData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -281,9 +281,9 @@ FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelNam
     return FF_VARIANT_NULL;
 }
 #else //FF_HAVE_XFCONF
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type)
 {
-    FF_UNUSED(instance, channelName, propertyName, type)
+    FF_UNUSED(channelName, propertyName, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_XFCONF
@@ -303,9 +303,9 @@ typedef struct SQLiteData
     FF_LIBRARY_SYMBOL(sqlite3_close)
 } SQLiteData;
 
-static const SQLiteData* getSQLiteData(const FFinstance* instance)
+static const SQLiteData* getSQLiteData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance->config.libSQLite3, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance.config.libSQLite3, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_open_v2)
     FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_prepare_v2)
@@ -319,12 +319,12 @@ static const SQLiteData* getSQLiteData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query)
 {
     if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
         return 0;
 
-    const SQLiteData* data = getSQLiteData(instance);
+    const SQLiteData* data = getSQLiteData();
     if(data == NULL)
         return 0;
 
@@ -354,12 +354,12 @@ int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, cons
     return result;
 }
 
-bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result)
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result)
 {
     if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
         return false;
 
-    const SQLiteData* data = getSQLiteData(instance);
+    const SQLiteData* data = getSQLiteData();
     if(data == NULL)
         return false;
 
@@ -389,14 +389,14 @@ bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath,
     return true;
 }
 #else //FF_HAVE_SQLITE3
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query)
 {
-    FF_UNUSED(instance, dbPath, query)
+    FF_UNUSED(dbPath, query)
     return 0;
 }
-bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result)
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result)
 {
-    FF_UNUSED(instance, dbPath, query, result)
+    FF_UNUSED(dbPath, query, result)
     return false;
 }
 #endif //FF_HAVE_SQLITE3

src/common/settings.h

@@ -25,13 +25,13 @@ typedef union FFvariant
 
 #define FF_VARIANT_NULL ((FFvariant){.strValue = NULL})
 
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type);
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type);
-FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type);
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type);
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type);
+FFvariant ffSettingsGet(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type);
 
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query);
-bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result);
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query);
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result);
 
 #ifdef __ANDROID__
 bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);

src/common/thread.h

@@ -19,6 +19,7 @@
             return (FFThreadType)_beginthreadex(NULL, 0, func, data, 0, NULL);
         }
         #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType) static __stdcall unsigned fn ## ThreadMain (void* data) { fn((paramType)data); return 0; }
+        #define FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(fn) static __stdcall unsigned fn ## ThreadMain () { fn(); return 0; }
         static inline void ffThreadDetach(FFThreadType thread) { CloseHandle(thread); }
         static inline void ffThreadJoin(FFThreadType thread) { WaitForSingleObject(thread, 0xffffffff /*INFINITE*/); }
     #else
@@ -34,6 +35,7 @@
             return newThread;
         }
         #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType) static void* fn ## ThreadMain (void* data) { fn((paramType)data); return NULL; }
+        #define FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(fn) static void* fn ## ThreadMain () { fn(); return NULL; }
         static inline void ffThreadDetach(FFThreadType thread) { pthread_detach(thread); }
         static inline void ffThreadJoin(FFThreadType thread) { pthread_join(thread, NULL); }
     #endif

src/detection/battery/battery.h

@@ -17,6 +17,6 @@ typedef struct BatteryResult
     double temperature;
 } BatteryResult;
 
-const char* ffDetectBattery(FFinstance* instance, FFBatteryOptions* options, FFlist* results);
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results);
 
 #endif

src/detection/battery/battery_android.c

@@ -7,7 +7,7 @@
 #define FF_TERMUX_API_PATH FASTFETCH_TARGET_DIR_ROOT "/libexec/termux-api"
 #define FF_TERMUX_API_PARAM "BatteryStatus"
 
-const char* ffDetectBattery(FF_MAYBE_UNUSED FFinstance* instance, FFBatteryOptions* options, FFlist* results)
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
 

src/detection/battery/battery_apple.c

@@ -5,7 +5,7 @@
 
 #include <IOKit/IOKitLib.h>
 
-static double detectBatteryTemp()
+static double detectBatteryTemp(void)
 {
     FF_LIST_AUTO_DESTROY temps = ffListCreate(sizeof(FFTempValue));
 
@@ -27,7 +27,7 @@ static double detectBatteryTemp()
     return result;
 }
 
-const char* ffDetectBattery(FF_MAYBE_UNUSED FFinstance* instance, FFBatteryOptions* options, FFlist* results)
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
     CFMutableDictionaryRef matchDict = IOServiceMatching("AppleSmartBattery");
     if (matchDict == NULL)

src/detection/battery/battery_bsd.c

@@ -7,7 +7,7 @@
 #include <sys/fcntl.h>
 #include <unistd.h>
 
-const char* ffDetectBattery(FF_MAYBE_UNUSED FFinstance* instance, FF_MAYBE_UNUSED FFBatteryOptions* options, FFlist* results)
+const char* ffDetectBattery(FF_MAYBE_UNUSED FFBatteryOptions* options, FFlist* results)
 {
     //https://www.freebsd.org/cgi/man.cgi?acpi_battery(4)
     //https://gitlab.xfce.org/panel-plugins/xfce4-battery-plugin/-/blob/master/panel-plugin/libacpi.c

src/detection/battery/battery_linux.c

@@ -68,7 +68,7 @@ static void parseBattery(FFstrbuf* dir, FFlist* results)
     result->temperature = FF_BATTERY_TEMP_UNSET;
 }
 
-const char* ffDetectBattery(FF_MAYBE_UNUSED FFinstance* instance, FFBatteryOptions* options, FFlist* results)
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
     FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
 

src/detection/battery/battery_nosupport.c

@@ -1,8 +1,8 @@
 #include "fastfetch.h"
 #include "battery.h"
 
-const char* ffDetectBattery(FFinstance* instance, FFBatteryOptions* options, FFlist* results)
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
-    FF_UNUSED(instance, options, results)
+    FF_UNUSED(options, results)
     return "Not supported on this platform";
 }

src/detection/battery/battery_windows.c

@@ -30,9 +30,9 @@ static inline void wrapSetupDiDestroyDeviceInfoList(HDEVINFO* hdev)
         SetupDiDestroyDeviceInfoList(*hdev);
 }
 
-const char* ffDetectBattery(FFinstance* instance, FFBatteryOptions* options, FFlist* results)
+const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
-    if(instance->config.allowSlowOperations)
+    if(instance.config.allowSlowOperations)
     {
         //https://learn.microsoft.com/en-us/windows/win32/power/enumerating-battery-devices
         HDEVINFO hdev __attribute__((__cleanup__(wrapSetupDiDestroyDeviceInfoList))) =

src/detection/bluetooth/bluetooth.h

@@ -14,6 +14,6 @@ typedef struct FFBluetoothDevice
     bool connected;
 } FFBluetoothDevice;
 
-const char* ffDetectBluetooth(const FFinstance* instance, FFlist* devices /* FFBluetoothDevice */);
+const char* ffDetectBluetooth(FFlist* devices /* FFBluetoothDevice */);
 
 #endif

src/detection/bluetooth/bluetooth_apple.m

@@ -2,7 +2,7 @@
 
 #import <IOBluetooth/IOBluetooth.h>
 
-const char* ffDetectBluetooth(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* FFBluetoothDevice */)
+const char* ffDetectBluetooth(FFlist* devices /* FFBluetoothDevice */)
 {
     NSArray<IOBluetoothDevice*>* ioDevices = IOBluetoothDevice.pairedDevices;
     if(!ioDevices)

src/detection/bluetooth/bluetooth_linux.c

@@ -167,10 +167,10 @@ static void detectBluetoothRoot(FFlist* devices, FFDBusData* dbus, DBusMessageIt
     }
 }
 
-static const char* detectBluetooth(const FFinstance* instance, FFlist* devices)
+static const char* detectBluetooth(FFlist* devices)
 {
     FFDBusData dbus;
-    const char* error = ffDBusLoadData(instance, DBUS_BUS_SYSTEM, &dbus);
+    const char* error = ffDBusLoadData(DBUS_BUS_SYSTEM, &dbus);
     if(error)
         return error;
 
@@ -193,12 +193,11 @@ static const char* detectBluetooth(const FFinstance* instance, FFlist* devices)
 
 #endif
 
-const char* ffDetectBluetooth(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* FFBluetoothDevice */)
+const char* ffDetectBluetooth(FFlist* devices /* FFBluetoothDevice */)
 {
     #ifdef FF_HAVE_DBUS
-        return detectBluetooth(instance, devices);
+        return detectBluetooth(devices);
     #else
-        FF_UNUSED(instance);
         return "Fastfetch was compiled without DBus support";
     #endif
 }

src/detection/bluetooth/bluetooth_nosupport.c

@@ -1,6 +1,6 @@
 #include "bluetooth.h"
 
-const char* ffDetectBluetooth(FF_MAYBE_UNUSED const FFinstance* instance, FF_MAYBE_UNUSED FFlist* devices /* FFBluetoothDevice */)
+const char* ffDetectBluetooth(FF_MAYBE_UNUSED FFlist* devices /* FFBluetoothDevice */)
 {
     return "Not supported on this platform";
 }

src/detection/bluetooth/bluetooth_windows.c

@@ -7,7 +7,7 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpointer-sign"
 
-const char* ffDetectBluetooth(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* FFBluetoothDevice */)
+const char* ffDetectBluetooth(FFlist* devices /* FFBluetoothDevice */)
 {
     BLUETOOTH_DEVICE_SEARCH_PARAMS btsp = {
         .fReturnConnected = TRUE,

src/detection/chassis/chassis_windows.cpp

@@ -52,5 +52,5 @@ extern "C"
 const char* ffDetectChassis(FFChassisResult* result)
 {
     return detectWithRegistry(result);
-    // TODO: if (instance->config.allowSlowOperations) detectWithWmi(result);
+    // TODO: if (instance.config.allowSlowOperations) detectWithWmi(result);
 }

src/detection/cpu/cpu.c

@@ -1,11 +1,11 @@
 #include "cpu.h"
 #include "detection/internal.h"
 
-const char* ffDetectCPUImpl(const FFinstance* instance, const FFCPUOptions* options, FFCPUResult* cpu);
+const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu);
 
-const char* ffDetectCPU(const FFinstance* instance, const FFCPUOptions* options, FFCPUResult* cpu)
+const char* ffDetectCPU(const FFCPUOptions* options, FFCPUResult* cpu)
 {
-    const char* error = ffDetectCPUImpl(instance, options, cpu);
+    const char* error = ffDetectCPUImpl(options, cpu);
     if (error) return error;
 
     const char* removeStrings[] = {

src/detection/cpu/cpu.h

@@ -22,6 +22,6 @@ typedef struct FFCPUResult
     double temperature;
 } FFCPUResult;
 
-const char* ffDetectCPU(const FFinstance* instance, const FFCPUOptions* options, FFCPUResult* cpu);
+const char* ffDetectCPU(const FFCPUOptions* options, FFCPUResult* cpu);
 
 #endif

src/detection/cpu/cpu_apple.c

@@ -40,7 +40,7 @@ static double detectCpuTemp(const FFstrbuf* cpuName)
     return result;
 }
 
-const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFinstance* instance, const FFCPUOptions* options, FFCPUResult* cpu)
+const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
     if (ffSysctlGetString("machdep.cpu.brand_string", &cpu->name) != NULL)
         return "sysctlbyname(machdep.cpu.brand_string) failed";

src/detection/cpu/cpu_bsd.c

@@ -2,7 +2,7 @@
 #include "common/sysctl.h"
 #include "detection/temps/temps_bsd.h"
 
-const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFinstance* instance, const FFCPUOptions* options, FFCPUResult* cpu)
+const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
     if (ffSysctlGetString("hw.model", &cpu->name))
         return "sysctlbyname(hw.model) failed";

src/detection/cpu/cpu_linux.c

@@ -104,7 +104,7 @@ static void parseIsa(FFstrbuf* cpuIsa)
     }
 }
 
-const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFinstance* instance, const FFCPUOptions* options, FFCPUResult* cpu)
+const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
     cpu->temperature = options->temp ? detectCPUTemp() : FF_CPU_TEMP_UNSET;
 

src/detection/cpu/cpu_windows.c

@@ -3,7 +3,7 @@
 #include "util/windows/registry.h"
 #include "util/mallocHelper.h"
 
-const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFinstance* instance, const FFCPUOptions* options, FFCPUResult* cpu)
+const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
     {
         DWORD length = 0;

src/detection/cpuusage/cpuusage.c

@@ -9,7 +9,7 @@ const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll);
 
 static uint64_t inUseAll1, totalAll1;
 
-void ffPrepareCPUUsage()
+void ffPrepareCPUUsage(void)
 {
     ffGetCpuUsageInfo(&inUseAll1, &totalAll1);
 }

src/detection/cursor/cursor.h

@@ -12,6 +12,6 @@ typedef struct FFCursorResult
     FFstrbuf error;
 } FFCursorResult;
 
-void ffDetectCursor(const FFinstance* instance, FFCursorResult* result);
+void ffDetectCursor(FFCursorResult* result);
 
 #endif

src/detection/cursor/cursor_apple.m

@@ -17,10 +17,10 @@ static void appendColor(FFstrbuf* str, NSDictionary* color)
         ffStrbufAppendF(str, "#%02X%02X%02X%02X", r, g, b, a);
 }
 
-void ffDetectCursor(const FFinstance* instance, FFCursorResult* result)
+void ffDetectCursor(FFCursorResult* result)
 {
     NSError* error;
-    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/com.apple.universalaccess.plist", instance->state.platform.homeDir.chars];
+    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/com.apple.universalaccess.plist", instance.state.platform.homeDir.chars];
     NSDictionary* dict = [NSDictionary dictionaryWithContentsOfURL:[NSURL URLWithString:fileName]
                                        error:&error];
     if(error)

src/detection/cursor/cursor_linux.c

@@ -9,15 +9,15 @@
 
 #include <stdlib.h>
 
-static bool detectCursorGTK(const FFinstance* instance, FFCursorResult* result)
+static bool detectCursorGTK(FFCursorResult* result)
 {
-    const FFGTKResult* gtk = ffDetectGTK4(instance);
+    const FFGTKResult* gtk = ffDetectGTK4();
 
     if(gtk->cursor.length == 0)
-        gtk = ffDetectGTK3(instance);
+        gtk = ffDetectGTK3();
 
     if(gtk->cursor.length == 0)
-        gtk = ffDetectGTK2(instance);
+        gtk = ffDetectGTK2();
 
     if(gtk->cursor.length == 0)
         return false;
@@ -27,9 +27,9 @@ static bool detectCursorGTK(const FFinstance* instance, FFCursorResult* result)
     return true;
 }
 
-static void detectCursorFromConfigFile(const FFinstance* instance, const char* relativeFilePath, const char* themeStart, const char* themeDefault, const char* sizeStart, const char* sizeDefault, FFCursorResult* result)
+static void detectCursorFromConfigFile(const char* relativeFilePath, const char* themeStart, const char* themeDefault, const char* sizeStart, const char* sizeDefault, FFCursorResult* result)
 {
-    if(ffParsePropFileConfigValues(instance, relativeFilePath, 2, (FFpropquery[]) {
+    if(ffParsePropFileConfigValues(relativeFilePath, 2, (FFpropquery[]) {
         {themeStart, &result->theme},
         {sizeStart, &result->size}
     })) {
@@ -45,9 +45,9 @@ static void detectCursorFromConfigFile(const FFinstance* instance, const char* r
         ffStrbufAppendF(&result->error, "Couldn't find cursor in %s", relativeFilePath);
 }
 
-static bool detectCursorFromXResources(const FFinstance* instance, FFCursorResult* result)
+static bool detectCursorFromXResources(FFCursorResult* result)
 {
-    ffParsePropFileHomeValues(instance, ".Xresources", 2, (FFpropquery[]) {
+    ffParsePropFileHomeValues(".Xresources", 2, (FFpropquery[]) {
         {"Xcursor.theme :", &result->theme},
         {"Xcursor.size :", &result->size}
     });
@@ -55,9 +55,8 @@ static bool detectCursorFromXResources(const FFinstance* instance, FFCursorResul
     return result->theme.length > 0;
 }
 
-static bool detectCursorFromEnv(const FFinstance* instance, FFCursorResult* result)
+static bool detectCursorFromEnv(FFCursorResult* result)
 {
-    FF_UNUSED(instance);
     const char* xcursor_theme = getenv("XCURSOR_THEME");
 
     if(!ffStrSet(xcursor_theme))
@@ -69,23 +68,23 @@ static bool detectCursorFromEnv(const FFinstance* instance, FFCursorResult* resu
     return true;
 }
 
-void ffDetectCursor(const FFinstance* instance, FFCursorResult* result)
+void ffDetectCursor(FFCursorResult* result)
 {
-    const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
     if(ffStrbufCompS(&wmde->wmPrettyName, FF_WM_PRETTY_WSLG) == 0)
         ffStrbufAppendS(&result->error, "WSLg uses native windows cursor");
     else if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
         ffStrbufAppendS(&result->error, "Cursor isn't supported in TTY");
     else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_PLASMA) == 0)
-        detectCursorFromConfigFile(instance, "kcminputrc", "cursorTheme =", "Breeze", "cursorSize =", "24", result);
+        detectCursorFromConfigFile("kcminputrc", "cursorTheme =", "Breeze", "cursorSize =", "24", result);
     else if(ffStrbufStartsWithIgnCaseS(&wmde->dePrettyName, FF_DE_PRETTY_LXQT))
-        detectCursorFromConfigFile(instance, "lxqt/session.conf", "cursor_theme =", "Adwaita", "cursor_size =", "24", result);
+        detectCursorFromConfigFile("lxqt/session.conf", "cursor_theme =", "Adwaita", "cursor_size =", "24", result);
     else if(
-        !detectCursorGTK(instance, result) &&
-        !detectCursorFromEnv(instance, result) &&
-        !ffParsePropFileHome(instance, ".icons/default/index.theme", "Inherits =", &result->theme) &&
-        !detectCursorFromXResources(instance, result) &&
-        !ffParsePropFileData(instance, "icons/default/index.theme", "Inherits =", &result->theme)
+        !detectCursorGTK(result) &&
+        !detectCursorFromEnv(result) &&
+        !ffParsePropFileHome(".icons/default/index.theme", "Inherits =", &result->theme) &&
+        !detectCursorFromXResources(result) &&
+        !ffParsePropFileData("icons/default/index.theme", "Inherits =", &result->theme)
     ) ffStrbufAppendS(&result->error, "Couldn't find cursor");
 }

src/detection/cursor/cursor_nosupport.c

@@ -1,7 +1,6 @@
 #include "cursor.h"
 
-void ffDetectCursor(const FFinstance* instance, FFCursorResult* result)
+void ffDetectCursor(FF_MAYBE_UNUSED FFCursorResult* result)
 {
-    FF_UNUSED(instance, result);
     ffStrbufInitS(&result->error, "Not supported on this platform");
 }

src/detection/cursor/cursor_windows.c

@@ -2,10 +2,8 @@
 
 #include "util/windows/registry.h"
 
-void ffDetectCursor(const FFinstance* instance, FFCursorResult* result)
+void ffDetectCursor(FFCursorResult* result)
 {
-    FF_UNUSED(instance);
-
     FF_HKEY_AUTO_DESTROY hKey;
     if(ffRegOpenKeyForRead(HKEY_CURRENT_USER, L"Control Panel\\Cursors", &hKey, &result->error))
     {

src/detection/datetime/datetime.c

@@ -4,10 +4,8 @@
 
 #include <time.h>
 
-const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance)
+const FFDateTimeResult* ffDetectDateTime(void)
 {
-    FF_UNUSED(instance); //We may need it later for additional configuration
-
     static FFDateTimeResult result;
     static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
     static bool init = false;

src/detection/datetime/datetime.h

@@ -30,6 +30,6 @@ typedef struct FFDateTimeResult
     FFstrbuf secondPretty; //37
 } FFDateTimeResult;
 
-const FFDateTimeResult* ffDetectDateTime(const FFinstance* instance);
+const FFDateTimeResult* ffDetectDateTime();
 
 #endif

src/detection/displayserver/displayserver.c

@@ -30,11 +30,11 @@ bool ffdsAppendDisplay(
     return true;
 }
 
-void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance);
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds);
 
-const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance)
+const FFDisplayServerResult* ffConnectDisplayServer()
 {
     FF_DETECTION_INTERNAL_GUARD(FFDisplayServerResult,
-        ffConnectDisplayServerImpl(&result, instance);
+        ffConnectDisplayServerImpl(&result);
     );
 }

src/detection/displayserver/displayserver.h

@@ -71,7 +71,7 @@ typedef struct FFDisplayServerResult
     FFlist displays; //List of FFDisplayResult
 } FFDisplayServerResult;
 
-const FFDisplayServerResult* ffConnectDisplayServer(const FFinstance* instance);
+const FFDisplayServerResult* ffConnectDisplayServer();
 
 bool ffdsAppendDisplay(
     FFDisplayServerResult* result,

src/detection/displayserver/displayserver_apple.c

@@ -100,15 +100,13 @@ static void detectWMPlugin(FFstrbuf* name)
     }
 }
 
-void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds)
 {
-    FF_UNUSED(instance);
-
     ffStrbufInitS(&ds->wmProcessName, "WindowServer");
     ffStrbufInitS(&ds->wmPrettyName, "Quartz Compositor");
     ffStrbufInit(&ds->wmProtocolName);
 
-    if(instance->config.allowSlowOperations)
+    if(instance.config.allowSlowOperations)
     {
         FF_STRBUF_AUTO_DESTROY name;
         ffStrbufInit(&name);

src/detection/displayserver/displayserver_nosupport.c

@@ -1,9 +1,7 @@
 #include "displayserver.h"
 
-void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds)
 {
-    FF_UNUSED(instance);
-
     ffStrbufInit(&ds->wmProcessName);
     ffStrbufInit(&ds->wmPrettyName);
     ffStrbufInit(&ds->wmProtocolName);

src/detection/displayserver/displayserver_windows.c

@@ -131,7 +131,7 @@ static void detectDisplays(FFDisplayServerResult* ds)
     }
 }
 
-void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds)
 {
     BOOL enabled;
     if(SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled == TRUE)
@@ -153,7 +153,7 @@ void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* ins
     detectDisplays(ds);
 
     //https://github.com/hykilpikonna/hyfetch/blob/master/neofetch#L2067
-    const FFOSResult* os = ffDetectOS(instance);
+    const FFOSResult* os = ffDetectOS();
     if(
         ffStrbufEqualS(&os->version, "11") ||
         ffStrbufEqualS(&os->version, "10") ||

src/detection/displayserver/linux/displayserver_linux.c

@@ -64,7 +64,7 @@ static void parseDRM(FFDisplayServerResult* result)
     closedir(dirp);
 }
 
-void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* instance)
+void ffConnectDisplayServerImpl(FFDisplayServerResult* ds)
 {
     ffStrbufInit(&ds->wmProcessName);
     ffStrbufInit(&ds->wmPrettyName);
@@ -76,23 +76,23 @@ void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* ins
 
     //We try wayland as our prefered display server, as it supports the most features.
     //This method can't detect the name of our WM / DE
-    ffdsConnectWayland(instance, ds);
+    ffdsConnectWayland(ds);
 
     //Try the x11 libs, from most feature rich to least.
     //We use the display list to detect if a connection is needed.
     //They respect wmProtocolName, and only detect display if it is set.
 
     if(ds->displays.length == 0)
-        ffdsConnectXcbRandr(instance, ds);
+        ffdsConnectXcbRandr(ds);
 
     if(ds->displays.length == 0)
-        ffdsConnectXrandr(instance, ds);
+        ffdsConnectXrandr(ds);
 
     if(ds->displays.length == 0)
-        ffdsConnectXcb(instance, ds);
+        ffdsConnectXcb(ds);
 
     if(ds->displays.length == 0)
-        ffdsConnectXlib(instance, ds);
+        ffdsConnectXlib(ds);
 
     //This display detection method is display server independent.
     //Use it if all connections failed
@@ -100,5 +100,5 @@ void ffConnectDisplayServerImpl(FFDisplayServerResult* ds, const FFinstance* ins
         parseDRM(ds);
 
     //This fills in missing information about WM / DE by using env vars and iterating processes
-    ffdsDetectWMDE(instance, ds);
+    ffdsDetectWMDE(ds);
 }

src/detection/displayserver/linux/displayserver_linux.h

@@ -5,14 +5,14 @@
 
 #include "detection/displayserver/displayserver.h"
 
-void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result);
+void ffdsConnectWayland(FFDisplayServerResult* result);
 
-void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* result);
-void ffdsConnectXcb(const FFinstance* instance, FFDisplayServerResult* result);
+void ffdsConnectXcbRandr(FFDisplayServerResult* result);
+void ffdsConnectXcb(FFDisplayServerResult* result);
 
-void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result);
-void ffdsConnectXlib(const FFinstance* instance, FFDisplayServerResult* result);
+void ffdsConnectXrandr(FFDisplayServerResult* result);
+void ffdsConnectXlib(FFDisplayServerResult* result);
 
-void ffdsDetectWMDE(const FFinstance* instance, FFDisplayServerResult* result);
+void ffdsDetectWMDE(FFDisplayServerResult* result);
 
 #endif

src/detection/displayserver/linux/wayland.c

@@ -201,9 +201,9 @@ static void waylandGlobalAddListener(void* data, struct wl_registry* registry, u
         waylandOutputHandler(wldata, registry, name, version);
 }
 
-bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)
+bool detectWayland(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(wayland, &instance->config.libWayland, false, "libwayland-client" FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD(wayland, &instance.config.libWayland, false, "libwayland-client" FF_LIBRARY_EXTENSION, 1)
 
     FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_connect, false)
     FF_LIBRARY_LOAD_SYMBOL(wayland, wl_display_get_fd, false)
@@ -255,17 +255,15 @@ bool detectWayland(const FFinstance* instance, FFDisplayServerResult* result)
 }
 #endif
 
-void ffdsConnectWayland(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectWayland(FFDisplayServerResult* result)
 {
     //Wayland requires this to be set
     if(getenv("XDG_RUNTIME_DIR") == NULL)
         return;
 
     #ifdef FF_HAVE_WAYLAND
-        if(detectWayland(instance, result))
+        if(detectWayland(result))
             return;
-    #else
-        FF_UNUSED(instance);
     #endif
 
     const char* xdgSessionType = getenv("XDG_SESSION_TYPE");

src/detection/displayserver/linux/wmde.c

@@ -11,7 +11,7 @@
 #include <unistd.h>
 #include <dirent.h>
 
-static const char* parseEnv()
+static const char* parseEnv(void)
 {
     const char* env;
 
@@ -126,7 +126,7 @@ static void applyBetterWM(FFDisplayServerResult* result, const char* processName
         ffStrbufAppend(&result->wmPrettyName, &result->wmProcessName);
 }
 
-static void getKDE(const FFinstance* instance, FFDisplayServerResult* result)
+static void getKDE(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "plasmashell");
     ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_PLASMA);
@@ -135,9 +135,9 @@ static void getKDE(const FFinstance* instance, FFDisplayServerResult* result)
         {"X-KDE-PluginInfo-Version =", &result->deVersion}
     });
     if(result->deVersion.length == 0)
-        ffParsePropFileData(instance, "xsessions/plasma.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+        ffParsePropFileData("xsessions/plasma.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
     if(result->deVersion.length == 0)
-        ffParsePropFileData(instance, "xsessions/plasma5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+        ffParsePropFileData("xsessions/plasma5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
     if(result->deVersion.length == 0)
     {
         ffParsePropFileValues("/usr/share/wayland-sessions/plasma.desktop", 1, (FFpropquery[]) {
@@ -145,11 +145,11 @@ static void getKDE(const FFinstance* instance, FFDisplayServerResult* result)
         });
     }
     if(result->deVersion.length == 0)
-        ffParsePropFileData(instance, "wayland-sessions/plasmawayland.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+        ffParsePropFileData("wayland-sessions/plasmawayland.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
     if(result->deVersion.length == 0)
-        ffParsePropFileData(instance, "wayland-sessions/plasmawayland5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
+        ffParsePropFileData("wayland-sessions/plasmawayland5.desktop", "X-KDE-PluginInfo-Version =", &result->deVersion);
 
-    if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
+    if(result->deVersion.length == 0 && instance.config.allowSlowOperations)
     {
         if (ffProcessAppendStdOut(&result->deVersion, (char* const[]){
             "plasmashell",
@@ -163,7 +163,7 @@ static void getKDE(const FFinstance* instance, FFDisplayServerResult* result)
     applyBetterWM(result, getenv("KDEWM"));
 }
 
-static void getGnome(const FFinstance* instance, FFDisplayServerResult* result)
+static void getGnome(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "gnome-shell");
     const char* sessionMode = getenv("GNOME_SHELL_SESSION_MODE");
@@ -172,7 +172,7 @@ static void getGnome(const FFinstance* instance, FFDisplayServerResult* result)
     else
         ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_GNOME);
 
-    ffParsePropFileData(instance, "gnome-shell/org.gnome.Extensions", "version :", &result->deVersion);
+    ffParsePropFileData("gnome-shell/org.gnome.Extensions", "version :", &result->deVersion);
 
     if (result->deVersion.length == 0)
     {
@@ -185,14 +185,14 @@ static void getGnome(const FFinstance* instance, FFDisplayServerResult* result)
     }
 }
 
-static void getCinnamon(const FFinstance* instance, FFDisplayServerResult* result)
+static void getCinnamon(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "cinnamon");
     ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_CINNAMON);
-    ffParsePropFileData(instance, "applications/cinnamon.desktop", "X-GNOME-Bugzilla-Version =", &result->deVersion);
+    ffParsePropFileData("applications/cinnamon.desktop", "X-GNOME-Bugzilla-Version =", &result->deVersion);
 }
 
-static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
+static void getMate(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "mate-session");
     ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_MATE);
@@ -201,7 +201,7 @@ static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
     FF_STRBUF_AUTO_DESTROY minor = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY micro = ffStrbufCreate();
 
-    ffParsePropFileDataValues(instance, "mate-about/mate-version.xml", 3, (FFpropquery[]) {
+    ffParsePropFileDataValues("mate-about/mate-version.xml", 3, (FFpropquery[]) {
         {"<platform>", &major},
         {"<minor>", &minor},
         {"<micro>", &micro}
@@ -209,7 +209,7 @@ static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
 
     ffParseSemver(&result->deVersion, &major, &minor, &micro);
 
-    if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
+    if(result->deVersion.length == 0 && instance.config.allowSlowOperations)
     {
         ffProcessAppendStdOut(&result->deVersion, (char* const[]){
             "mate-session",
@@ -222,13 +222,13 @@ static void getMate(const FFinstance* instance, FFDisplayServerResult* result)
     }
 }
 
-static void getXFCE4(const FFinstance* instance, FFDisplayServerResult* result)
+static void getXFCE4(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "xfce4-session");
     ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_XFCE4);
-    ffParsePropFileData(instance, "gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version", &result->deVersion);
+    ffParsePropFileData("gtk-doc/html/libxfce4ui/index.html", "<div><p class=\"releaseinfo\">Version", &result->deVersion);
 
-    if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
+    if(result->deVersion.length == 0 && instance.config.allowSlowOperations)
     {
         //This is somewhat slow
         ffProcessAppendStdOut(&result->deVersion, (char* const[]){
@@ -243,18 +243,18 @@ static void getXFCE4(const FFinstance* instance, FFDisplayServerResult* result)
     }
 }
 
-static void getLXQt(const FFinstance* instance, FFDisplayServerResult* result)
+static void getLXQt(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "lxqt-session");
     ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_LXQT);
-    ffParsePropFileData(instance, "gconfig/lxqt.pc", "Version:", &result->deVersion);
+    ffParsePropFileData("gconfig/lxqt.pc", "Version:", &result->deVersion);
 
     if(result->deVersion.length == 0)
-        ffParsePropFileData(instance, "cmake/lxqt/lxqt-config.cmake", "set ( LXQT_VERSION", &result->deVersion);
+        ffParsePropFileData("cmake/lxqt/lxqt-config.cmake", "set ( LXQT_VERSION", &result->deVersion);
     if(result->deVersion.length == 0)
-        ffParsePropFileData(instance, "cmake/lxqt/lxqt-config-version.cmake", "set ( PACKAGE_VERSION", &result->deVersion);
+        ffParsePropFileData("cmake/lxqt/lxqt-config-version.cmake", "set ( PACKAGE_VERSION", &result->deVersion);
 
-    if(result->deVersion.length == 0 && instance->config.allowSlowOperations)
+    if(result->deVersion.length == 0 && instance.config.allowSlowOperations)
     {
         //This is really, really, really slow. Thank you, LXQt developers
         ffProcessAppendStdOut(&result->deVersion, (char* const[]){
@@ -269,39 +269,39 @@ static void getLXQt(const FFinstance* instance, FFDisplayServerResult* result)
 
     FF_STRBUF_AUTO_DESTROY wmProcessNameBuffer = ffStrbufCreate();
 
-    ffParsePropFileConfig(instance, "lxqt/session.conf", "window_manager =", &wmProcessNameBuffer);
+    ffParsePropFileConfig("lxqt/session.conf", "window_manager =", &wmProcessNameBuffer);
     applyBetterWM(result, wmProcessNameBuffer.chars);
 }
 
-static void getBudgie(const FFinstance* instance, FFDisplayServerResult* result)
+static void getBudgie(FFDisplayServerResult* result)
 {
     ffStrbufSetS(&result->deProcessName, "budgie-desktop");
     ffStrbufSetS(&result->dePrettyName, FF_DE_PRETTY_BUDGIE);
-    ffParsePropFileData(instance, "budgie/budgie-version.xml", "<str>", &result->deVersion);
+    ffParsePropFileData("budgie/budgie-version.xml", "<str>", &result->deVersion);
 }
 
-static void applyPrettyNameIfDE(const FFinstance* instance, FFDisplayServerResult* result, const char* name)
+static void applyPrettyNameIfDE(FFDisplayServerResult* result, const char* name)
 {
     if(!ffStrSet(name))
         return;
     else if(strcasestr(name, "plasma") != NULL)
-        getKDE(instance, result);
+        getKDE(result);
     else if(
         strcasecmp(name, "polkit-gnome") != 0 &&
         strcasecmp(name, "gnome-keyring") != 0 &&
         strcasestr(name, "gnome") != NULL
     )
-        getGnome(instance, result);
+        getGnome(result);
     else if(strcasestr(name, "cinnamon") != NULL)
-        getCinnamon(instance, result);
+        getCinnamon(result);
     else if(strcasestr(name, "xfce") != NULL)
-        getXFCE4(instance, result);
+        getXFCE4(result);
     else if(strcasestr(name, "mate") != NULL)
-        getMate(instance, result);
+        getMate(result);
     else if(strcasestr(name, "lxqt") != NULL)
-        getLXQt(instance, result);
+        getLXQt(result);
     else if(strcasestr(name, "budgie") != NULL)
-        getBudgie(instance, result);
+        getBudgie(result);
 }
 
 static void getWMProtocolNameFromEnv(FFDisplayServerResult* result)
@@ -337,7 +337,7 @@ static void getWMProtocolNameFromEnv(FFDisplayServerResult* result)
     }
 }
 
-static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* result)
+static void getFromProcDir(FFDisplayServerResult* result)
 {
     DIR* proc = opendir("/proc");
     if(proc == NULL)
@@ -382,7 +382,7 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
         ffStrbufSubstrBefore(&procPath, procPathLength);
 
         if(result->dePrettyName.length == 0)
-            applyPrettyNameIfDE(instance, result, processName.chars);
+            applyPrettyNameIfDE(result, processName.chars);
 
         if(result->wmPrettyName.length == 0)
             applyNameIfWM(result, processName.chars);
@@ -394,7 +394,7 @@ static void getFromProcDir(const FFinstance* instance, FFDisplayServerResult* re
     closedir(proc);
 }
 
-void ffdsDetectWMDE(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsDetectWMDE(FFDisplayServerResult* result)
 {
     //If all connections failed, use the environment variables to detect protocol name
     if(result->wmProtocolName.length == 0)
@@ -423,7 +423,7 @@ void ffdsDetectWMDE(const FFinstance* instance, FFDisplayServerResult* result)
 
     //Connecting to a display server only gives WM results, not DE results.
     //If we find it in the environment, use that.
-    applyPrettyNameIfDE(instance, result, env);
+    applyPrettyNameIfDE(result, env);
 
     //If WM was found by connection to the sever, and DE in the environment, we can return
     //This way we never call getFromProcDir(), which has slow initalization time
@@ -431,7 +431,7 @@ void ffdsDetectWMDE(const FFinstance* instance, FFDisplayServerResult* result)
         return;
 
     //Get missing WM / DE from processes.
-    getFromProcDir(instance, result);
+    getFromProcDir(result);
 
     //Return if both wm and de are set, or if env doesn't contain anything
     if(

src/detection/displayserver/linux/xcb.c

@@ -96,9 +96,9 @@ static void xcbDetectWMfromEWMH(XcbPropertyData* data, xcb_connection_t* connect
     free(wmName);
 }
 
-void ffdsConnectXcb(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXcb(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcb, &instance->config.libXcb, , "libxcb" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(xcb, &instance.config.libXcb, , "libxcb" FF_LIBRARY_EXTENSION, 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,)
@@ -142,10 +142,10 @@ void ffdsConnectXcb(const FFinstance* instance, FFDisplayServerResult* result)
 
 #else
 
-void ffdsConnectXcb(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXcb(FFDisplayServerResult* result)
 {
     //Do nothing. There are other implementations coming
-    FF_UNUSED(instance, result)
+    FF_UNUSED(result)
 }
 
 #endif
@@ -383,9 +383,9 @@ static void xcbRandrHandleScreen(XcbRandrData* data, xcb_screen_t* screen)
     );
 }
 
-void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXcbRandr(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xcbRandr, &instance->config.libXcbRandr, , "libxcb-randr" FF_LIBRARY_EXTENSION, 1)
+    FF_LIBRARY_LOAD(xcbRandr, &instance.config.libXcbRandr, , "libxcb-randr" FF_LIBRARY_EXTENSION, 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,)
@@ -440,10 +440,10 @@ void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* resu
 
 #else
 
-void ffdsConnectXcbRandr(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXcbRandr(FFDisplayServerResult* result)
 {
     //Do nothing. There are other implementations coming
-    FF_UNUSED(instance, result)
+    FF_UNUSED(result)
 }
 
 #endif

src/detection/displayserver/linux/xlib.c

@@ -58,9 +58,9 @@ static void x11DetectWMFromEWMH(X11PropertyData* data, Display* display, FFDispl
     data->ffXFree(wmWindow);
 }
 
-void ffdsConnectXlib(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXlib(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(x11, &instance->config.libX11, , "libX11" FF_LIBRARY_EXTENSION, 7, "libX11-xcb" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(x11, &instance.config.libX11, , "libX11" FF_LIBRARY_EXTENSION, 7, "libX11-xcb" FF_LIBRARY_EXTENSION, 2)
     FF_LIBRARY_LOAD_SYMBOL(x11, XOpenDisplay,)
     FF_LIBRARY_LOAD_SYMBOL(x11, XCloseDisplay,)
 
@@ -99,10 +99,10 @@ void ffdsConnectXlib(const FFinstance* instance, FFDisplayServerResult* result)
 
 #else
 
-void ffdsConnectXlib(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXlib(FFDisplayServerResult* result)
 {
     //Do nothing. WM / DE detection will use environment vars to detect as much as possible.
-    FF_UNUSED(instance, result);
+    FF_UNUSED(result);
 }
 
 #endif //FF_HAVE_X11
@@ -286,9 +286,9 @@ static void xrandrHandleScreen(XrandrData* data, Screen* screen)
     );
 }
 
-void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXrandr(FFDisplayServerResult* result)
 {
-    FF_LIBRARY_LOAD(xrandr, &instance->config.libXrandr, , "libXrandr" FF_LIBRARY_EXTENSION, 3)
+    FF_LIBRARY_LOAD(xrandr, &instance.config.libXrandr, , "libXrandr" FF_LIBRARY_EXTENSION, 3)
 
     FF_LIBRARY_LOAD_SYMBOL(xrandr, XOpenDisplay,)
     FF_LIBRARY_LOAD_SYMBOL(xrandr, XCloseDisplay,)
@@ -331,10 +331,10 @@ void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result
 
 #else
 
-void ffdsConnectXrandr(const FFinstance* instance, FFDisplayServerResult* result)
+void ffdsConnectXrandr(FFDisplayServerResult* result)
 {
     //Do nothing here. There are more x11 implementaions to come.
-    FF_UNUSED(instance, result);
+    FF_UNUSED(result);
 }
 
 #endif // FF_HAVE_XRANDR

src/detection/font/font.c

@@ -1,11 +1,11 @@
 #include "font.h"
 #include "detection/internal.h"
 
-const char* ffDetectFontImpl(const FFinstance* instance, FFFontResult* font);
+const char* ffDetectFontImpl(FFFontResult* font);
 
-const char* ffDetectFont(const FFinstance* instance, FFFontResult* font)
+const char* ffDetectFont(FFFontResult* font)
 {
-    const char* error = ffDetectFontImpl(instance, font);
+    const char* error = ffDetectFontImpl(font);
 
     if(error) return error;
 

src/detection/font/font.h

@@ -19,6 +19,6 @@ typedef struct FFFontResult
     FFstrbuf display;
 } FFFontResult;
 
-const char* ffDetectFont(const FFinstance* instance, FFFontResult* font);
+const char* ffDetectFont(FFFontResult* font);
 
 #endif

src/detection/font/font_apple.m

@@ -21,7 +21,7 @@ static void generateString(FFFontResult* font)
     }
 }
 
-const char* ffDetectFontImpl(FF_MAYBE_UNUSED const FFinstance* instance, FFFontResult* result)
+const char* ffDetectFontImpl(FFFontResult* result)
 {
     ffStrbufAppendS(&result->fonts[0], [NSFont systemFontOfSize:12].familyName.UTF8String);
     ffStrbufAppendS(&result->fonts[1], [NSFont userFontOfSize:12].familyName.UTF8String);

src/detection/font/font_linux.c

@@ -24,30 +24,30 @@ static void generateString(FFFontResult* font)
     ffParseGTK(&font->display, &font->fonts[1], &font->fonts[2], &font->fonts[3]);
 }
 
-const char* ffDetectFontImpl(const FFinstance* instance, FFFontResult* result)
+const char* ffDetectFontImpl(FFFontResult* result)
 {
-    const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
     if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
         return "Font isn't supported in TTY";
 
     FFfont qt;
-    ffFontInitQt(&qt, ffDetectQt(instance)->font.chars);
+    ffFontInitQt(&qt, ffDetectQt()->font.chars);
     ffStrbufAppend(&result->fonts[0], &qt.pretty);
     ffFontDestroy(&qt);
 
     FFfont gtk2;
-    ffFontInitPango(&gtk2, ffDetectGTK2(instance)->font.chars);
+    ffFontInitPango(&gtk2, ffDetectGTK2()->font.chars);
     ffStrbufAppend(&result->fonts[1], &gtk2.pretty);
     ffFontDestroy(&gtk2);
 
     FFfont gtk3;
-    ffFontInitPango(&gtk3, ffDetectGTK3(instance)->font.chars);
+    ffFontInitPango(&gtk3, ffDetectGTK3()->font.chars);
     ffStrbufAppend(&result->fonts[2], &gtk3.pretty);
     ffFontDestroy(&gtk3);
 
     FFfont gtk4;
-    ffFontInitPango(&gtk4, ffDetectGTK4(instance)->font.chars);
+    ffFontInitPango(&gtk4, ffDetectGTK4()->font.chars);
     ffStrbufAppend(&result->fonts[3], &gtk4.pretty);
     ffFontDestroy(&gtk4);
 

src/detection/font/font_nosupport.c

@@ -1,8 +1,8 @@
 #include "fastfetch.h"
 #include "font.h"
 
-const char* ffDetectFontImpl(const FFinstance* instance, FFFontResult* result)
+const char* ffDetectFontImpl(FF_MAYBE_UNUSED FFFontResult* result)
 {
-    FF_UNUSED(instance, result);
+    FF_UNUSED(result);
     return "Not supported on this platform";
 }

src/detection/font/font_windows.c

@@ -23,7 +23,7 @@ static void generateString(FFFontResult* font)
     ffStrbufAppendC(&font->display, ']');
 }
 
-const char* ffDetectFontImpl(FF_MAYBE_UNUSED const FFinstance* instance, FFFontResult* result)
+const char* ffDetectFontImpl(FFFontResult* result)
 {
     NONCLIENTMETRICSW info = { .cbSize = sizeof(info) };
     if(!SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0))

src/detection/gamepad/gamepad.h

@@ -11,6 +11,6 @@ typedef struct FFGamepadDevice
     FFstrbuf name;
 } FFGamepadDevice;
 
-const char* ffDetectGamepad(const FFinstance* instance, FFlist* devices /* List of FFGamepadDevice */);
+const char* ffDetectGamepad(FFlist* devices /* List of FFGamepadDevice */);
 
 #endif

src/detection/gamepad/gamepad_apple.c

@@ -15,7 +15,7 @@ static void enumSet(const void* value, void *context)
     ffCfStrGetString(product, &device->name);
 }
 
-const char* ffDetectGamepad(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* List of FFGamepadDevice */)
+const char* ffDetectGamepad(FFlist* devices /* List of FFGamepadDevice */)
 {
     IOHIDManagerRef FF_CFTYPE_AUTO_RELEASE manager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
     if (IOHIDManagerOpen(manager, kIOHIDOptionsTypeNone) != kIOReturnSuccess)

src/detection/gamepad/gamepad_bsd.c

@@ -8,7 +8,7 @@
 
 #define MAX_UHID_JOYS 64
 
-const char* ffDetectGamepad(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* List of FFGamepadDevice */)
+const char* ffDetectGamepad(FFlist* devices /* List of FFGamepadDevice */)
 {
     char path[16];
     for (int i = 0; i < MAX_UHID_JOYS; i++)

src/detection/gamepad/gamepad_linux.c

@@ -5,7 +5,7 @@
 #include <dirent.h>
 #include <ctype.h>
 
-const char* ffDetectGamepad(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* List of FFGamepadDevice */)
+const char* ffDetectGamepad(FFlist* devices /* List of FFGamepadDevice */)
 {
     DIR* dirp = opendir("/sys/class/input/");
     if(dirp == NULL)

src/detection/gamepad/gamepad_nosupport.c

@@ -1,6 +1,6 @@
 #include "gamepad.h"
 
-const char* ffDetectGamepad(FF_MAYBE_UNUSED const FFinstance* instance, FF_MAYBE_UNUSED FFlist* devices /* List of FFGamepadDevice */)
+const char* ffDetectGamepad(FF_MAYBE_UNUSED FFlist* devices /* List of FFGamepadDevice */)
 {
     return "Not supported on this platform";
 }

src/detection/gamepad/gamepad_windows.c

@@ -87,7 +87,7 @@ static const char* detectKnownGamepad(uint32_t vendorId, uint32_t productId)
     }
 }
 
-const char* ffDetectGamepad(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* List of FFGamepadDevice */)
+const char* ffDetectGamepad(FFlist* devices /* List of FFGamepadDevice */)
 {
     UINT nDevices = 0;
     if (GetRawInputDeviceList(NULL, &nDevices, sizeof(RAWINPUTDEVICELIST)))

src/detection/gpu/gpu.c

@@ -30,14 +30,14 @@ const char* ffGetGPUVendorString(unsigned vendorId)
     return NULL;
 }
 
-const char* ffDetectGPU(const FFinstance* instance, const FFGPUOptions* options, FFlist* result)
+const char* ffDetectGPU(const FFGPUOptions* options, FFlist* result)
 {
     if (!options->forceVulkan)
     {
-        const char* error = ffDetectGPUImpl(instance, options, result);
+        const char* error = ffDetectGPUImpl(options, result);
         if (!error) return NULL;
     }
-    FFVulkanResult* vulkan = ffDetectVulkan(instance);
+    FFVulkanResult* vulkan = ffDetectVulkan();
     if (vulkan->error) return "GPU detection failed";
     ffListDestroy(result);
     ffListInitMove(result, &vulkan->gpus);

src/detection/gpu/gpu.h

@@ -33,8 +33,8 @@ typedef struct FFGPUResult
     uint32_t vulkanDeviceId; // Only used for vulkan
 } FFGPUResult;
 
-const char* ffDetectGPU(const FFinstance* instance, const FFGPUOptions* options, FFlist* result);
-const char* ffDetectGPUImpl(const FFinstance* instance, const FFGPUOptions* options, FFlist* gpus);
+const char* ffDetectGPU(const FFGPUOptions* options, FFlist* result);
+const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus);
 
 const char* ffGetGPUVendorString(unsigned vendorId);
 

src/detection/gpu/gpu_apple.c

@@ -38,7 +38,7 @@ static double detectGpuTemp(const FFstrbuf* gpuName)
     return result;
 }
 
-const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFinstance* instance, const FFGPUOptions* options, FFlist* gpus)
+const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
 {
     CFMutableDictionaryRef matchDict = IOServiceMatching(kIOAcceleratorClassName);
     io_iterator_t iterator;

src/detection/gpu/gpu_linux.c

@@ -44,7 +44,7 @@ static void pciDetectVendorName(FFGPUResult* gpu, PCIData* pci, struct pci_dev*
         ffStrbufSetS(&gpu->vendor, FF_GPU_VENDOR_NAME_NVIDIA);
 }
 
-static void drmDetectDeviceName(const FFinstance* instance, FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
+static void drmDetectDeviceName(FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
 {
     u8 revId = 0;
     bool revIdSet = false;
@@ -65,7 +65,7 @@ static void drmDetectDeviceName(const FFinstance* instance, FFGPUResult* gpu, PC
     }
 
     FF_STRBUF_AUTO_DESTROY query = ffStrbufCreateF("%X, %X,", device->device_id, revId);
-    ffParsePropFileData(instance, "libdrm/amdgpu.ids", query.chars, &gpu->name);
+    ffParsePropFileData("libdrm/amdgpu.ids", query.chars, &gpu->name);
 
     const char* removeStrings[] = {
         "AMD ", "ATI ",
@@ -75,11 +75,11 @@ static void drmDetectDeviceName(const FFinstance* instance, FFGPUResult* gpu, PC
     ffStrbufRemoveStringsA(&gpu->name, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
 }
 
-static void pciDetectDeviceName(const FFinstance* instance, FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
+static void pciDetectDeviceName(FFGPUResult* gpu, PCIData* pci, struct pci_dev* device)
 {
     if(ffStrbufCompS(&gpu->vendor, FF_GPU_VENDOR_NAME_AMD) == 0)
     {
-        drmDetectDeviceName(instance, gpu, pci, device);
+        drmDetectDeviceName(gpu, pci, device);
         if(gpu->name.length > 0)
             return;
     }
@@ -171,7 +171,7 @@ static void detectType(FFGPUResult* gpu, const PCIData* pci, struct pci_dev* dev
     gpu->type = FF_GPU_TYPE_INTEGRATED;
 }
 
-static void pciHandleDevice(const FFinstance* instance, FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist* results, PCIData* pci, struct pci_dev* device)
+static void pciHandleDevice(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist* results, PCIData* pci, struct pci_dev* device)
 {
     pci->ffpci_fill_info(device, PCI_FILL_CLASS);
 
@@ -196,7 +196,7 @@ static void pciHandleDevice(const FFinstance* instance, FF_MAYBE_UNUSED const FF
     pciDetectVendorName(gpu, pci, device);
 
     ffStrbufInit(&gpu->name);
-    pciDetectDeviceName(instance, gpu, pci, device);
+    pciDetectDeviceName(gpu, pci, device);
 
     ffStrbufInit(&gpu->driver);
     pciDetectDriverName(gpu, pci, device);
@@ -237,11 +237,11 @@ static void handlePciWarning(FF_MAYBE_UNUSED char *msg, ...)
     // noop
 }
 
-static const char* pciDetectGPUs(const FFinstance* instance, const FFGPUOptions* options, FFlist* gpus)
+static const char* pciDetectGPUs(const FFGPUOptions* options, FFlist* gpus)
 {
     PCIData pci;
 
-    FF_LIBRARY_LOAD(libpci, &instance->config.libPCI, "dlopen libpci.so failed", "libpci" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_LOAD(libpci, &instance.config.libPCI, "dlopen libpci.so failed", "libpci" FF_LIBRARY_EXTENSION, 4);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libpci, pci_alloc);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libpci, pci_init);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(libpci, pci_scan_bus);
@@ -270,7 +270,7 @@ static const char* pciDetectGPUs(const FFinstance* instance, const FFGPUOptions*
     struct pci_dev* device = pci.access->devices;
     while(device != NULL)
     {
-        pciHandleDevice(instance, options, gpus, &pci, device);
+        pciHandleDevice(options, gpus, &pci, device);
         device = device->next;
     }
 
@@ -280,12 +280,12 @@ static const char* pciDetectGPUs(const FFinstance* instance, const FFGPUOptions*
 
 #endif
 
-const char* ffDetectGPUImpl(const FFinstance* instance, const FFGPUOptions* options, FFlist* gpus)
+const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
 {
     #ifdef FF_HAVE_LIBPCI
-        return pciDetectGPUs(instance, options, gpus);
+        return pciDetectGPUs(options, gpus);
     #else
-        FF_UNUSED(instance, options, gpus);
+        FF_UNUSED(options, gpus);
         return "fastfetch is built without libpci support";
     #endif
 }

src/detection/gpu/gpu_nosupport.c

@@ -1,7 +1,7 @@
 #include "gpu.h"
 
-const char* ffDetectGPUImpl(const FFinstance* instance, const FFGPUOptions* options, FFlist* gpus)
+const char* ffDetectGPUImpl(const FFGPUOptions* options, FFlist* gpus)
 {
-    FF_UNUSED(instance, options, gpus);
+    FF_UNUSED(options, gpus);
     return "Not supported on this platform";
 }

src/detection/gpu/gpu_windows.c

@@ -4,7 +4,7 @@
 
 #include <inttypes.h>
 
-const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFinstance* instance, const FF_MAYBE_UNUSED FFGPUOptions* options, FFlist* gpus)
+const char* ffDetectGPUImpl(FF_MAYBE_UNUSED const FFGPUOptions* options, FFlist* gpus)
 {
     DISPLAY_DEVICEW displayDevice = {.cb = sizeof(displayDevice) };
     wchar_t regKey[MAX_PATH] = L"SYSTEM\\CurrentControlSet\\Control\\Video\\{";

src/detection/gtk_qt/gtk.c

@@ -34,7 +34,7 @@ static inline void applyGTKSettings(FFGTKResult* result, const char* themeName,
         ffStrbufAppendS(&result->wallpaper, wallpaper);
 }
 
-static void detectGTKFromSettings(const FFinstance* instance, FFGTKResult* result)
+static void detectGTKFromSettings(FFGTKResult* result)
 {
     static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
 
@@ -58,36 +58,36 @@ static void detectGTKFromSettings(const FFinstance* instance, FFGTKResult* resul
 
     init = true;
 
-    const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
     if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_XFCE4) == 0)
     {
-        themeName = ffSettingsGetXFConf(instance, "xsettings", "/Net/ThemeName", FF_VARIANT_TYPE_STRING).strValue;
-        iconsName = ffSettingsGetXFConf(instance, "xsettings", "/Net/IconThemeName", FF_VARIANT_TYPE_STRING).strValue;
-        fontName = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/FontName", FF_VARIANT_TYPE_STRING).strValue;
-        cursorTheme = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/CursorThemeName", FF_VARIANT_TYPE_STRING).strValue;
-        cursorSize = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/CursorThemeSize", FF_VARIANT_TYPE_INT).intValue;
-        wallpaper = ffSettingsGetXFConf(instance, "xfce4-desktop", "/backdrop/screen0/monitor0/workspace0/last-image", FF_VARIANT_TYPE_STRING).strValue;
+        themeName = ffSettingsGetXFConf("xsettings", "/Net/ThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        iconsName = ffSettingsGetXFConf("xsettings", "/Net/IconThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        fontName = ffSettingsGetXFConf("xsettings", "/Gtk/FontName", FF_VARIANT_TYPE_STRING).strValue;
+        cursorTheme = ffSettingsGetXFConf("xsettings", "/Gtk/CursorThemeName", FF_VARIANT_TYPE_STRING).strValue;
+        cursorSize = ffSettingsGetXFConf("xsettings", "/Gtk/CursorThemeSize", FF_VARIANT_TYPE_INT).intValue;
+        wallpaper = ffSettingsGetXFConf("xfce4-desktop", "/backdrop/screen0/monitor0/workspace0/last-image", FF_VARIANT_TYPE_STRING).strValue;
         if (!wallpaper) // FIXME: find a way to enumerate possible properties
-            wallpaper = ffSettingsGetXFConf(instance, "xfce4-desktop", "/backdrop/screen0/monitoreDP-1/workspace0/last-image", FF_VARIANT_TYPE_STRING).strValue;
+            wallpaper = ffSettingsGetXFConf("xfce4-desktop", "/backdrop/screen0/monitoreDP-1/workspace0/last-image", FF_VARIANT_TYPE_STRING).strValue;
     }
     else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_CINNAMON) == 0)
     {
-        themeName = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/gtk-theme", "org.cinnamon.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
-        iconsName = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/icon-theme", "org.cinnamon.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
-        fontName = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/font-name", "org.cinnamon.desktop.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
-        cursorTheme = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/cursor-theme", "org.cinnamon.desktop.interface", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
-        cursorSize = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/cursor-size", "org.cinnamon.desktop.interface", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
-        wallpaper = ffSettingsGet(instance, "/org/cinnamon/desktop/background/picture-uri", "org.cinnamon.desktop.background", NULL, "picture-uri", FF_VARIANT_TYPE_STRING).strValue;
+        themeName = ffSettingsGet("/org/cinnamon/desktop/interface/gtk-theme", "org.cinnamon.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
+        iconsName = ffSettingsGet("/org/cinnamon/desktop/interface/icon-theme", "org.cinnamon.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
+        fontName = ffSettingsGet("/org/cinnamon/desktop/interface/font-name", "org.cinnamon.desktop.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
+        cursorTheme = ffSettingsGet("/org/cinnamon/desktop/interface/cursor-theme", "org.cinnamon.desktop.interface", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
+        cursorSize = ffSettingsGet("/org/cinnamon/desktop/interface/cursor-size", "org.cinnamon.desktop.interface", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
+        wallpaper = ffSettingsGet("/org/cinnamon/desktop/background/picture-uri", "org.cinnamon.desktop.background", NULL, "picture-uri", FF_VARIANT_TYPE_STRING).strValue;
     }
     else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_MATE) == 0)
     {
-        themeName = ffSettingsGet(instance, "/org/mate/interface/gtk-theme", "org.mate.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
-        iconsName = ffSettingsGet(instance, "/org/mate/interface/icon-theme", "org.mate.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
-        fontName = ffSettingsGet(instance, "/org/mate/interface/font-name", "org.mate.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
-        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;
-        wallpaper = ffSettingsGet(instance, "/org/mate/desktop/background", "org.mate.background", NULL, "picture-filename", FF_VARIANT_TYPE_STRING).strValue;
+        themeName = ffSettingsGet("/org/mate/interface/gtk-theme", "org.mate.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
+        iconsName = ffSettingsGet("/org/mate/interface/icon-theme", "org.mate.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
+        fontName = ffSettingsGet("/org/mate/interface/font-name", "org.mate.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
+        cursorTheme = ffSettingsGet("/org/mate/peripherals-mouse/cursor-theme", "org.mate.peripherals-mouse", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
+        cursorSize = ffSettingsGet("/org/mate/peripherals-mouse/cursor-size", "org.mate.peripherals-mouse", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
+        wallpaper = ffSettingsGet("/org/mate/desktop/background", "org.mate.background", NULL, "picture-filename", FF_VARIANT_TYPE_STRING).strValue;
     }
     else if(
         ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_GNOME) == 0 ||
@@ -95,12 +95,12 @@ static void detectGTKFromSettings(const FFinstance* instance, FFGTKResult* resul
         ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_UNITY) == 0 ||
         ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_BUDGIE) == 0
     ) {
-        themeName = ffSettingsGet(instance, "/org/gnome/desktop/interface/gtk-theme", "org.gnome.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
-        iconsName = ffSettingsGet(instance, "/org/gnome/desktop/interface/icon-theme", "org.gnome.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
-        fontName = ffSettingsGet(instance, "/org/gnome/desktop/interface/font-name", "org.gnome.desktop.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
-        cursorTheme = ffSettingsGet(instance, "/org/gnome/desktop/interface/cursor-theme", "org.gnome.desktop.interface", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
-        cursorSize = ffSettingsGet(instance, "/org/gnome/desktop/interface/cursor-size", "org.gnome.desktop.interface", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
-        wallpaper = ffSettingsGet(instance, "/org/gnome/desktop/background/picture-uri", "org.gnome.desktop.background", NULL, "picture-uri", FF_VARIANT_TYPE_STRING).strValue;
+        themeName = ffSettingsGet("/org/gnome/desktop/interface/gtk-theme", "org.gnome.desktop.interface", NULL, "gtk-theme", FF_VARIANT_TYPE_STRING).strValue;
+        iconsName = ffSettingsGet("/org/gnome/desktop/interface/icon-theme", "org.gnome.desktop.interface", NULL, "icon-theme", FF_VARIANT_TYPE_STRING).strValue;
+        fontName = ffSettingsGet("/org/gnome/desktop/interface/font-name", "org.gnome.desktop.interface", NULL, "font-name", FF_VARIANT_TYPE_STRING).strValue;
+        cursorTheme = ffSettingsGet("/org/gnome/desktop/interface/cursor-theme", "org.gnome.desktop.interface", NULL, "cursor-theme", FF_VARIANT_TYPE_STRING).strValue;
+        cursorSize = ffSettingsGet("/org/gnome/desktop/interface/cursor-size", "org.gnome.desktop.interface", NULL, "cursor-size", FF_VARIANT_TYPE_INT).intValue;
+        wallpaper = ffSettingsGet("/org/gnome/desktop/background/picture-uri", "org.gnome.desktop.background", NULL, "picture-uri", FF_VARIANT_TYPE_STRING).strValue;
     }
 
     ffThreadMutexUnlock(&mutex);
@@ -157,18 +157,18 @@ static void detectGTKFromConfigDir(FFstrbuf* configDir, const char* version, FFG
     ffStrbufSubstrBefore(configDir, configDirLength);
 }
 
-static void detectGTK(const FFinstance* instance, const char* version, FFGTKResult* result)
+static void detectGTK(const char* version, FFGTKResult* result)
 {
     //Mate, Cinnamon, Gnome, Unity, Budgie use dconf to save theme config
     //On other DEs, this will do nothing
-    detectGTKFromSettings(instance, result);
+    detectGTKFromSettings(result);
     if(allPropertiesSet(result))
         return;
 
     //We need to do this because we use multiple threads on configDirs
     FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
 
-    FF_LIST_FOR_EACH(FFstrbuf, configDir, instance->state.platform.configDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, configDir, instance.state.platform.configDirs)
     {
         ffStrbufSet(&baseDir, configDir);
         detectGTKFromConfigDir(&baseDir, version, result);
@@ -193,21 +193,21 @@ static void detectGTK(const FFinstance* instance, const char* version, FFGTKResu
     ffStrbufInit(&result.cursor); \
     ffStrbufInit(&result.cursorSize); \
     ffStrbufInit(&result.wallpaper); \
-    detectGTK(instance, #version, &result); \
+    detectGTK(#version, &result); \
     ffThreadMutexUnlock(&mutex); \
     return &result;
 
-const FFGTKResult* ffDetectGTK2(const FFinstance* instance)
+const FFGTKResult* ffDetectGTK2(void)
 {
     FF_DETECT_GTK_IMPL(2)
 }
 
-const FFGTKResult* ffDetectGTK3(const FFinstance* instance)
+const FFGTKResult* ffDetectGTK3(void)
 {
     FF_DETECT_GTK_IMPL(3)
 }
 
-const FFGTKResult* ffDetectGTK4(const FFinstance* instance)
+const FFGTKResult* ffDetectGTK4(void)
 {
     FF_DETECT_GTK_IMPL(4)
 }

src/detection/gtk_qt/gtk_qt.h

@@ -24,9 +24,9 @@ typedef struct FFQtResult
     FFstrbuf wallpaper;
 } FFQtResult;
 
-const FFGTKResult* ffDetectGTK2(const FFinstance* instance);
-const FFGTKResult* ffDetectGTK4(const FFinstance* instance);
-const FFGTKResult* ffDetectGTK3(const FFinstance* instance);
-const FFQtResult* ffDetectQt(const FFinstance* instance);
+const FFGTKResult* ffDetectGTK2(void);
+const FFGTKResult* ffDetectGTK4(void);
+const FFGTKResult* ffDetectGTK3(void);
+const FFQtResult* ffDetectQt(void);
 
 #endif

src/detection/gtk_qt/qt.c

@@ -81,14 +81,14 @@ static bool detectPlasmaFromFile(const char* filename, FFQtResult* result)
     return true;
 }
 
-static void detectPlasma(const FFinstance* instance, FFQtResult* result)
+static void detectPlasma(FFQtResult* result)
 {
     bool foundAFile = false;
 
     //We need to do this because we use multiple threads on configDirs
     FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
 
-    FF_LIST_FOR_EACH(FFstrbuf, configDir, instance->state.platform.configDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, configDir, instance.state.platform.configDirs)
     {
         ffStrbufSet(&baseDir, configDir);
         ffStrbufAppendS(&baseDir, "kdeglobals");
@@ -123,18 +123,18 @@ static void detectPlasma(const FFinstance* instance, FFQtResult* result)
         ffStrbufAppendS(&result->font, "Noto Sans, 10");
 }
 
-static void detectLXQt(const FFinstance* instance, FFQtResult* result)
+static void detectLXQt(FFQtResult* result)
 {
-    ffParsePropFileConfigValues(instance, "lxqt/lxqt.conf", 3, (FFpropquery[]) {
+    ffParsePropFileConfigValues("lxqt/lxqt.conf", 3, (FFpropquery[]) {
         {"style = ", &result->widgetStyle},
         {"icon_theme = ", &result->icons},
         {"font = ", &result->font}
     });
 
-    ffParsePropFileConfig(instance, "pcmanfm-qt/lxqt/settings.conf", "Wallpaper=", &result->wallpaper);
+    ffParsePropFileConfig("pcmanfm-qt/lxqt/settings.conf", "Wallpaper=", &result->wallpaper);
 }
 
-const FFQtResult* ffDetectQt(const FFinstance* instance)
+const FFQtResult* ffDetectQt(void)
 {
     static FFQtResult result;
 
@@ -154,12 +154,12 @@ const FFQtResult* ffDetectQt(const FFinstance* instance)
     ffStrbufInit(&result.font);
     ffStrbufInit(&result.wallpaper);
 
-    const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
     if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_PLASMA) == 0)
-        detectPlasma(instance, &result);
+        detectPlasma(&result);
     else if(ffStrbufIgnCaseCompS(&wmde->dePrettyName, FF_DE_PRETTY_LXQT) == 0)
-        detectLXQt(instance, &result);
+        detectLXQt(&result);
 
     ffThreadMutexUnlock(&mutex);
     return &result;

src/detection/icons/icons.h

@@ -5,6 +5,6 @@
 
 #include "fastfetch.h"
 
-const char* ffDetectIcons(const FFinstance* instance, FFstrbuf* result);
+const char* ffDetectIcons(FFstrbuf* result);
 
 #endif

src/detection/icons/icons_linux.c

@@ -3,17 +3,17 @@
 #include "detection/gtk_qt/gtk_qt.h"
 #include "detection/displayserver/displayserver.h"
 
-const char* ffDetectIcons(const FFinstance* instance, FFstrbuf* result)
+const char* ffDetectIcons(FFstrbuf* result)
 {
-    const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
     if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
         return "Icons aren't supported in TTY";
 
-    const FFstrbuf* plasma = &ffDetectQt(instance)->icons;
-    const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->icons;
-    const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->icons;
-    const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->icons;
+    const FFstrbuf* plasma = &ffDetectQt()->icons;
+    const FFstrbuf* gtk2 = &ffDetectGTK2()->icons;
+    const FFstrbuf* gtk3 = &ffDetectGTK3()->icons;
+    const FFstrbuf* gtk4 = &ffDetectGTK4()->icons;
 
     if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
         return "No icons could be found";

src/detection/icons/icons_nosupport.c

@@ -1,6 +1,6 @@
 #include "icons.h"
 
-const char* ffDetectIcons(FF_MAYBE_UNUSED const FFinstance* instance, FF_MAYBE_UNUSED FFstrbuf* result)
+const char* ffDetectIcons(FF_MAYBE_UNUSED FFstrbuf* result)
 {
     return "Not supported on this platform";
 }

src/detection/icons/icons_windows.c

@@ -1,7 +1,7 @@
 #include "icons.h"
 #include "util/windows/registry.h"
 
-const char* ffDetectIcons(FF_MAYBE_UNUSED const FFinstance* instance, FFstrbuf* result)
+const char* ffDetectIcons(FFstrbuf* result)
 {
     FF_HKEY_AUTO_DESTROY hKey = NULL;
     if(!ffRegOpenKeyForRead(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\HideDesktopIcons\\ClassicStartMenu", &hKey, NULL))

src/detection/media/media.c

@@ -1,9 +1,9 @@
 #include "media.h"
 #include "detection/internal.h"
 
-void ffDetectMediaImpl(const FFinstance* instance, FFMediaResult* media);
+void ffDetectMediaImpl(FFMediaResult* media);
 
-const FFMediaResult* ffDetectMedia(const FFinstance* instance)
+const FFMediaResult* ffDetectMedia(void)
 {
     FF_DETECTION_INTERNAL_GUARD(FFMediaResult,
         ffStrbufInit(&result.error);
@@ -15,7 +15,7 @@ const FFMediaResult* ffDetectMedia(const FFinstance* instance)
         ffStrbufInit(&result.url);
         ffStrbufInit(&result.status);
 
-        ffDetectMediaImpl(instance, &result);
+        ffDetectMediaImpl(&result);
 
         if(result.song.length == 0 && result.error.length == 0)
             ffStrbufAppendS(&result.error, "No media found");

src/detection/media/media.h

@@ -17,6 +17,6 @@ typedef struct FFMediaResult
     FFstrbuf status;
 } FFMediaResult;
 
-const FFMediaResult* ffDetectMedia(const FFinstance* instance);
+const FFMediaResult* ffDetectMedia();
 
 #endif

src/detection/media/media_apple.m

@@ -77,7 +77,7 @@ static const char* getMedia(FFMediaResult* result)
     return error;
 }
 
-void ffDetectMediaImpl(const FFinstance* instance, FFMediaResult* media)
+void ffDetectMediaImpl(FFMediaResult* media)
 {
     FF_UNUSED(instance)
     const char* error = getMedia(media);

src/detection/media/media_linux.c

@@ -152,17 +152,17 @@ static void getBestBus(FFDBusData* data, FFMediaResult* result)
     data->lib->ffdbus_message_unref(reply);
 }
 
-static const char* getMedia(const FFinstance* instance, FFMediaResult* result)
+static const char* getMedia(FFMediaResult* result)
 {
     FFDBusData data;
-    const char* error = ffDBusLoadData(instance, DBUS_BUS_SESSION, &data);
+    const char* error = ffDBusLoadData(DBUS_BUS_SESSION, &data);
     if(error != NULL)
         return error;
 
     // FIXME: This is shared for both player and media module.
     // However it uses an option in one specific module
-    if(instance->config.playerName.length > 0)
-        getCustomBus(&data, &instance->config.playerName, result);
+    if(instance.config.playerName.length > 0)
+        getCustomBus(&data, &instance.config.playerName, result);
     else
         getBestBus(&data, result);
 
@@ -171,13 +171,12 @@ static const char* getMedia(const FFinstance* instance, FFMediaResult* result)
 
 #endif
 
-void ffDetectMediaImpl(const FFinstance* instance, FFMediaResult* media)
+void ffDetectMediaImpl(FFMediaResult* media)
 {
     #ifdef FF_HAVE_DBUS
-        const char* error = getMedia(instance, media);
+        const char* error = getMedia(media);
         ffStrbufAppendS(&media->error, error);
     #else
-        FF_UNUSED(instance);
         ffStrbufAppendS(&media->error, "Fastfetch was compiled without DBus support");
     #endif
 }

src/detection/media/media_nosupport.c

@@ -1,7 +1,6 @@
 #include "media.h"
 
-void ffDetectMediaImpl(const FFinstance* instance, FFMediaResult* media)
+void ffDetectMediaImpl(FFMediaResult* media)
 {
-    FF_UNUSED(instance);
     ffStrbufAppendS(&media->error, "Not supported on this platform");
 }

src/detection/opencl/opencl.c

@@ -63,13 +63,13 @@ static const char* openCLHandleData(OpenCLData* data, FFOpenCLResult* result)
 
 #endif // defined(FF_HAVE_OPENCL) || defined(__APPLE__)
 
-const char* ffDetectOpenCL(FFinstance* instance, FFOpenCLResult* result)
+const char* ffDetectOpenCL(FFOpenCLResult* result)
 {
     #ifdef FF_HAVE_OPENCL
 
     OpenCLData data;
 
-    FF_LIBRARY_LOAD(opencl, &instance->config.libOpenCL, "dlopen libOpenCL"FF_LIBRARY_EXTENSION" failed",
+    FF_LIBRARY_LOAD(opencl, &instance.config.libOpenCL, "dlopen libOpenCL"FF_LIBRARY_EXTENSION" failed",
     #ifdef _WIN32
         "OpenCL"FF_LIBRARY_EXTENSION, -1,
     #endif
@@ -83,8 +83,6 @@ const char* ffDetectOpenCL(FFinstance* instance, FFOpenCLResult* result)
 
     #elif defined(__APPLE__) // FF_HAVE_OPENCL
 
-    FF_UNUSED(instance);
-
     OpenCLData data;
     data.ffclGetPlatformIDs = clGetPlatformIDs;
     data.ffclGetDeviceIDs = clGetDeviceIDs;
@@ -94,7 +92,7 @@ const char* ffDetectOpenCL(FFinstance* instance, FFOpenCLResult* result)
 
     #else
 
-    FF_UNUSED(instance, result);
+    FF_UNUSED(result);
     return "Fastfetch was build without OpenCL support";
 
     #endif // FF_HAVE_OPENCL

src/detection/opencl/opencl.h

@@ -12,6 +12,6 @@ typedef struct FFOpenCLResult
     FFstrbuf vendor;
 } FFOpenCLResult;
 
-const char* ffDetectOpenCL(FFinstance* instance, FFOpenCLResult* result);
+const char* ffDetectOpenCL(FFOpenCLResult* result);
 
 #endif

src/detection/opengl/opengl.h

@@ -13,6 +13,6 @@ typedef struct FFOpenGLResult
     FFstrbuf slv;
 } FFOpenGLResult;
 
-const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result);
+const char* ffDetectOpenGL(FFOpenGLResult* result);
 
 #endif

src/detection/opengl/opengl_apple.c

@@ -35,10 +35,8 @@ static const char* cglHandlePixelFormat(FFOpenGLResult* result, CGLPixelFormatOb
     return error;
 }
 
-const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
+const char* ffDetectOpenGL(FFOpenGLResult* result)
 {
-    FF_UNUSED(instance);
-
     CGLPixelFormatObj pixelFormat;
     CGLPixelFormatAttribute attrs[] = {
         kCGLPFAOpenGLProfile, (CGLPixelFormatAttribute) kCGLOGLPVersion_3_2_Core,

src/detection/opengl/opengl_linux.c

@@ -118,11 +118,11 @@ static const char* eglHandleData(FFOpenGLResult* result, EGLData* data)
     return error;
 }
 
-static const char* eglPrint(FFinstance* instance, FFOpenGLResult* result)
+static const char* eglPrint(FFOpenGLResult* result)
 {
     EGLData eglData;
 
-    FF_LIBRARY_LOAD(egl, &instance->config.libEGL, "dlopen egl failed", "libEGL" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_LOAD(egl, &instance.config.libEGL, "dlopen egl failed", "libEGL" FF_LIBRARY_EXTENSION, 1);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglGetProcAddress);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglGetDisplay);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglInitialize);
@@ -235,11 +235,11 @@ static const char* glxHandleData(FFOpenGLResult* result, GLXData* data)
     return error;
 }
 
-static const char* glxPrint(FFinstance* instance, FFOpenGLResult* result)
+static const char* glxPrint(FFOpenGLResult* result)
 {
     GLXData data;
 
-    FF_LIBRARY_LOAD(glx, &instance->config.libGLX, "dlopen glx failed", "libGLX" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_LOAD(glx, &instance.config.libGLX, "dlopen glx failed", "libGLX" FF_LIBRARY_EXTENSION, 1);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(glx, data, glXGetProcAddress);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(glx, data, XOpenDisplay);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(glx, data, glXChooseVisual);
@@ -299,11 +299,11 @@ static const char* osMesaHandleData(FFOpenGLResult* result, OSMesaData* data)
     return error;
 }
 
-static const char* osMesaPrint(FFinstance* instance, FFOpenGLResult* result)
+static const char* osMesaPrint(FFOpenGLResult* result)
 {
     OSMesaData data;
 
-    FF_LIBRARY_LOAD(osmesa, &instance->config.libOSMesa, "dlopen osmesa failed", "libOSMesa" FF_LIBRARY_EXTENSION, 8);
+    FF_LIBRARY_LOAD(osmesa, &instance.config.libOSMesa, "dlopen osmesa failed", "libOSMesa" FF_LIBRARY_EXTENSION, 8);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(osmesa, data, OSMesaGetProcAddress);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(osmesa, data, OSMesaCreateContext);
     FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(osmesa, data, OSMesaMakeCurrent);
@@ -314,32 +314,32 @@ static const char* osMesaPrint(FFinstance* instance, FFOpenGLResult* result)
 
 #endif //FF_HAVE_OSMESA
 
-const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
+const char* ffDetectOpenGL(FFOpenGLResult* result)
 {
     #if FF_HAVE_GL
 
-    if(instance->config.openGL.library == FF_OPENGL_LIBRARY_GLX)
+    if(instance.config.openGL.library == FF_OPENGL_LIBRARY_GLX)
     {
         #ifdef FF_HAVE_GLX
-            return glxPrint(instance, result);
+            return glxPrint(result);
         #else
             return "fastfetch was compiled without glx support";
         #endif
     }
 
-    if(instance->config.openGL.library == FF_OPENGL_LIBRARY_EGL)
+    if(instance.config.openGL.library == FF_OPENGL_LIBRARY_EGL)
     {
         #ifdef FF_HAVE_EGL
-            return eglPrint(instance, result);
+            return eglPrint(result);
         #else
             return "fastfetch was compiled without egl support";
         #endif
     }
 
-    if(instance->config.openGL.library == FF_OPENGL_LIBRARY_OSMESA)
+    if(instance.config.openGL.library == FF_OPENGL_LIBRARY_OSMESA)
     {
         #ifdef FF_HAVE_OSMESA
-            return osMesaPrint(instance, result);
+            return osMesaPrint(result);
         #else
             return "fastfetch was compiled without osmesa support";
         #endif
@@ -348,12 +348,12 @@ const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
     const char* error = ""; // not NULL dummy value
 
     #ifdef FF_HAVE_EGL
-        error = eglPrint(instance, result);
+        error = eglPrint(result);
     #endif
 
     #ifdef FF_HAVE_GLX
         if(error != NULL)
-            error = glxPrint(instance, result);
+            error = glxPrint(result);
     #endif
 
     //We don't use osmesa in auto mode here, because it is a software implementation,
@@ -363,7 +363,7 @@ const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
 
     #else
 
-        FF_UNUSED(instance, result);
+        FF_UNUSED(result);
         return "Fastfetch was built without gl support.";
 
     #endif //FF_HAVE_GL

src/detection/opengl/opengl_windows.c

@@ -82,10 +82,8 @@ LRESULT CALLBACK wglHandleWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM
     }
 }
 
-const char* ffDetectOpenGL(FFinstance* instance, FFOpenGLResult* result)
+const char* ffDetectOpenGL(FFOpenGLResult* result)
 {
-    FF_UNUSED(instance);
-
     MSG msg = {0};
     WNDCLASSW wc = {
         .lpfnWndProc = wglHandleWndProc,

src/detection/os/os.c

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

src/detection/os/os.h

@@ -19,6 +19,6 @@ typedef struct FFOSResult
     FFstrbuf buildID;
 } FFOSResult;
 
-const FFOSResult* ffDetectOS(const FFinstance* instance);
+const FFOSResult* ffDetectOS();
 
 #endif

src/detection/os/os_android.c

@@ -1,10 +1,8 @@
 #include "os.h"
 #include "common/settings.h"
 
-void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
+void ffDetectOSImpl(FFOSResult* os)
 {
-    FF_UNUSED(instance);
-
     ffStrbufInitS(&os->name, "Android");
 
     ffStrbufInitS(&os->prettyName, "Android");

src/detection/os/os_apple.m

@@ -96,10 +96,8 @@ static void parseOSXSoftwareLicense(FFOSResult* os)
     fclose(rtf);
 }
 
-void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
+void ffDetectOSImpl(FFOSResult* os)
 {
-    FF_UNUSED(instance);
-
     ffStrbufInit(&os->name);
     ffStrbufInit(&os->version);
     ffStrbufInit(&os->buildID);

src/detection/os/os_linux.c

@@ -94,15 +94,15 @@ static void getUbuntuFlavour(FFOSResult* result)
     }
 }
 
-static void detectOS(FFOSResult* os, const FFinstance* instance)
+static void detectOS(FFOSResult* os)
 {
-    if(instance->config.osFile.length > 0)
+    if(instance.config.osFile.length > 0)
     {
-        parseFile(instance->config.osFile.chars, os);
+        parseFile(instance.config.osFile.chars, os);
         return;
     }
 
-    if(instance->config.escapeBedrock && parseFile(FASTFETCH_TARGET_DIR_ROOT"/bedrock"FASTFETCH_TARGET_DIR_ETC"/bedrock-release", os))
+    if(instance.config.escapeBedrock && parseFile(FASTFETCH_TARGET_DIR_ROOT"/bedrock"FASTFETCH_TARGET_DIR_ETC"/bedrock-release", os))
     {
         if(os->id.length == 0)
             ffStrbufAppendS(&os->id, "bedrock");
@@ -127,7 +127,7 @@ static void detectOS(FFOSResult* os, const FFinstance* instance)
     parseFile(FASTFETCH_TARGET_DIR_ETC"/lsb-release", os);
 }
 
-void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
+void ffDetectOSImpl(FFOSResult* os)
 {
     ffStrbufInit(&os->name);
     ffStrbufInit(&os->prettyName);
@@ -140,7 +140,7 @@ void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
     ffStrbufInit(&os->codename);
     ffStrbufInit(&os->buildID);
 
-    detectOS(os, instance);
+    detectOS(os);
 
     if(ffStrbufIgnCaseCompS(&os->id, "ubuntu") == 0)
         getUbuntuFlavour(os);

src/detection/os/os_windows.cpp

@@ -44,10 +44,8 @@ static const char* getOsNameByWinbrand(FFstrbuf* osName)
 }
 
 extern "C"
-void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance)
+void ffDetectOSImpl(FFOSResult* os)
 {
-    FF_UNUSED(instance);
-
     ffStrbufInit(&os->name);
     ffStrbufInit(&os->prettyName);
     ffStrbufInit(&os->id);

src/detection/packages/packages.c

@@ -3,11 +3,11 @@
 
 #include <stddef.h>
 
-void ffDetectPackagesImpl(const FFinstance* instance, FFPackagesResult* result);
+void ffDetectPackagesImpl(FFPackagesResult* result);
 
-const char* ffDetectPackages(const FFinstance* instance, FFPackagesResult* result)
+const char* ffDetectPackages(FFPackagesResult* result)
 {
-    ffDetectPackagesImpl(instance, result);
+    ffDetectPackagesImpl(result);
 
     for(uint32_t i = 0; i < offsetof(FFPackagesResult, all) / sizeof(uint32_t); ++i)
         result->all += ((uint32_t *)result)[i];

src/detection/packages/packages.h

@@ -32,6 +32,6 @@ typedef struct FFPackagesResult
     FFstrbuf pacmanBranch;
 } FFPackagesResult;
 
-const char* ffDetectPackages(const FFinstance* instance, FFPackagesResult* result);
+const char* ffDetectPackages(FFPackagesResult* result);
 
 #endif

src/detection/packages/packages_apple.c

@@ -68,9 +68,8 @@ static uint32_t getMacPortsPackages()
     return countMacPortsPackages(FASTFETCH_TARGET_DIR_ROOT"/opt/local");
 }
 
-void ffDetectPackagesImpl(const FFinstance* instance, FFPackagesResult* result)
+void ffDetectPackagesImpl(FFPackagesResult* result)
 {
-    FF_UNUSED(instance);
     getBrewPackages(result);
     result->port = getMacPortsPackages();
 }

src/detection/packages/packages_linux.c

@@ -74,11 +74,11 @@ static uint32_t getNumStrings(FFstrbuf* baseDir, const char* filename, const cha
     return num_elements;
 }
 
-static uint32_t getSQLite3Int(const FFinstance* instance, FFstrbuf* baseDir, const char* dbPath, const char* query)
+static uint32_t getSQLite3Int(FFstrbuf* baseDir, const char* dbPath, const char* query)
 {
     uint32_t baseDirLength = baseDir->length;
     ffStrbufAppendS(baseDir, dbPath);
-    uint32_t num_elements = (uint32_t) ffSettingsGetSQLite3Int(instance, baseDir->chars, query);
+    uint32_t num_elements = (uint32_t) ffSettingsGetSQLite3Int(baseDir->chars, query);
     ffStrbufSubstrBefore(baseDir, baseDirLength);
     return num_elements;
 }
@@ -221,9 +221,9 @@ static uint32_t getFlatpak(FFstrbuf* baseDir, const char* dirname)
 #include <rpm/rpmdb.h>
 #include <rpm/rpmlog.h>
 
-static uint32_t getRpmFromLibrpm(const FFinstance* instance)
+static uint32_t getRpmFromLibrpm(void)
 {
-    FF_LIBRARY_LOAD(rpm, &instance->config.librpm, 0, "librpm" FF_LIBRARY_EXTENSION, 12)
+    FF_LIBRARY_LOAD(rpm, &instance.config.librpm, 0, "librpm" FF_LIBRARY_EXTENSION, 12)
     FF_LIBRARY_LOAD_SYMBOL(rpm, rpmReadConfigFiles, 0)
     FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsCreate, 0)
     FF_LIBRARY_LOAD_SYMBOL(rpm, rpmtsInitIterator, 0)
@@ -259,7 +259,7 @@ static uint32_t getRpmFromLibrpm(const FFinstance* instance)
 
 #endif //FF_HAVE_RPM
 
-static void getPackageCounts(const FFinstance* instance, FFstrbuf* baseDir, FFPackagesResult* packageCounts)
+static void getPackageCounts(FFstrbuf* baseDir, FFPackagesResult* packageCounts)
 {
     packageCounts->apk += getNumStrings(baseDir, "/lib/apk/db/installed", "C:Q");
     packageCounts->dpkg += getNumStrings(baseDir, "/var/lib/dpkg/status", "Status: ");
@@ -269,17 +269,17 @@ static void getPackageCounts(const FFinstance* instance, FFstrbuf* baseDir, FFPa
     packageCounts->nixDefault += getNixPackages(baseDir, "/nix/var/nix/profiles/default");
     packageCounts->nixSystem += getNixPackages(baseDir, "/run/current-system");
     packageCounts->pacman += getNumElements(baseDir, "/var/lib/pacman/local", DT_DIR);
-    packageCounts->pkg += getSQLite3Int(instance, baseDir, "/var/db/pkg/local.sqlite", "SELECT count(id) FROM packages");
-    packageCounts->rpm += getSQLite3Int(instance, baseDir, "/var/lib/rpm/rpmdb.sqlite", "SELECT count(blob) FROM Packages");
+    packageCounts->pkg += getSQLite3Int(baseDir, "/var/db/pkg/local.sqlite", "SELECT count(id) FROM packages");
+    packageCounts->rpm += getSQLite3Int(baseDir, "/var/lib/rpm/rpmdb.sqlite", "SELECT count(blob) FROM Packages");
     packageCounts->snap += getSnap(baseDir);
     packageCounts->xbps += getXBPS(baseDir, "/var/db/xbps");
     packageCounts->brewCask += getNumElements(baseDir, "/home/linuxbrew/.linuxbrew/Caskroom", DT_DIR);
     packageCounts->brew += getNumElements(baseDir, "/home/linuxbrew/.linuxbrew/Cellar", DT_DIR);
 }
 
-static void getPackageCountsRegular(const FFinstance* instance, FFstrbuf* baseDir, FFPackagesResult* packageCounts)
+static void getPackageCountsRegular(FFstrbuf* baseDir, FFPackagesResult* packageCounts)
 {
-    getPackageCounts(instance, baseDir, packageCounts);
+    getPackageCounts(baseDir, packageCounts);
 
     uint32_t baseDirLength = baseDir->length;
     ffStrbufAppendS(baseDir, FASTFETCH_TARGET_DIR_ETC"/pacman-mirrors.conf");
@@ -288,7 +288,7 @@ static void getPackageCountsRegular(const FFinstance* instance, FFstrbuf* baseDi
     ffStrbufSubstrBefore(baseDir, baseDirLength);
 }
 
-static void getPackageCountsBedrock(const FFinstance* instance, FFstrbuf* baseDir, FFPackagesResult* packageCounts)
+static void getPackageCountsBedrock(FFstrbuf* baseDir, FFPackagesResult* packageCounts)
 {
     uint32_t baseDirLength = baseDir->length;
 
@@ -313,7 +313,7 @@ static void getPackageCountsBedrock(const FFinstance* instance, FFstrbuf* baseDi
             continue;
 
         ffStrbufAppendS(baseDir, entry->d_name);
-        getPackageCounts(instance, baseDir, packageCounts);
+        getPackageCounts(baseDir, packageCounts);
         ffStrbufSubstrBefore(baseDir, baseDirLength2);
     }
 
@@ -321,25 +321,25 @@ static void getPackageCountsBedrock(const FFinstance* instance, FFstrbuf* baseDi
     ffStrbufSubstrBefore(baseDir, baseDirLength);
 }
 
-void ffDetectPackagesImpl(const FFinstance* instance, FFPackagesResult* result)
+void ffDetectPackagesImpl(FFPackagesResult* result)
 {
     FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(512);
     ffStrbufAppendS(&baseDir, FASTFETCH_TARGET_DIR_ROOT);
 
-    if(ffStrbufIgnCaseEqualS(&ffDetectOS(instance)->id, "bedrock"))
-        getPackageCountsBedrock(instance, &baseDir, result);
+    if(ffStrbufIgnCaseEqualS(&ffDetectOS()->id, "bedrock"))
+        getPackageCountsBedrock(&baseDir, result);
     else
-        getPackageCountsRegular(instance, &baseDir, result);
+        getPackageCountsRegular(&baseDir, result);
 
     // 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
         if(result->rpm == 0)
-            result->rpm = getRpmFromLibrpm(instance);
+            result->rpm = getRpmFromLibrpm();
     #endif
 
-    ffStrbufSet(&baseDir, &instance->state.platform.homeDir);
+    ffStrbufSet(&baseDir, &instance.state.platform.homeDir);
     result->nixUser = getNixPackages(&baseDir, "/.nix-profile");
     result->flatpakUser = getFlatpak(&baseDir, "/.local/share/flatpak");
 }

src/detection/packages/packages_windows.c

@@ -32,7 +32,7 @@ static uint32_t getNumElements(const char* searchPath /* including `\*` suffix *
     return counter;
 }
 
-static void detectScoop(const FFinstance* instance, FFPackagesResult* result)
+static void detectScoop(FFPackagesResult* result)
 {
     FF_STRBUF_AUTO_DESTROY scoopPath = ffStrbufCreateA(MAX_PATH + 3);
 
@@ -44,13 +44,13 @@ static void detectScoop(const FFinstance* instance, FFPackagesResult* result)
     }
     else
     {
-        ffStrbufAppendS(&scoopPath, instance->state.platform.homeDir.chars);
+        ffStrbufAppendS(&scoopPath, instance.state.platform.homeDir.chars);
         ffStrbufAppendS(&scoopPath, "/scoop/apps/*");
     }
     result->scoop = getNumElements(scoopPath.chars, FILE_ATTRIBUTE_DIRECTORY, "scoop");
 }
 
-static void detectChoco(FF_MAYBE_UNUSED const FFinstance* instance, FFPackagesResult* result)
+static void detectChoco(FF_MAYBE_UNUSED FFPackagesResult* result)
 {
     const char* chocoInstall = getenv("ChocolateyInstall");
     if(!chocoInstall || chocoInstall[0] == '\0')
@@ -62,7 +62,7 @@ static void detectChoco(FF_MAYBE_UNUSED const FFinstance* instance, FFPackagesRe
     result->choco = getNumElements(chocoPath, FILE_ATTRIBUTE_DIRECTORY, "choco");
 }
 
-static void detectPacman(FF_MAYBE_UNUSED const FFinstance* instance, FFPackagesResult* result)
+static void detectPacman(FF_MAYBE_UNUSED FFPackagesResult* result)
 {
     const char* msystemPrefix = getenv("MSYSTEM_PREFIX");
     if(!msystemPrefix)
@@ -75,9 +75,9 @@ static void detectPacman(FF_MAYBE_UNUSED const FFinstance* instance, FFPackagesR
     result->pacman = getNumElements(pacmanPath, FILE_ATTRIBUTE_DIRECTORY, NULL);
 }
 
-void ffDetectPackagesImpl(const FFinstance* instance, FFPackagesResult* result)
+void ffDetectPackagesImpl(FFPackagesResult* result)
 {
-    detectScoop(instance, result);
-    detectChoco(instance, result);
-    detectPacman(instance, result);
+    detectScoop(result);
+    detectChoco(result);
+    detectPacman(result);
 }

src/detection/poweradapter/poweradapter.h

@@ -14,7 +14,7 @@ typedef struct PowerAdapterResult
     int watts;
 } PowerAdapterResult;
 
-const char* ffDetectPowerAdapterImpl(FFinstance* instance, FFlist* results);
+const char* ffDetectPowerAdapterImpl(FFlist* results);
 
 #define FF_POWERADAPTER_UNSET -2
 #define FF_POWERADAPTER_NOT_CONNECTED -1