diff --git a/src/common/bar.c b/src/common/bar.c
index d4a8cf0f1..e42a07c2a 100644
--- a/src/common/bar.c
+++ b/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);
     }
diff --git a/src/common/bar.h b/src/common/bar.h
index f28cbe777..d776454d4 100644
--- a/src/common/bar.h
+++ b/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
diff --git a/src/common/dbus.c b/src/common/dbus.c
index b0f5c4ffe..968358a8d 100644
--- a/src/common/dbus.c
+++ b/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";
 
diff --git a/src/common/dbus.h b/src/common/dbus.h
index 7f0fa2402..bf112e244 100644
--- a/src/common/dbus.h
+++ b/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);
diff --git a/src/common/init.c b/src/common/init.c
index ed522d8ff..423f0de58 100644
--- a/src/common/init.c
+++ b/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
diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c
index 98ae8a2d3..13b6e514f 100644
--- a/src/common/jsonconfig.c
+++ b/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);
 }
diff --git a/src/common/jsonconfig.h b/src/common/jsonconfig.h
index 8a72408bc..7cf6a96e0 100644
--- a/src/common/jsonconfig.h
+++ b/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();
diff --git a/src/common/printing.c b/src/common/printing.c
index 97aacb62b..538698550 100644
--- a/src/common/printing.c
+++ b/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);
 }
 
diff --git a/src/common/printing.h b/src/common/printing.h
index 801ef7e8e..8019a01cc 100644
--- a/src/common/printing.h
+++ b/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);
diff --git a/src/common/properties.c b/src/common/properties.c
index 6543d14a4..c91f107eb 100644
--- a/src/common/properties.c
+++ b/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);
 }
 
diff --git a/src/common/properties.h b/src/common/properties.h
index ea78ed903..8b65e419c 100644
--- a/src/common/properties.h
+++ b/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
diff --git a/src/common/settings.c b/src/common/settings.c
index f8e88b10a..dda3fe62d 100644
--- a/src/common/settings.c
+++ b/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
diff --git a/src/common/settings.h b/src/common/settings.h
index 7cb4fd46e..212727fe9 100644
--- a/src/common/settings.h
+++ b/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);
diff --git a/src/common/thread.h b/src/common/thread.h
index 0b9bcb7e1..0b8989c4e 100644
--- a/src/common/thread.h
+++ b/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
diff --git a/src/detection/battery/battery.h b/src/detection/battery/battery.h
index e83bf78d8..5667af76c 100644
--- a/src/detection/battery/battery.h
+++ b/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
diff --git a/src/detection/battery/battery_android.c b/src/detection/battery/battery_android.c
index eb05fefe4..d163f0894 100644
--- a/src/detection/battery/battery_android.c
+++ b/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();
 
diff --git a/src/detection/battery/battery_apple.c b/src/detection/battery/battery_apple.c
index 1ddec8d43..82b020179 100644
--- a/src/detection/battery/battery_apple.c
+++ b/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)
diff --git a/src/detection/battery/battery_bsd.c b/src/detection/battery/battery_bsd.c
index 0430f2c33..29799fec2 100644
--- a/src/detection/battery/battery_bsd.c
+++ b/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
diff --git a/src/detection/battery/battery_linux.c b/src/detection/battery/battery_linux.c
index bca7fbfdc..41d49db62 100644
--- a/src/detection/battery/battery_linux.c
+++ b/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);
 
diff --git a/src/detection/battery/battery_nosupport.c b/src/detection/battery/battery_nosupport.c
index 1cc9f79fb..02f084748 100644
--- a/src/detection/battery/battery_nosupport.c
+++ b/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";
 }
diff --git a/src/detection/battery/battery_windows.c b/src/detection/battery/battery_windows.c
index 16bedad17..3afbb996e 100644
--- a/src/detection/battery/battery_windows.c
+++ b/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))) =
diff --git a/src/detection/bluetooth/bluetooth.h b/src/detection/bluetooth/bluetooth.h
index a2aad630f..4aecdfc6f 100644
--- a/src/detection/bluetooth/bluetooth.h
+++ b/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
diff --git a/src/detection/bluetooth/bluetooth_apple.m b/src/detection/bluetooth/bluetooth_apple.m
index 061bf2cf3..d6f3e9878 100644
--- a/src/detection/bluetooth/bluetooth_apple.m
+++ b/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)
diff --git a/src/detection/bluetooth/bluetooth_linux.c b/src/detection/bluetooth/bluetooth_linux.c
index f429387e1..3938cafbd 100644
--- a/src/detection/bluetooth/bluetooth_linux.c
+++ b/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
 }
diff --git a/src/detection/bluetooth/bluetooth_nosupport.c b/src/detection/bluetooth/bluetooth_nosupport.c
index 4fbc5353c..4ae74ac3e 100644
--- a/src/detection/bluetooth/bluetooth_nosupport.c
+++ b/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";
 }
diff --git a/src/detection/bluetooth/bluetooth_windows.c b/src/detection/bluetooth/bluetooth_windows.c
index 698eb86db..0066cebb3 100644
--- a/src/detection/bluetooth/bluetooth_windows.c
+++ b/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,
diff --git a/src/detection/chassis/chassis_windows.cpp b/src/detection/chassis/chassis_windows.cpp
index 3264381c0..99731889a 100644
--- a/src/detection/chassis/chassis_windows.cpp
+++ b/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);
 }
diff --git a/src/detection/cpu/cpu.c b/src/detection/cpu/cpu.c
index 7410dbbee..4fc6d34bc 100644
--- a/src/detection/cpu/cpu.c
+++ b/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[] = {
diff --git a/src/detection/cpu/cpu.h b/src/detection/cpu/cpu.h
index 6c5a3188c..7dd1c29d2 100644
--- a/src/detection/cpu/cpu.h
+++ b/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
diff --git a/src/detection/cpu/cpu_apple.c b/src/detection/cpu/cpu_apple.c
index 51d485699..6de492132 100644
--- a/src/detection/cpu/cpu_apple.c
+++ b/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";
diff --git a/src/detection/cpu/cpu_bsd.c b/src/detection/cpu/cpu_bsd.c
index fe3315e61..835bdd4f6 100644
--- a/src/detection/cpu/cpu_bsd.c
+++ b/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";
diff --git a/src/detection/cpu/cpu_linux.c b/src/detection/cpu/cpu_linux.c
index f9abd1d32..00c332a26 100644
--- a/src/detection/cpu/cpu_linux.c
+++ b/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;
 
diff --git a/src/detection/cpu/cpu_windows.c b/src/detection/cpu/cpu_windows.c
index 8c9246d2f..231ea342e 100644
--- a/src/detection/cpu/cpu_windows.c
+++ b/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;
diff --git a/src/detection/cpuusage/cpuusage.c b/src/detection/cpuusage/cpuusage.c
index 7342bbc55..f12cec257 100644
--- a/src/detection/cpuusage/cpuusage.c
+++ b/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);
 }
diff --git a/src/detection/cursor/cursor.h b/src/detection/cursor/cursor.h
index 268631240..793721f0b 100644
--- a/src/detection/cursor/cursor.h
+++ b/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
diff --git a/src/detection/cursor/cursor_apple.m b/src/detection/cursor/cursor_apple.m
index 3873e979a..40d4b90c9 100644
--- a/src/detection/cursor/cursor_apple.m
+++ b/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)
diff --git a/src/detection/cursor/cursor_linux.c b/src/detection/cursor/cursor_linux.c
index 3ca696091..17ff04765 100644
--- a/src/detection/cursor/cursor_linux.c
+++ b/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");
 }
diff --git a/src/detection/cursor/cursor_nosupport.c b/src/detection/cursor/cursor_nosupport.c
index c54637c96..6e36e55ca 100644
--- a/src/detection/cursor/cursor_nosupport.c
+++ b/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");
 }
diff --git a/src/detection/cursor/cursor_windows.c b/src/detection/cursor/cursor_windows.c
index c3d6c644a..6cb8f8985 100644
--- a/src/detection/cursor/cursor_windows.c
+++ b/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))
     {
diff --git a/src/detection/datetime/datetime.c b/src/detection/datetime/datetime.c
index 317fdcf85..60cc1f658 100644
--- a/src/detection/datetime/datetime.c
+++ b/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;
diff --git a/src/detection/datetime/datetime.h b/src/detection/datetime/datetime.h
index 418f14fb2..fd47ba03b 100644
--- a/src/detection/datetime/datetime.h
+++ b/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
diff --git a/src/detection/displayserver/displayserver.c b/src/detection/displayserver/displayserver.c
index b535012d2..538ff7d89 100644
--- a/src/detection/displayserver/displayserver.c
+++ b/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);
     );
 }
diff --git a/src/detection/displayserver/displayserver.h b/src/detection/displayserver/displayserver.h
index ba874dc25..d45f43070 100644
--- a/src/detection/displayserver/displayserver.h
+++ b/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,
diff --git a/src/detection/displayserver/displayserver_apple.c b/src/detection/displayserver/displayserver_apple.c
index 15e423330..0a7ddde5a 100644
--- a/src/detection/displayserver/displayserver_apple.c
+++ b/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);
diff --git a/src/detection/displayserver/displayserver_nosupport.c b/src/detection/displayserver/displayserver_nosupport.c
index bef1e4554..20e121e65 100644
--- a/src/detection/displayserver/displayserver_nosupport.c
+++ b/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);
diff --git a/src/detection/displayserver/displayserver_windows.c b/src/detection/displayserver/displayserver_windows.c
index 565c8fcce..0a91eedb1 100644
--- a/src/detection/displayserver/displayserver_windows.c
+++ b/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") ||
diff --git a/src/detection/displayserver/linux/displayserver_linux.c b/src/detection/displayserver/linux/displayserver_linux.c
index f2101e010..65f1075ba 100644
--- a/src/detection/displayserver/linux/displayserver_linux.c
+++ b/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);
 }
diff --git a/src/detection/displayserver/linux/displayserver_linux.h b/src/detection/displayserver/linux/displayserver_linux.h
index aee7c25ff..695fcede9 100644
--- a/src/detection/displayserver/linux/displayserver_linux.h
+++ b/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
diff --git a/src/detection/displayserver/linux/wayland.c b/src/detection/displayserver/linux/wayland.c
index 5ab460efd..0f2ec77c6 100644
--- a/src/detection/displayserver/linux/wayland.c
+++ b/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");
diff --git a/src/detection/displayserver/linux/wmde.c b/src/detection/displayserver/linux/wmde.c
index aa9c2c112..91af20511 100644
--- a/src/detection/displayserver/linux/wmde.c
+++ b/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(
diff --git a/src/detection/displayserver/linux/xcb.c b/src/detection/displayserver/linux/xcb.c
index 8812e1b98..47c5ec851 100644
--- a/src/detection/displayserver/linux/xcb.c
+++ b/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
diff --git a/src/detection/displayserver/linux/xlib.c b/src/detection/displayserver/linux/xlib.c
index 9045a7e53..288763ee6 100644
--- a/src/detection/displayserver/linux/xlib.c
+++ b/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
diff --git a/src/detection/font/font.c b/src/detection/font/font.c
index 4455ea45f..6de21cfdf 100644
--- a/src/detection/font/font.c
+++ b/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;
 
diff --git a/src/detection/font/font.h b/src/detection/font/font.h
index 9b7e4e237..22e402652 100644
--- a/src/detection/font/font.h
+++ b/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
diff --git a/src/detection/font/font_apple.m b/src/detection/font/font_apple.m
index 818047a97..9a9888e5f 100644
--- a/src/detection/font/font_apple.m
+++ b/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);
diff --git a/src/detection/font/font_linux.c b/src/detection/font/font_linux.c
index 304450c70..7cee52ccd 100644
--- a/src/detection/font/font_linux.c
+++ b/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);
 
diff --git a/src/detection/font/font_nosupport.c b/src/detection/font/font_nosupport.c
index c64936584..cce3904ff 100644
--- a/src/detection/font/font_nosupport.c
+++ b/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";
 }
diff --git a/src/detection/font/font_windows.c b/src/detection/font/font_windows.c
index 202aa8b51..46a63f520 100644
--- a/src/detection/font/font_windows.c
+++ b/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))
diff --git a/src/detection/gamepad/gamepad.h b/src/detection/gamepad/gamepad.h
index 1def1b430..59519bb16 100644
--- a/src/detection/gamepad/gamepad.h
+++ b/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
diff --git a/src/detection/gamepad/gamepad_apple.c b/src/detection/gamepad/gamepad_apple.c
index 154f1c587..b1a8436ca 100644
--- a/src/detection/gamepad/gamepad_apple.c
+++ b/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)
diff --git a/src/detection/gamepad/gamepad_bsd.c b/src/detection/gamepad/gamepad_bsd.c
index 49f49bf58..9ede2280b 100644
--- a/src/detection/gamepad/gamepad_bsd.c
+++ b/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++)
diff --git a/src/detection/gamepad/gamepad_linux.c b/src/detection/gamepad/gamepad_linux.c
index 8bbd53939..c68a31d74 100644
--- a/src/detection/gamepad/gamepad_linux.c
+++ b/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)
diff --git a/src/detection/gamepad/gamepad_nosupport.c b/src/detection/gamepad/gamepad_nosupport.c
index d921d3552..7c323142a 100644
--- a/src/detection/gamepad/gamepad_nosupport.c
+++ b/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";
 }
diff --git a/src/detection/gamepad/gamepad_windows.c b/src/detection/gamepad/gamepad_windows.c
index 216bde8e8..e115782aa 100644
--- a/src/detection/gamepad/gamepad_windows.c
+++ b/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)))
diff --git a/src/detection/gpu/gpu.c b/src/detection/gpu/gpu.c
index f78eeb433..9300b2484 100644
--- a/src/detection/gpu/gpu.c
+++ b/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);
diff --git a/src/detection/gpu/gpu.h b/src/detection/gpu/gpu.h
index 444e68f87..c0f5dfaa8 100644
--- a/src/detection/gpu/gpu.h
+++ b/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);
 
diff --git a/src/detection/gpu/gpu_apple.c b/src/detection/gpu/gpu_apple.c
index cdb8b8f79..00ee7422b 100644
--- a/src/detection/gpu/gpu_apple.c
+++ b/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;
diff --git a/src/detection/gpu/gpu_linux.c b/src/detection/gpu/gpu_linux.c
index 8b9478e1b..8374e418b 100644
--- a/src/detection/gpu/gpu_linux.c
+++ b/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
 }
diff --git a/src/detection/gpu/gpu_nosupport.c b/src/detection/gpu/gpu_nosupport.c
index c32574c56..28daf5fa6 100644
--- a/src/detection/gpu/gpu_nosupport.c
+++ b/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";
 }
diff --git a/src/detection/gpu/gpu_windows.c b/src/detection/gpu/gpu_windows.c
index 2866ff5f3..a018bafca 100644
--- a/src/detection/gpu/gpu_windows.c
+++ b/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\\{";
diff --git a/src/detection/gtk_qt/gtk.c b/src/detection/gtk_qt/gtk.c
index b611827f4..8c7debe01 100644
--- a/src/detection/gtk_qt/gtk.c
+++ b/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)
 }
diff --git a/src/detection/gtk_qt/gtk_qt.h b/src/detection/gtk_qt/gtk_qt.h
index 8a115e5b0..ef329f03a 100644
--- a/src/detection/gtk_qt/gtk_qt.h
+++ b/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
diff --git a/src/detection/gtk_qt/qt.c b/src/detection/gtk_qt/qt.c
index 7955be14c..71b0536c7 100644
--- a/src/detection/gtk_qt/qt.c
+++ b/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;
diff --git a/src/detection/icons/icons.h b/src/detection/icons/icons.h
index 4f948cdad..744dc3f5f 100644
--- a/src/detection/icons/icons.h
+++ b/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
diff --git a/src/detection/icons/icons_linux.c b/src/detection/icons/icons_linux.c
index 5246950db..357cfadb6 100644
--- a/src/detection/icons/icons_linux.c
+++ b/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";
diff --git a/src/detection/icons/icons_nosupport.c b/src/detection/icons/icons_nosupport.c
index 9a47a0183..f0a0ebe8c 100644
--- a/src/detection/icons/icons_nosupport.c
+++ b/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";
 }
diff --git a/src/detection/icons/icons_windows.c b/src/detection/icons/icons_windows.c
index 881589bc1..0008d04af 100644
--- a/src/detection/icons/icons_windows.c
+++ b/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))
diff --git a/src/detection/media/media.c b/src/detection/media/media.c
index 7bb38d0e5..50604342b 100644
--- a/src/detection/media/media.c
+++ b/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");
diff --git a/src/detection/media/media.h b/src/detection/media/media.h
index f82fa4359..8043e0d93 100644
--- a/src/detection/media/media.h
+++ b/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
diff --git a/src/detection/media/media_apple.m b/src/detection/media/media_apple.m
index 3e4bf3d75..741301273 100644
--- a/src/detection/media/media_apple.m
+++ b/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);
diff --git a/src/detection/media/media_linux.c b/src/detection/media/media_linux.c
index 9eb92bf73..2552fdab2 100644
--- a/src/detection/media/media_linux.c
+++ b/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
 }
diff --git a/src/detection/media/media_nosupport.c b/src/detection/media/media_nosupport.c
index e3d038186..b0c19a652 100644
--- a/src/detection/media/media_nosupport.c
+++ b/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");
 }
diff --git a/src/detection/opencl/opencl.c b/src/detection/opencl/opencl.c
index 2e5949af9..d8cb4a66b 100644
--- a/src/detection/opencl/opencl.c
+++ b/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
diff --git a/src/detection/opencl/opencl.h b/src/detection/opencl/opencl.h
index 93cceecc8..56a96c98f 100644
--- a/src/detection/opencl/opencl.h
+++ b/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
diff --git a/src/detection/opengl/opengl.h b/src/detection/opengl/opengl.h
index 206347184..b4426856b 100644
--- a/src/detection/opengl/opengl.h
+++ b/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
diff --git a/src/detection/opengl/opengl_apple.c b/src/detection/opengl/opengl_apple.c
index 4ccbb5fe6..b6f4fe257 100644
--- a/src/detection/opengl/opengl_apple.c
+++ b/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,
diff --git a/src/detection/opengl/opengl_linux.c b/src/detection/opengl/opengl_linux.c
index 9a4f42bec..43378be63 100644
--- a/src/detection/opengl/opengl_linux.c
+++ b/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
diff --git a/src/detection/opengl/opengl_windows.c b/src/detection/opengl/opengl_windows.c
index a3865e550..11d608db5 100644
--- a/src/detection/opengl/opengl_windows.c
+++ b/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,
diff --git a/src/detection/os/os.c b/src/detection/os/os.c
index dee22a566..c09935954 100644
--- a/src/detection/os/os.c
+++ b/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)
     );
 }
diff --git a/src/detection/os/os.h b/src/detection/os/os.h
index 80fb6b2af..87af406a9 100644
--- a/src/detection/os/os.h
+++ b/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
diff --git a/src/detection/os/os_android.c b/src/detection/os/os_android.c
index 890486ab7..18b491283 100644
--- a/src/detection/os/os_android.c
+++ b/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");
diff --git a/src/detection/os/os_apple.m b/src/detection/os/os_apple.m
index dac09ddcd..98e639bad 100644
--- a/src/detection/os/os_apple.m
+++ b/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);
diff --git a/src/detection/os/os_linux.c b/src/detection/os/os_linux.c
index 063e8455b..eb37a5bad 100644
--- a/src/detection/os/os_linux.c
+++ b/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);
diff --git a/src/detection/os/os_windows.cpp b/src/detection/os/os_windows.cpp
index aa25e90ae..addb61f17 100644
--- a/src/detection/os/os_windows.cpp
+++ b/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);
diff --git a/src/detection/packages/packages.c b/src/detection/packages/packages.c
index b820be2ba..ce7c778c3 100644
--- a/src/detection/packages/packages.c
+++ b/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];
diff --git a/src/detection/packages/packages.h b/src/detection/packages/packages.h
index 1a83645e9..ef1cf1d4f 100644
--- a/src/detection/packages/packages.h
+++ b/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
diff --git a/src/detection/packages/packages_apple.c b/src/detection/packages/packages_apple.c
index 0f7ab36e0..97e858fbe 100644
--- a/src/detection/packages/packages_apple.c
+++ b/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();
 }
diff --git a/src/detection/packages/packages_linux.c b/src/detection/packages/packages_linux.c
index 3fc5c9816..d67a05a74 100644
--- a/src/detection/packages/packages_linux.c
+++ b/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");
 }
diff --git a/src/detection/packages/packages_windows.c b/src/detection/packages/packages_windows.c
index 30870ce5d..5b5343f79 100644
--- a/src/detection/packages/packages_windows.c
+++ b/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);
 }
diff --git a/src/detection/poweradapter/poweradapter.h b/src/detection/poweradapter/poweradapter.h
index 1b9abd513..9abdd48ec 100644
--- a/src/detection/poweradapter/poweradapter.h
+++ b/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
diff --git a/src/detection/poweradapter/poweradapter_apple.c b/src/detection/poweradapter/poweradapter_apple.c
index 9c550d95d..de3025a40 100644
--- a/src/detection/poweradapter/poweradapter_apple.c
+++ b/src/detection/poweradapter/poweradapter_apple.c
@@ -4,10 +4,8 @@
 
 #include <IOKit/IOKitLib.h>
 
-const char* ffDetectPowerAdapterImpl(FFinstance* instance, FFlist* results)
+const char* ffDetectPowerAdapterImpl(FFlist* results)
 {
-    FF_UNUSED(instance);
-
     CFMutableDictionaryRef matchDict = IOServiceMatching("AppleSmartBattery");
     if (matchDict == NULL)
         return "IOServiceMatching(\"AppleSmartBattery\") failed";
diff --git a/src/detection/poweradapter/poweradapter_nosupport.c b/src/detection/poweradapter/poweradapter_nosupport.c
index cf6d1c841..80730810d 100644
--- a/src/detection/poweradapter/poweradapter_nosupport.c
+++ b/src/detection/poweradapter/poweradapter_nosupport.c
@@ -1,7 +1,7 @@
 #include "fastfetch.h"
 
-const char* ffDetectPowerAdapterImpl(FFinstance* instance, FFlist* results)
+const char* ffDetectPowerAdapterImpl(FFlist* results)
 {
-    FF_UNUSED(instance, results);
+    FF_UNUSED(results);
     return "Not supported on this platform";
 }
diff --git a/src/detection/sound/sound.h b/src/detection/sound/sound.h
index 7603110f6..350a4f3e6 100644
--- a/src/detection/sound/sound.h
+++ b/src/detection/sound/sound.h
@@ -16,6 +16,6 @@ typedef struct FFSoundDevice
     bool active;
 } FFSoundDevice;
 
-const char* ffDetectSound(const FFinstance* instance, FFlist* devices /* List of FFSoundDevice */);
+const char* ffDetectSound(FFlist* devices /* List of FFSoundDevice */);
 
 #endif
diff --git a/src/detection/sound/sound_apple.c b/src/detection/sound/sound_apple.c
index 862ee523a..8f23f2a3a 100644
--- a/src/detection/sound/sound_apple.c
+++ b/src/detection/sound/sound_apple.c
@@ -8,7 +8,7 @@
 #define kAudioObjectPropertyElementMain kAudioObjectPropertyElementMaster
 #endif
 
-const char* ffDetectSound(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* devices /* List of FFSoundDevice */)
+const char* ffDetectSound(FFlist* devices /* List of FFSoundDevice */)
 {
     AudioDeviceID mainDeviceId;
     UInt32 dataSize = sizeof(mainDeviceId);
diff --git a/src/detection/sound/sound_linux.c b/src/detection/sound/sound_linux.c
index bba07c13b..8f14ab49e 100644
--- a/src/detection/sound/sound_linux.c
+++ b/src/detection/sound/sound_linux.c
@@ -36,9 +36,9 @@ static void paServerInfoCallback(pa_context *c, const pa_server_info *i, void *u
     }
 }
 
-static const char* detectSound(const FFinstance* instance, FFlist* devices)
+static const char* detectSound(FFlist* devices)
 {
-    FF_LIBRARY_LOAD(pulse, &instance->config.libPulse, "Failed to load libpulse" FF_LIBRARY_EXTENSION, "libpulse" FF_LIBRARY_EXTENSION, 0)
+    FF_LIBRARY_LOAD(pulse, &instance.config.libPulse, "Failed to load libpulse" FF_LIBRARY_EXTENSION, "libpulse" FF_LIBRARY_EXTENSION, 0)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(pulse, pa_mainloop_new)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(pulse, pa_mainloop_get_api)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(pulse, pa_mainloop_iterate)
@@ -119,12 +119,12 @@ static const char* detectSound(const FFinstance* instance, FFlist* devices)
 
 #endif // FF_HAVE_PULSE
 
-const char* ffDetectSound(const FFinstance* instance, FFlist* devices)
+const char* ffDetectSound(FFlist* devices)
 {
     #ifdef FF_HAVE_PULSE
-        return detectSound(instance, devices);
+        return detectSound(devices);
     #else
-        FF_UNUSED(instance, devices);
+        FF_UNUSED(devices);
         return "Fastfetch was built without libpulse support";
     #endif
 }
diff --git a/src/detection/sound/sound_nosupport.c b/src/detection/sound/sound_nosupport.c
index 8f8014341..7b23b2fa4 100644
--- a/src/detection/sound/sound_nosupport.c
+++ b/src/detection/sound/sound_nosupport.c
@@ -1,6 +1,6 @@
 #include "sound.h"
 
-const char* ffDetectSound(FF_MAYBE_UNUSED const FFinstance* instance, FF_MAYBE_UNUSED FFlist* devices /* List of FFSoundDevice */)
+const char* ffDetectSound(FF_MAYBE_UNUSED FFlist* devices /* List of FFSoundDevice */)
 {
     return "Not supported on this platform";
 }
diff --git a/src/detection/sound/sound_windows.cpp b/src/detection/sound/sound_windows.cpp
index faa7328f4..6990615ab 100644
--- a/src/detection/sound/sound_windows.cpp
+++ b/src/detection/sound/sound_windows.cpp
@@ -9,7 +9,7 @@ extern "C" {
 #include <endpointvolume.h>
 #include <functiondiscoverykeys_devpkey.h>
 
-const char* ffDetectSound(FF_MAYBE_UNUSED const FFinstance* instance, FF_MAYBE_UNUSED FFlist* devices /* List of FFSoundDevice */)
+const char* ffDetectSound(FFlist* devices /* List of FFSoundDevice */)
 {
     const char* error = ffInitCom();
     if (error)
diff --git a/src/detection/temps/temps_linux.c b/src/detection/temps/temps_linux.c
index 55506c384..ee30a85c4 100644
--- a/src/detection/temps/temps_linux.c
+++ b/src/detection/temps/temps_linux.c
@@ -41,7 +41,7 @@ static bool parseHwmonDir(FFstrbuf* dir, FFTempValue* value)
     return value->name.length > 0 || value->deviceClass > 0;
 }
 
-const FFTempsResult* ffDetectTemps()
+const FFTempsResult* ffDetectTemps(void)
 {
     static FFTempsResult result;
     static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
diff --git a/src/detection/terminalfont/terminalfont.c b/src/detection/terminalfont/terminalfont.c
index 46c390955..58320d223 100644
--- a/src/detection/terminalfont/terminalfont.c
+++ b/src/detection/terminalfont/terminalfont.c
@@ -4,7 +4,7 @@
 #include "detection/internal.h"
 #include "detection/terminalshell/terminalshell.h"
 
-static void detectAlacritty(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectAlacritty(FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
@@ -15,11 +15,11 @@ static void detectAlacritty(const FFinstance* instance, FFTerminalFontResult* te
     };
 
     // alacritty parses config files in this order
-    ffParsePropFileConfigValues(instance, "alacritty/alacritty.yml", 2, fontQuery);
+    ffParsePropFileConfigValues("alacritty/alacritty.yml", 2, fontQuery);
     if(fontName.length == 0 || fontSize.length == 0)
-        ffParsePropFileConfigValues(instance, "alacritty.yml", 2, fontQuery);
+        ffParsePropFileConfigValues("alacritty.yml", 2, fontQuery);
     if(fontName.length == 0 || fontSize.length == 0)
-        ffParsePropFileConfigValues(instance, ".alacritty.yml", 2, fontQuery);
+        ffParsePropFileConfigValues(".alacritty.yml", 2, fontQuery);
 
     //by default alacritty uses its own font called alacritty
     if(fontName.length == 0)
@@ -238,7 +238,7 @@ static void detectFromWindowsTeriminal(const FFstrbuf* terminalExe, FFTerminalFo
 
 #endif //defined(_WIN32) || defined(__linux__)
 
-FF_MAYBE_UNUSED static bool detectKitty(const FFinstance* instance, FFTerminalFontResult* result)
+FF_MAYBE_UNUSED static bool detectKitty(FFTerminalFontResult* result)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
@@ -248,7 +248,7 @@ FF_MAYBE_UNUSED static bool detectKitty(const FFinstance* instance, FFTerminalFo
         {"font_size ", &fontSize},
     };
 
-    if(!ffParsePropFileConfigValues(instance, "kitty/kitty.conf", 2, fontQuery))
+    if(!ffParsePropFileConfigValues("kitty/kitty.conf", 2, fontQuery))
         return false;
 
     if(fontName.length == 0)
@@ -261,7 +261,7 @@ FF_MAYBE_UNUSED static bool detectKitty(const FFinstance* instance, FFTerminalFo
     return true;
 }
 
-static void detectTerminator(const FFinstance* instance, FFTerminalFontResult* result)
+static void detectTerminator(FFTerminalFontResult* result)
 {
     FF_STRBUF_AUTO_DESTROY useSystemFont = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
@@ -271,7 +271,7 @@ static void detectTerminator(const FFinstance* instance, FFTerminalFontResult* r
         {"font =", &fontName},
     };
 
-    if(!ffParsePropFileConfigValues(instance, "terminator/config", 2, fontQuery))
+    if(!ffParsePropFileConfigValues("terminator/config", 2, fontQuery))
     {
         ffStrbufAppendS(&result->error, "Couldn't read Terminator config file");
         return;
@@ -289,7 +289,7 @@ static void detectTerminator(const FFinstance* instance, FFTerminalFontResult* r
         ffFontInitPango(&result->font, fontName.chars);
 }
 
-static bool detectWezterm(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminalFontResult* result)
+static bool detectWezterm(FFTerminalFontResult* result)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
 
@@ -316,7 +316,7 @@ static bool detectWezterm(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminal
     return true;
 }
 
-static bool detectTabby(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminalFontResult* result)
+static bool detectTabby(FFTerminalFontResult* result)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
@@ -326,7 +326,7 @@ static bool detectTabby(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminalFo
         {"fontSize: ", &fontSize},
     };
 
-    if(!ffParsePropFileConfigValues(instance, "tabby/config.yaml", 2, fontQuery))
+    if(!ffParsePropFileConfigValues("tabby/config.yaml", 2, fontQuery))
         return false;
 
     if(fontName.length == 0)
@@ -339,24 +339,24 @@ static bool detectTabby(FF_MAYBE_UNUSED const FFinstance* instance, FFTerminalFo
     return true;
 }
 
-void ffDetectTerminalFontPlatform(const FFinstance* instance, const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont);
+void ffDetectTerminalFontPlatform(const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont);
 
-static bool detectTerminalFontCommon(const FFinstance* instance, const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
+static bool detectTerminalFontCommon(const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalProcessName, "alacritty"))
-        detectAlacritty(instance, terminalFont);
+        detectAlacritty(terminalFont);
     else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalProcessName, "terminator"))
-        detectTerminator(instance, terminalFont);
+        detectTerminator(terminalFont);
     else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalProcessName, "wezterm-gui"))
-        detectWezterm(instance, terminalFont);
+        detectWezterm(terminalFont);
     else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalProcessName, "tabby"))
-        detectTabby(instance, terminalFont);
+        detectTabby(terminalFont);
 
     #ifndef _WIN32
     else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalExe, "/dev/pts/"))
         ffStrbufAppendS(&terminalFont->error, "Terminal font detection is not supported on PTS");
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "kitty"))
-        detectKitty(instance, terminalFont);
+        detectKitty(terminalFont);
     else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalExe, "/dev/tty"))
         detectTTY(terminalFont);
     #endif
@@ -374,15 +374,15 @@ static bool detectTerminalFontCommon(const FFinstance* instance, const FFTermina
     return true;
 }
 
-bool ffDetectTerminalFont(const FFinstance* instance, FFTerminalFontResult* result)
+bool ffDetectTerminalFont(FFTerminalFontResult* result)
 {
-    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell(instance);
+    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell();
 
     if(terminalShell->terminalProcessName.length == 0)
         ffStrbufAppendS(&result->error, "Terminal font needs successful terminal detection");
 
-    else if(!detectTerminalFontCommon(instance, terminalShell, result))
-        ffDetectTerminalFontPlatform(instance, terminalShell, result);
+    else if(!detectTerminalFontCommon(terminalShell, result))
+        ffDetectTerminalFontPlatform(terminalShell, result);
 
     if(result->error.length == 0 && result->font.pretty.length == 0)
         ffStrbufAppendF(&result->error, "Unknown terminal: %s", terminalShell->terminalProcessName.chars);
diff --git a/src/detection/terminalfont/terminalfont.h b/src/detection/terminalfont/terminalfont.h
index a542d3226..9b15dede4 100644
--- a/src/detection/terminalfont/terminalfont.h
+++ b/src/detection/terminalfont/terminalfont.h
@@ -12,6 +12,6 @@ typedef struct FFTerminalFontResult
     FFfont font;
 } FFTerminalFontResult;
 
-bool ffDetectTerminalFont(const FFinstance* instance, FFTerminalFontResult* result);
+bool ffDetectTerminalFont(FFTerminalFontResult* result);
 
 #endif
diff --git a/src/detection/terminalfont/terminalfont_android.c b/src/detection/terminalfont/terminalfont_android.c
index 251ada6c7..ae79a4517 100644
--- a/src/detection/terminalfont/terminalfont_android.c
+++ b/src/detection/terminalfont/terminalfont_android.c
@@ -11,11 +11,11 @@
 
 #define FF_TERMUX_FONT_PATH FASTFETCH_TARGET_DIR_HOME "/.termux/font.ttf"
 
-const char* detectTermux(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+const char* detectTermux(FFTerminalFontResult* terminalFont)
 {
     #ifdef FF_HAVE_FREETYPE
 
-    FF_LIBRARY_LOAD(freetype, &instance->config.libfreetype, "dlopen libfreetype"FF_LIBRARY_EXTENSION " failed", "libfreetype"FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(freetype, &instance.config.libfreetype, "dlopen libfreetype"FF_LIBRARY_EXTENSION " failed", "libfreetype"FF_LIBRARY_EXTENSION, 2)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(freetype, FT_Init_FreeType);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(freetype, FT_New_Face);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(freetype, FT_Done_Face);
@@ -53,7 +53,7 @@ exit:
     #endif
 }
 
-void ffDetectTerminalFontPlatform(const FFinstance* instance, const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
+void ffDetectTerminalFontPlatform(const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufCompS(&terminalShell->terminalProcessName, "Termux") != 0)
     {
@@ -67,5 +67,5 @@ void ffDetectTerminalFontPlatform(const FFinstance* instance, const FFTerminalSh
         return;
     }
 
-    ffStrbufSetS(&terminalFont->error, detectTermux(instance, terminalFont));
+    ffStrbufSetS(&terminalFont->error, detectTermux(terminalFont));
 }
diff --git a/src/detection/terminalfont/terminalfont_apple.m b/src/detection/terminalfont/terminalfont_apple.m
index f95503585..c89b4135f 100644
--- a/src/detection/terminalfont/terminalfont_apple.m
+++ b/src/detection/terminalfont/terminalfont_apple.m
@@ -7,7 +7,7 @@
 #include <string.h>
 #import <Foundation/Foundation.h>
 
-static void detectIterm2(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectIterm2(FFTerminalFontResult* terminalFont)
 {
     const char* profile = getenv("ITERM_PROFILE");
     if (profile == NULL)
@@ -17,7 +17,7 @@ static void detectIterm2(const FFinstance* instance, FFTerminalFontResult* termi
     }
 
     NSError* error;
-    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/com.googlecode.iterm2.plist", instance->state.platform.homeDir.chars];
+    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/com.googlecode.iterm2.plist", instance.state.platform.homeDir.chars];
     NSDictionary* dict = [NSDictionary dictionaryWithContentsOfURL:[NSURL URLWithString:fileName]
                                        error:&error];
     if(error)
@@ -58,10 +58,10 @@ static void detectAppleTerminal(FFTerminalFontResult* terminalFont)
     ffFontInitWithSpace(&terminalFont->font, font.chars);
 }
 
-static void detectWarpTerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectWarpTerminal(FFTerminalFontResult* terminalFont)
 {
     NSError* error;
-    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/dev.warp.Warp-Stable.plist", instance->state.platform.homeDir.chars];
+    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/dev.warp.Warp-Stable.plist", instance.state.platform.homeDir.chars];
     NSDictionary* dict = [NSDictionary dictionaryWithContentsOfURL:[NSURL URLWithString:fileName]
                                        error:&error];
     if(error)
@@ -83,13 +83,13 @@ static void detectWarpTerminal(const FFinstance* instance, FFTerminalFontResult*
     ffFontInitValues(&terminalFont->font, fontName.UTF8String, fontSize.UTF8String);
 }
 
-void ffDetectTerminalFontPlatform(const FFinstance* instance, const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
+void ffDetectTerminalFontPlatform(const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "iterm.app") == 0 ||
         ffStrbufStartsWithIgnCaseS(&terminalShell->terminalProcessName, "iTermServer-"))
-        detectIterm2(instance, terminalFont);
+        detectIterm2(terminalFont);
     else if(ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "Apple_Terminal") == 0)
         detectAppleTerminal(terminalFont);
     else if(ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "WarpTerminal") == 0)
-        detectWarpTerminal(instance, terminalFont);
+        detectWarpTerminal(terminalFont);
 }
diff --git a/src/detection/terminalfont/terminalfont_linux.c b/src/detection/terminalfont/terminalfont_linux.c
index 32cb3b847..fabca6902 100644
--- a/src/detection/terminalfont/terminalfont_linux.c
+++ b/src/detection/terminalfont/terminalfont_linux.c
@@ -7,29 +7,29 @@
 #include "util/mallocHelper.h"
 #include "util/stringUtils.h"
 
-static const char* getSystemMonospaceFont(const FFinstance* instance)
+static const char* getSystemMonospaceFont(void)
 {
-    const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
     if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, "Cinnamon"))
     {
-        const char* systemMonospaceFont = ffSettingsGet(instance, "/org/cinnamon/desktop/interface/monospace-font-name", "org.cinnamon.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
+        const char* systemMonospaceFont = ffSettingsGet("/org/cinnamon/desktop/interface/monospace-font-name", "org.cinnamon.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
         if(ffStrSet(systemMonospaceFont))
             return systemMonospaceFont;
     }
     else if(ffStrbufIgnCaseEqualS(&wmde->dePrettyName, "Mate"))
     {
-        const char* systemMonospaceFont = ffSettingsGet(instance, "/org/mate/interface/monospace-font-name", "org.mate.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
+        const char* systemMonospaceFont = ffSettingsGet("/org/mate/interface/monospace-font-name", "org.mate.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
         if(ffStrSet(systemMonospaceFont))
             return systemMonospaceFont;
     }
 
-    return ffSettingsGet(instance, "/org/gnome/desktop/interface/monospace-font-name", "org.gnome.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
+    return ffSettingsGet("/org/gnome/desktop/interface/monospace-font-name", "org.gnome.desktop.interface", NULL, "monospace-font-name", FF_VARIANT_TYPE_STRING).strValue;
 }
 
-static void detectFromGSettings(const FFinstance* instance, const char* profilePath, const char* profileList, const char* profile, const char* defaultProfileKey, FFTerminalFontResult* terminalFont)
+static void detectFromGSettings(const char* profilePath, const char* profileList, const char* profile, const char* defaultProfileKey, FFTerminalFontResult* terminalFont)
 {
-    FF_AUTO_FREE const char* defaultProfile = ffSettingsGetGSettings(instance, profileList, NULL, defaultProfileKey, FF_VARIANT_TYPE_STRING).strValue;
+    FF_AUTO_FREE const char* defaultProfile = ffSettingsGetGSettings(profileList, NULL, defaultProfileKey, FF_VARIANT_TYPE_STRING).strValue;
     if(!ffStrSet(defaultProfile))
     {
         ffStrbufAppendF(&terminalFont->error, "Could not get default profile from gsettings: %s", profileList);
@@ -41,9 +41,9 @@ static void detectFromGSettings(const FFinstance* instance, const char* profileP
     ffStrbufAppendS(&path, defaultProfile);
     ffStrbufAppendC(&path, '/');
 
-    if(!ffSettingsGetGSettings(instance, profile, path.chars, "use-system-font", FF_VARIANT_TYPE_BOOL).boolValue)
+    if(!ffSettingsGetGSettings(profile, path.chars, "use-system-font", FF_VARIANT_TYPE_BOOL).boolValue)
     {
-        FF_AUTO_FREE const char* fontName = ffSettingsGetGSettings(instance, profile, path.chars, "font", FF_VARIANT_TYPE_STRING).strValue;
+        FF_AUTO_FREE const char* fontName = ffSettingsGetGSettings(profile, path.chars, "font", FF_VARIANT_TYPE_STRING).strValue;
         if(ffStrSet(fontName))
             ffFontInitPango(&terminalFont->font, fontName);
         else
@@ -51,7 +51,7 @@ static void detectFromGSettings(const FFinstance* instance, const char* profileP
     }
     else
     {
-        const char* fontName = getSystemMonospaceFont(instance);
+        const char* fontName = getSystemMonospaceFont();
         if(ffStrSet(fontName))
             ffFontInitPango(&terminalFont->font, fontName);
         else
@@ -59,10 +59,10 @@ static void detectFromGSettings(const FFinstance* instance, const char* profileP
     }
 }
 
-static void detectFromConfigFile(const FFinstance* instance, const char* configFile, const char* start, FFTerminalFontResult* terminalFont)
+static void detectFromConfigFile(const char* configFile, const char* start, FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
-    ffParsePropFileConfig(instance, configFile, start, &fontName);
+    ffParsePropFileConfig(configFile, start, &fontName);
 
     if(fontName.length == 0)
         ffStrbufAppendF(&terminalFont->error, "Couldn't find %s in .config/%s", start, configFile);
@@ -70,10 +70,10 @@ static void detectFromConfigFile(const FFinstance* instance, const char* configF
         ffFontInitPango(&terminalFont->font, fontName.chars);
 }
 
-static void detectKonsole(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectKonsole(FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY profile = ffStrbufCreate();
-    ffParsePropFileConfig(instance, "konsolerc", "DefaultProfile =", &profile);
+    ffParsePropFileConfig("konsolerc", "DefaultProfile =", &profile);
 
     if(profile.length == 0)
     {
@@ -86,7 +86,7 @@ static void detectKonsole(const FFinstance* instance, FFTerminalFontResult* term
     ffStrbufAppend(&profilePath, &profile);
 
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
-    ffParsePropFileData(instance, profilePath.chars, "Font =", &fontName);
+    ffParsePropFileData(profilePath.chars, "Font =", &fontName);
 
     if(fontName.length == 0)
         ffStrbufAppendF(&terminalFont->error, "Couldn't find \"Font=%%[^\\n]\" in \"%s\"", profilePath.chars);
@@ -94,12 +94,12 @@ static void detectKonsole(const FFinstance* instance, FFTerminalFontResult* term
         ffFontInitQt(&terminalFont->font, fontName.chars);
 }
 
-static void detectXFCETerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectXFCETerminal(FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY useSysFont = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
 
-    ffParsePropFileConfigValues(instance, "xfce4/terminal/terminalrc", 2, (FFpropquery[]) {
+    ffParsePropFileConfigValues("xfce4/terminal/terminalrc", 2, (FFpropquery[]) {
         {"FontUseSystem = ", &useSysFont},
         {"FontName = ", &fontName}
     });
@@ -113,7 +113,7 @@ static void detectXFCETerminal(const FFinstance* instance, FFTerminalFontResult*
     }
     else
     {
-        const char* systemFontName = ffSettingsGetXFConf(instance, "xsettings", "/Gtk/MonospaceFontName", FF_VARIANT_TYPE_STRING).strValue;
+        const char* systemFontName = ffSettingsGetXFConf("xsettings", "/Gtk/MonospaceFontName", FF_VARIANT_TYPE_STRING).strValue;
         if(ffStrSet(systemFontName))
             ffFontInitPango(&terminalFont->font, systemFontName);
         else
@@ -121,13 +121,13 @@ static void detectXFCETerminal(const FFinstance* instance, FFTerminalFontResult*
     }
 }
 
-static void detectDeepinTerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectDeepinTerminal(FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY profile = ffStrbufCreate();
 
-    ffStrbufAppend(&profile, &instance->state.platform.homeDir);
+    ffStrbufAppend(&profile, &instance.state.platform.homeDir);
     ffStrbufAppendS(&profile, ".config/deepin/deepin-terminal/config.conf"); //TODO: Use config dirs
     FILE* file = fopen(profile.chars, "r");
 
@@ -164,11 +164,11 @@ static void detectDeepinTerminal(const FFinstance* instance, FFTerminalFontResul
     ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
 }
 
-static void detectFootTerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectFootTerminal(FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY font = ffStrbufCreate();
 
-    if (!ffParsePropFileConfig(instance, "foot/foot.ini", "font=", &font) || !ffStrSet(font.chars))
+    if (!ffParsePropFileConfig("foot/foot.ini", "font=", &font) || !ffStrSet(font.chars))
     {
         ffFontInitValues(&terminalFont->font, "monospace", "8");
         return;
@@ -191,12 +191,12 @@ static void detectFootTerminal(const FFinstance* instance, FFTerminalFontResult*
     ffFontInitValues(&terminalFont->font, font.chars, &font.chars[equal + strlen("size=")]);
 }
 
-static void detectQTerminal(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectQTerminal(FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
 
-    ffParsePropFileConfigValues(instance, "qterminal.org/qterminal.ini", 2, (FFpropquery[]) {
+    ffParsePropFileConfigValues("qterminal.org/qterminal.ini", 2, (FFpropquery[]) {
         {"fontFamily=", &fontName},
         {"fontSize=", &fontSize},
     });
@@ -208,24 +208,24 @@ static void detectQTerminal(const FFinstance* instance, FFTerminalFontResult* te
     ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
 }
 
-void ffDetectTerminalFontPlatform(const FFinstance* instance, const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
+void ffDetectTerminalFontPlatform(const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "konsole"))
-        detectKonsole(instance, terminalFont);
+        detectKonsole(terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "xfce4-terminal"))
-        detectXFCETerminal(instance, terminalFont);
+        detectXFCETerminal(terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "lxterminal"))
-        detectFromConfigFile(instance, "lxterminal/lxterminal.conf", "fontname =", terminalFont);
+        detectFromConfigFile("lxterminal/lxterminal.conf", "fontname =", terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "tilix"))
-        detectFromGSettings(instance, "/com/gexperts/Tilix/profiles/", "com.gexperts.Tilix.ProfilesList", "com.gexperts.Tilix.Profile", "default", terminalFont);
+        detectFromGSettings("/com/gexperts/Tilix/profiles/", "com.gexperts.Tilix.ProfilesList", "com.gexperts.Tilix.Profile", "default", terminalFont);
     else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalProcessName, "gnome-terminal-"))
-        detectFromGSettings(instance, "/org/gnome/terminal/legacy/profiles:/:", "org.gnome.Terminal.ProfilesList", "org.gnome.Terminal.Legacy.Profile", "default", terminalFont);
+        detectFromGSettings("/org/gnome/terminal/legacy/profiles:/:", "org.gnome.Terminal.ProfilesList", "org.gnome.Terminal.Legacy.Profile", "default", terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "mate-terminal"))
-        detectFromGSettings(instance, "/org/mate/terminal/profiles/", "org.mate.terminal.global", "org.mate.terminal.profile", "default-profile", terminalFont);
+        detectFromGSettings("/org/mate/terminal/profiles/", "org.mate.terminal.global", "org.mate.terminal.profile", "default-profile", terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "deepin-terminal"))
-        detectDeepinTerminal(instance, terminalFont);
+        detectDeepinTerminal(terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "foot"))
-        detectFootTerminal(instance, terminalFont);
+        detectFootTerminal(terminalFont);
     else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "qterminal"))
-        detectQTerminal(instance, terminalFont);
+        detectQTerminal(terminalFont);
 }
diff --git a/src/detection/terminalfont/terminalfont_windows.c b/src/detection/terminalfont/terminalfont_windows.c
index 3a10e1bd6..704efa5d5 100644
--- a/src/detection/terminalfont/terminalfont_windows.c
+++ b/src/detection/terminalfont/terminalfont_windows.c
@@ -6,16 +6,16 @@
 
 #include <windows.h>
 
-static void detectMintty(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectMintty(FFTerminalFontResult* terminalFont)
 {
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontSize = ffStrbufCreate();
 
-    if(!ffParsePropFileConfigValues(instance, "mintty/config", 2, (FFpropquery[]) {
+    if(!ffParsePropFileConfigValues("mintty/config", 2, (FFpropquery[]) {
         {"Font=", &fontName},
         {"FontHeight=", &fontSize}
     }))
-        ffParsePropFileConfigValues(instance, ".minttyrc", 2, (FFpropquery[]) {
+        ffParsePropFileConfigValues(".minttyrc", 2, (FFpropquery[]) {
             {"Font=", &fontName},
             {"FontHeight=", &fontSize}
         });
@@ -27,10 +27,8 @@ static void detectMintty(const FFinstance* instance, FFTerminalFontResult* termi
     ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
 }
 
-static void detectConhost(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectConhost(FFTerminalFontResult* terminalFont)
 {
-    FF_UNUSED(instance);
-
     CONSOLE_FONT_INFOEX cfi = { .cbSize = sizeof(cfi) };
     if(!GetCurrentConsoleFontEx(GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &cfi))
     {
@@ -46,10 +44,8 @@ static void detectConhost(const FFinstance* instance, FFTerminalFontResult* term
     ffFontInitValues(&terminalFont->font, fontName.chars, fontSize);
 }
 
-static void detectConEmu(const FFinstance* instance, FFTerminalFontResult* terminalFont)
+static void detectConEmu(FFTerminalFontResult* terminalFont)
 {
-    FF_UNUSED(instance)
-
     //https://conemu.github.io/en/ConEmuXml.html#search-sequence
     FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
     FF_STRBUF_AUTO_DESTROY fontName = ffStrbufCreate();
@@ -89,12 +85,12 @@ static void detectConEmu(const FFinstance* instance, FFTerminalFontResult* termi
     ffFontInitValues(&terminalFont->font, fontName.chars, fontSize.chars);
 }
 
-void ffDetectTerminalFontPlatform(const FFinstance* instance, const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
+void ffDetectTerminalFontPlatform(const FFTerminalShellResult* terminalShell, FFTerminalFontResult* terminalFont)
 {
     if(ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "mintty") == 0)
-        detectMintty(instance, terminalFont);
+        detectMintty(terminalFont);
     else if(ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "conhost.exe") == 0)
-        detectConhost(instance, terminalFont);
+        detectConhost(terminalFont);
     else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalProcessName, "ConEmuC"))
-        detectConEmu(instance, terminalFont);
+        detectConEmu(terminalFont);
 }
diff --git a/src/detection/terminalshell/terminalshell.h b/src/detection/terminalshell/terminalshell.h
index f506381bb..c727b5fdf 100644
--- a/src/detection/terminalshell/terminalshell.h
+++ b/src/detection/terminalshell/terminalshell.h
@@ -26,6 +26,6 @@ typedef struct FFTerminalShellResult
     FFstrbuf userShellVersion;
 } FFTerminalShellResult;
 
-const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance);
+const FFTerminalShellResult* ffDetectTerminalShell();
 
 #endif
diff --git a/src/detection/terminalshell/terminalshell_linux.c b/src/detection/terminalshell/terminalshell_linux.c
index 9e60aacda..770df3c09 100644
--- a/src/detection/terminalshell/terminalshell_linux.c
+++ b/src/detection/terminalshell/terminalshell_linux.c
@@ -262,9 +262,9 @@ static void getTerminalFromEnv(FFTerminalShellResult* result)
     }
 }
 
-static void getUserShellFromEnv(const FFinstance* instance, FFTerminalShellResult* result)
+static void getUserShellFromEnv(FFTerminalShellResult* result)
 {
-    ffStrbufSet(&result->userShellExe, &instance->state.platform.userShell);
+    ffStrbufSet(&result->userShellExe, &instance.state.platform.userShell);
     if(result->userShellExe.length == 0)
         return;
 
@@ -309,10 +309,8 @@ static void getShellVersion(FFstrbuf* exe, const char* exeName, FFstrbuf* versio
 
 bool fftsGetTerminalVersion(FFstrbuf* processName, FFstrbuf* exe, FFstrbuf* version);
 
-const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance)
+const FFTerminalShellResult* ffDetectTerminalShell()
 {
-    FF_UNUSED(instance);
-
     static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
     static FFTerminalShellResult result;
     static bool init = false;
@@ -350,7 +348,7 @@ const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance)
     getTerminalShell(&result, getppid());
 
     getTerminalFromEnv(&result);
-    getUserShellFromEnv(instance, &result);
+    getUserShellFromEnv(&result);
 
     ffStrbufClear(&result.shellVersion);
     getShellVersion(&result.shellExe, result.shellExeName, &result.shellVersion);
diff --git a/src/detection/terminalshell/terminalshell_windows.c b/src/detection/terminalshell/terminalshell_windows.c
index 35a3af0f7..ac06bed6e 100644
--- a/src/detection/terminalshell/terminalshell_windows.c
+++ b/src/detection/terminalshell/terminalshell_windows.c
@@ -119,7 +119,7 @@ static bool getTerminalInfoByEnumeratingChildProcesses(FFTerminalShellResult* re
 
 bool fftsGetShellVersion(FFstrbuf* exe, const char* exeName, FFstrbuf* version);
 
-static uint32_t getShellInfo(const FFinstance* instance, FFTerminalShellResult* result, uint32_t pid)
+static uint32_t getShellInfo(FFTerminalShellResult* result, uint32_t pid)
 {
     uint32_t ppid;
 
@@ -148,7 +148,7 @@ static uint32_t getShellInfo(const FFinstance* instance, FFTerminalShellResult*
         ffStrbufClear(&result->shellPrettyName);
         ffStrbufClear(&result->shellExe);
         result->shellExeName = NULL;
-        return getShellInfo(instance, result, ppid);
+        return getShellInfo(result, ppid);
     }
 
     ffStrbufClear(&result->shellVersion);
@@ -199,7 +199,7 @@ static uint32_t getShellInfo(const FFinstance* instance, FFTerminalShellResult*
     return ppid;
 }
 
-static uint32_t getTerminalInfo(const FFinstance* instance, FFTerminalShellResult* result, uint32_t pid)
+static uint32_t getTerminalInfo(FFTerminalShellResult* result, uint32_t pid)
 {
     uint32_t ppid;
 
@@ -225,7 +225,7 @@ static uint32_t getTerminalInfo(const FFinstance* instance, FFTerminalShellResul
         ffStrbufClear(&result->terminalPrettyName);
         ffStrbufClear(&result->terminalExe);
         result->terminalExeName = "";
-        return getTerminalInfo(instance, result, ppid);
+        return getTerminalInfo(result, ppid);
     }
 
     if(ffStrbufIgnCaseEqualS(&result->terminalPrettyName, "sihost")           ||
@@ -306,10 +306,8 @@ static void getTerminalFromEnv(FFTerminalShellResult* result)
 
 bool fftsGetTerminalVersion(FFstrbuf* processName, FFstrbuf* exe, FFstrbuf* version);
 
-const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance)
+const FFTerminalShellResult* ffDetectTerminalShell(void)
 {
-    FF_UNUSED(instance);
-
     static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
     static FFTerminalShellResult result;
     static bool init = false;
@@ -342,9 +340,9 @@ const FFTerminalShellResult* ffDetectTerminalShell(const FFinstance* instance)
     if(!getProcessInfo(0, &ppid, NULL, NULL, NULL))
         goto exit;
 
-    ppid = getShellInfo(instance, &result, ppid);
+    ppid = getShellInfo(&result, ppid);
     if(ppid)
-        getTerminalInfo(instance, &result, ppid);
+        getTerminalInfo(&result, ppid);
 
     if(result.terminalProcessName.length == 0)
         getTerminalFromEnv(&result);
diff --git a/src/detection/theme/theme.h b/src/detection/theme/theme.h
index 252b4873f..ec4c596e8 100644
--- a/src/detection/theme/theme.h
+++ b/src/detection/theme/theme.h
@@ -5,6 +5,6 @@
 
 #include "fastfetch.h"
 
-const char* ffDetectTheme(const FFinstance* instance, FFstrbuf* result);
+const char* ffDetectTheme(FFstrbuf* result);
 
 #endif
diff --git a/src/detection/theme/theme_linux.c b/src/detection/theme/theme_linux.c
index d59c6d2de..1a97f49f4 100644
--- a/src/detection/theme/theme_linux.c
+++ b/src/detection/theme/theme_linux.c
@@ -3,17 +3,17 @@
 #include "detection/gtk_qt/gtk_qt.h"
 #include "detection/displayserver/displayserver.h"
 
-const char* ffDetectTheme(const FFinstance* instance, FFstrbuf* result)
+const char* ffDetectTheme(FFstrbuf* result)
 {
-    const FFDisplayServerResult* wmde = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wmde = ffConnectDisplayServer();
 
     if(ffStrbufIgnCaseCompS(&wmde->wmProtocolName, FF_WM_PROTOCOL_TTY) == 0)
         return "Theme isn't supported in TTY";
 
-    const FFQtResult* plasma = ffDetectQt(instance);
-    const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->theme;
-    const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->theme;
-    const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->theme;
+    const FFQtResult* plasma = ffDetectQt();
+    const FFstrbuf* gtk2 = &ffDetectGTK2()->theme;
+    const FFstrbuf* gtk3 = &ffDetectGTK3()->theme;
+    const FFstrbuf* gtk4 = &ffDetectGTK4()->theme;
 
     if(plasma->widgetStyle.length == 0 && plasma->colorScheme.length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
         return "No themes found";
diff --git a/src/detection/theme/theme_nosupport.c b/src/detection/theme/theme_nosupport.c
index d0e9fd073..c946833e6 100644
--- a/src/detection/theme/theme_nosupport.c
+++ b/src/detection/theme/theme_nosupport.c
@@ -1,6 +1,6 @@
 #include "theme.h"
 
-const char* ffDetectTheme(FF_MAYBE_UNUSED const FFinstance* instance, FF_MAYBE_UNUSED FFstrbuf* result)
+const char* ffDetectTheme(FF_MAYBE_UNUSED FFstrbuf* result)
 {
     return "Not supported on this platform";
 }
diff --git a/src/detection/vulkan/vulkan.c b/src/detection/vulkan/vulkan.c
index 9ab2319dd..88d687c8e 100644
--- a/src/detection/vulkan/vulkan.c
+++ b/src/detection/vulkan/vulkan.c
@@ -38,9 +38,9 @@ static void applyDriverName(VkPhysicalDeviceDriverProperties* properties, FFstrb
     ffStrbufAppendC(result, ']');
 }
 
-static const char* detectVulkan(const FFinstance* instance, FFVulkanResult* result)
+static const char* detectVulkan(FFVulkanResult* result)
 {
-    FF_LIBRARY_LOAD(vulkan, &instance->config.libVulkan, "dlopen libvulkan"FF_LIBRARY_EXTENSION " failed",
+    FF_LIBRARY_LOAD(vulkan, &instance.config.libVulkan, "dlopen libvulkan"FF_LIBRARY_EXTENSION " failed",
         #ifdef __APPLE__
             "libMoltenVK"FF_LIBRARY_EXTENSION, -1
         #elif defined(_WIN32)
@@ -119,7 +119,7 @@ static const char* detectVulkan(const FFinstance* instance, FFVulkanResult* resu
 
     PFN_vkGetPhysicalDeviceMemoryProperties ffvkGetPhysicalDeviceMemoryProperties = NULL;
     PFN_vkGetPhysicalDeviceMemoryProperties2 ffvkGetPhysicalDeviceMemoryProperties2 =
-        instance->config.allowSlowOperations ? (PFN_vkGetPhysicalDeviceMemoryProperties2) ffvkGetInstanceProcAddr(vkInstance, "vkGetPhysicalDeviceMemoryProperties2") : NULL; // 1.1
+        instance.config.allowSlowOperations ? (PFN_vkGetPhysicalDeviceMemoryProperties2) ffvkGetInstanceProcAddr(vkInstance, "vkGetPhysicalDeviceMemoryProperties2") : NULL; // 1.1
     if(!ffvkGetPhysicalDeviceMemoryProperties2)
         ffvkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) ffvkGetInstanceProcAddr(vkInstance, "vkGetPhysicalDeviceMemoryProperties");
 
@@ -245,7 +245,7 @@ static const char* detectVulkan(const FFinstance* instance, FFVulkanResult* resu
 
 #endif
 
-FFVulkanResult* ffDetectVulkan(const FFinstance* instance)
+FFVulkanResult* ffDetectVulkan(void)
 {
     static FFVulkanResult result;
     static FFThreadMutex mutex = FF_THREAD_MUTEX_INITIALIZER;
@@ -265,9 +265,8 @@ FFVulkanResult* ffDetectVulkan(const FFinstance* instance)
     ffListInit(&result.gpus, sizeof(FFGPUResult));
 
     #ifdef FF_HAVE_VULKAN
-        result.error = detectVulkan(instance, &result);
+        result.error = detectVulkan(&result);
     #else
-        FF_UNUSED(instance);
         result.error = "fastfetch was compiled without vulkan support";
     #endif
 
diff --git a/src/detection/vulkan/vulkan.h b/src/detection/vulkan/vulkan.h
index 1da50b969..560fcdc53 100644
--- a/src/detection/vulkan/vulkan.h
+++ b/src/detection/vulkan/vulkan.h
@@ -14,6 +14,6 @@ typedef struct FFVulkanResult
     const char* error;
 } FFVulkanResult;
 
-FFVulkanResult* ffDetectVulkan(const FFinstance* instance);
+FFVulkanResult* ffDetectVulkan();
 
 #endif
diff --git a/src/detection/wallpaper/wallpaper.h b/src/detection/wallpaper/wallpaper.h
index 72208eb5b..f75ad77dd 100644
--- a/src/detection/wallpaper/wallpaper.h
+++ b/src/detection/wallpaper/wallpaper.h
@@ -5,6 +5,6 @@
 
 #include "fastfetch.h"
 
-const char* ffDetectWallpaper(const FFinstance* instance, FFstrbuf* result);
+const char* ffDetectWallpaper(FFstrbuf* result);
 
 #endif
diff --git a/src/detection/wallpaper/wallpaper_apple.c b/src/detection/wallpaper/wallpaper_apple.c
index 7d2fb84dc..4ec131417 100644
--- a/src/detection/wallpaper/wallpaper_apple.c
+++ b/src/detection/wallpaper/wallpaper_apple.c
@@ -2,15 +2,15 @@
 #include "common/settings.h"
 #include "util/apple/osascript.h"
 
-const char* ffDetectWallpaper(FF_MAYBE_UNUSED const FFinstance* instance, FFstrbuf* result)
+const char* ffDetectWallpaper(FFstrbuf* result)
 {
     // https://stackoverflow.com/questions/301215/getting-desktop-background-on-mac
 
     #ifdef FF_HAVE_SQLITE3
 
-    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateCopy(&instance->state.platform.homeDir);
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateCopy(&instance.state.platform.homeDir);
     ffStrbufAppendS(&path, "Library/Application Support/Dock/desktoppicture.db");
-    if (ffSettingsGetSQLite3String(instance, path.chars,
+    if (ffSettingsGetSQLite3String(path.chars,
         "SELECT value\n"
         "FROM preferences\n"
         "JOIN data ON preferences.data_id=data.ROWID\n"
diff --git a/src/detection/wallpaper/wallpaper_linux.c b/src/detection/wallpaper/wallpaper_linux.c
index 7ae5b480d..d2aa65b6c 100644
--- a/src/detection/wallpaper/wallpaper_linux.c
+++ b/src/detection/wallpaper/wallpaper_linux.c
@@ -2,15 +2,15 @@
 #include "common/settings.h"
 #include "detection/gtk_qt/gtk_qt.h"
 
-const char* ffDetectWallpaper(const FFinstance* instance, FFstrbuf* result)
+const char* ffDetectWallpaper(FFstrbuf* result)
 {
     const FFstrbuf* wallpaper = NULL;
-    const FFGTKResult* gtk = ffDetectGTK4(instance);
+    const FFGTKResult* gtk = ffDetectGTK4();
     if (gtk->wallpaper.length)
         wallpaper = &gtk->wallpaper;
     else
     {
-        const FFQtResult* qt = ffDetectQt(instance);
+        const FFQtResult* qt = ffDetectQt();
         if (qt->wallpaper.length)
             wallpaper = &qt->wallpaper;
     }
diff --git a/src/detection/wallpaper/wallpaper_nosupport.c b/src/detection/wallpaper/wallpaper_nosupport.c
index 92278511d..787b106af 100644
--- a/src/detection/wallpaper/wallpaper_nosupport.c
+++ b/src/detection/wallpaper/wallpaper_nosupport.c
@@ -1,6 +1,6 @@
 #include "wallpaper.h"
 
-const char* ffDetectWallpaper(FF_MAYBE_UNUSED const FFinstance* instance, FF_MAYBE_UNUSED FFstrbuf* result)
+const char* ffDetectWallpaper(FF_MAYBE_UNUSED FFstrbuf* result)
 {
     return "Not supported on this platform";
 }
diff --git a/src/detection/wallpaper/wallpaper_windows.c b/src/detection/wallpaper/wallpaper_windows.c
index aa8b696ad..7a099cb40 100644
--- a/src/detection/wallpaper/wallpaper_windows.c
+++ b/src/detection/wallpaper/wallpaper_windows.c
@@ -1,7 +1,7 @@
 #include "wallpaper.h"
 #include "util/windows/registry.h"
 
-const char* ffDetectWallpaper(FF_MAYBE_UNUSED const FFinstance* instance, FFstrbuf* result)
+const char* ffDetectWallpaper(FFstrbuf* result)
 {
     FF_HKEY_AUTO_DESTROY hKey = NULL;
     if(!ffRegOpenKeyForRead(HKEY_CURRENT_USER, L"Control Panel\\Desktop", &hKey, NULL))
diff --git a/src/detection/wifi/wifi.h b/src/detection/wifi/wifi.h
index fae5c46ce..d3257a9ef 100644
--- a/src/detection/wifi/wifi.h
+++ b/src/detection/wifi/wifi.h
@@ -29,6 +29,6 @@ typedef struct FFWifiResult
     struct FFWifiConnection conn;
 } FFWifiResult;
 
-const char* ffDetectWifi(const FFinstance* instance, FFlist* result /*list of FFWifiItem*/);
+const char* ffDetectWifi(FFlist* result /*list of FFWifiItem*/);
 
 #endif
diff --git a/src/detection/wifi/wifi_android.c b/src/detection/wifi/wifi_android.c
index 39ae35541..b04796d6e 100644
--- a/src/detection/wifi/wifi_android.c
+++ b/src/detection/wifi/wifi_android.c
@@ -6,7 +6,7 @@
 #define FF_TERMUX_API_PATH FASTFETCH_TARGET_DIR_ROOT "/libexec/termux-api"
 #define FF_TERMUX_API_PARAM "WifiConnectionInfo"
 
-const char* ffDetectWifi(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* result)
+const char* ffDetectWifi(FFlist* result)
 {
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
 
diff --git a/src/detection/wifi/wifi_apple.m b/src/detection/wifi/wifi_apple.m
index a83f79485..c6b572012 100644
--- a/src/detection/wifi/wifi_apple.m
+++ b/src/detection/wifi/wifi_apple.m
@@ -2,10 +2,8 @@
 
 #import <CoreWLAN/CoreWLAN.h>
 
-const char* ffDetectWifi(const FFinstance* instance, FFlist* result)
+const char* ffDetectWifi(FFlist* result)
 {
-    FF_UNUSED(instance);
-
     NSArray<CWInterface*>* interfaces = CWWiFiClient.sharedWiFiClient.interfaces;
     if(!interfaces)
         return "CWWiFiClient.sharedWiFiClient.interfaces is nil";
diff --git a/src/detection/wifi/wifi_bsd.c b/src/detection/wifi/wifi_bsd.c
index 31ba488a2..663c6a4be 100644
--- a/src/detection/wifi/wifi_bsd.c
+++ b/src/detection/wifi/wifi_bsd.c
@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <string.h>
 
-const char* ffDetectWifi(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* result)
+const char* ffDetectWifi(FFlist* result)
 {
     struct if_nameindex* infs = if_nameindex();
     if(!infs)
diff --git a/src/detection/wifi/wifi_linux.c b/src/detection/wifi/wifi_linux.c
index 871b9be50..23534f3b9 100644
--- a/src/detection/wifi/wifi_linux.c
+++ b/src/detection/wifi/wifi_linux.c
@@ -20,9 +20,9 @@
     #define NM_802_11_AP_SEC_KEY_MGMT_OWE_TM 0x00001000
 #endif
 
-static const char* detectWifiWithLibnm(const FFinstance* instance, FFlist* result)
+static const char* detectWifiWithLibnm(FFlist* result)
 {
-    FF_LIBRARY_LOAD(nm, &instance->config.libnm, "dlopen libnm failed", "libnm" FF_LIBRARY_EXTENSION, 0);
+    FF_LIBRARY_LOAD(nm, &instance.config.libnm, "dlopen libnm failed", "libnm" FF_LIBRARY_EXTENSION, 0);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(nm, nm_client_new);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(nm, nm_client_get_devices);
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(nm, nm_device_get_iface);
@@ -143,7 +143,7 @@ static const char* detectWifiWithLibnm(const FFinstance* instance, FFlist* resul
         item->conn.signalQuality = ffnm_access_point_get_strength(ap);
         item->conn.rxRate = ffnm_access_point_get_max_bitrate(ap);
 
-        if(instance->config.allowSlowOperations)
+        if(instance.config.allowSlowOperations)
         {
             FF_STRBUF_AUTO_DESTROY output = ffStrbufCreate();
             if(!ffProcessAppendStdOut(&output, (char* const[]){
@@ -213,7 +213,7 @@ static const char* detectWifiWithLibnm(const FFinstance* instance, FFlist* resul
 #include <unistd.h>
 #include <linux/wireless.h> //TODO: Don't depend on kernel headers
 
-static const char* detectWifiWithIoctls(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* result)
+static const char* detectWifiWithIoctls(FFlist* result)
 {
     struct if_nameindex* infs = if_nameindex();
     if(!infs)
@@ -315,15 +315,15 @@ static const char* detectWifiWithIoctls(FF_MAYBE_UNUSED const FFinstance* instan
 
 #endif
 
-const char* ffDetectWifi(const FFinstance* instance, FFlist* result)
+const char* ffDetectWifi(FFlist* result)
 {
     #ifdef FF_HAVE_LIBNM
-    if(!detectWifiWithLibnm(instance, result))
+    if(!detectWifiWithLibnm(result))
         return NULL;
     #endif
 
     #ifdef FF_DETECT_WIFI_WITH_IOCTLS
-        detectWifiWithIoctls(instance, result);
+        detectWifiWithIoctls(result);
     #endif
 
     return "linux/wireless.h not found during compilation";
diff --git a/src/detection/wifi/wifi_windows.c b/src/detection/wifi/wifi_windows.c
index a0bd0af4b..3b7ac5a1c 100644
--- a/src/detection/wifi/wifi_windows.c
+++ b/src/detection/wifi/wifi_windows.c
@@ -41,7 +41,7 @@ static void convertIfStateToString(WLAN_INTERFACE_STATE state, FFstrbuf* result)
     }
 }
 
-const char* ffDetectWifi(FF_MAYBE_UNUSED const FFinstance* instance, FFlist* result)
+const char* ffDetectWifi(FFlist* result)
 {
     FF_LIBRARY_LOAD(wlanapi, NULL, "dlopen wlanapi"FF_LIBRARY_EXTENSION" failed", "wlanapi"FF_LIBRARY_EXTENSION, 1)
     FF_LIBRARY_LOAD_SYMBOL_MESSAGE(wlanapi, WlanOpenHandle)
diff --git a/src/detection/wmtheme/wmtheme.h b/src/detection/wmtheme/wmtheme.h
index 33a15dd0f..baf3e1ede 100644
--- a/src/detection/wmtheme/wmtheme.h
+++ b/src/detection/wmtheme/wmtheme.h
@@ -5,6 +5,6 @@
 
 #include "fastfetch.h"
 
-bool ffDetectWmTheme(FFinstance* instance, FFstrbuf* themeOrError);
+bool ffDetectWmTheme(FFstrbuf* themeOrError);
 
 #endif
diff --git a/src/detection/wmtheme/wmtheme_apple.m b/src/detection/wmtheme/wmtheme_apple.m
index 817a2cd65..08810b6cc 100644
--- a/src/detection/wmtheme/wmtheme_apple.m
+++ b/src/detection/wmtheme/wmtheme_apple.m
@@ -3,10 +3,10 @@
 
 #import <Foundation/Foundation.h>
 
-bool ffDetectWmTheme(FF_MAYBE_UNUSED FFinstance* instance, FFstrbuf* themeOrError)
+bool ffDetectWmTheme(FFstrbuf* themeOrError)
 {
     NSError* error;
-    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/.GlobalPreferences.plist", instance->state.platform.homeDir.chars];
+    NSString* fileName = [NSString stringWithFormat:@"file://%s/Library/Preferences/.GlobalPreferences.plist", instance.state.platform.homeDir.chars];
     NSDictionary* dict = [NSDictionary dictionaryWithContentsOfURL:[NSURL URLWithString:fileName]
                                        error:&error];
     if(error)
diff --git a/src/detection/wmtheme/wmtheme_linux.c b/src/detection/wmtheme/wmtheme_linux.c
index 055dc91ca..ba1e172a1 100644
--- a/src/detection/wmtheme/wmtheme_linux.c
+++ b/src/detection/wmtheme/wmtheme_linux.c
@@ -6,9 +6,9 @@
 #include "detection/displayserver/displayserver.h"
 #include "util/stringUtils.h"
 
-static bool detectWMThemeFromConfigFile(FFinstance* instance, const char* configFile, const char* themeRegex, const char* defaultValue, FFstrbuf* themeOrError)
+static bool detectWMThemeFromConfigFile(const char* configFile, const char* themeRegex, const char* defaultValue, FFstrbuf* themeOrError)
 {
-    if(!ffParsePropFileConfig(instance, configFile, themeRegex, themeOrError))
+    if(!ffParsePropFileConfig(configFile, themeRegex, themeOrError))
     {
         ffStrbufAppendF(themeOrError, "Config file %s doesn't exist", configFile);
         return false;
@@ -40,9 +40,9 @@ static bool detectWMThemeFromConfigFile(FFinstance* instance, const char* config
     return true;
 }
 
-static bool detectWMThemeFromSettings(FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFstrbuf* themeOrError)
+static bool detectWMThemeFromSettings(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFstrbuf* themeOrError)
 {
-    const char* theme = ffSettingsGet(instance, dconfKey, gsettingsSchemaName, gsettingsPath, gsettingsKey, FF_VARIANT_TYPE_STRING).strValue;
+    const char* theme = ffSettingsGet(dconfKey, gsettingsSchemaName, gsettingsPath, gsettingsKey, FF_VARIANT_TYPE_STRING).strValue;
 
     if(!ffStrSet(theme))
     {
@@ -54,17 +54,17 @@ static bool detectWMThemeFromSettings(FFinstance* instance, const char* dconfKey
     return true;
 }
 
-static bool detectGTKThemeAsWMTheme(FFinstance* instance, FFstrbuf* themeOrError)
+static bool detectGTKThemeAsWMTheme(FFstrbuf* themeOrError)
 {
-    const FFGTKResult* gtk = ffDetectGTK4(instance);
+    const FFGTKResult* gtk = ffDetectGTK4();
     if(gtk->theme.length > 0)
         goto ok;
 
-    gtk = ffDetectGTK3(instance);
+    gtk = ffDetectGTK3();
     if(gtk->theme.length > 0)
         goto ok;
 
-    gtk = ffDetectGTK2(instance);
+    gtk = ffDetectGTK2();
     if(gtk->theme.length > 0)
         goto ok;
 
@@ -76,22 +76,22 @@ ok:
     return true;
 }
 
-static bool detectMutter(FFinstance* instance, FFstrbuf* themeOrError)
+static bool detectMutter(FFstrbuf* themeOrError)
 {
-    const char* theme = ffSettingsGet(instance, "/org/gnome/shell/extensions/user-theme/name", "org.gnome.shell.extensions.user-theme", NULL, "name", FF_VARIANT_TYPE_STRING).strValue;
+    const char* theme = ffSettingsGet("/org/gnome/shell/extensions/user-theme/name", "org.gnome.shell.extensions.user-theme", NULL, "name", FF_VARIANT_TYPE_STRING).strValue;
     if(ffStrSet(theme))
     {
         ffStrbufAppendS(themeOrError, theme);
         return true;
     }
 
-    return detectGTKThemeAsWMTheme(instance, themeOrError);
+    return detectGTKThemeAsWMTheme(themeOrError);
 }
 
-static bool detectMuffin(FFinstance* instance, FFstrbuf* themeOrError)
+static bool detectMuffin(FFstrbuf* themeOrError)
 {
-    const char* name = ffSettingsGet(instance, "/org/cinnamon/theme/name", "org.cinnamon.theme", NULL, "name", FF_VARIANT_TYPE_STRING).strValue;
-    const char* theme = ffSettingsGet(instance, "/org/cinnamon/desktop/wm/preferences/theme", "org.cinnamon.desktop.wm.preferences", NULL, "theme", FF_VARIANT_TYPE_STRING).strValue;
+    const char* name = ffSettingsGet("/org/cinnamon/theme/name", "org.cinnamon.theme", NULL, "name", FF_VARIANT_TYPE_STRING).strValue;
+    const char* theme = ffSettingsGet("/org/cinnamon/desktop/wm/preferences/theme", "org.cinnamon.desktop.wm.preferences", NULL, "theme", FF_VARIANT_TYPE_STRING).strValue;
 
     if(name == NULL && theme == NULL)
     {
@@ -115,9 +115,9 @@ static bool detectMuffin(FFinstance* instance, FFstrbuf* themeOrError)
     return true;
 }
 
-static bool detectXFWM4(FFinstance* instance, FFstrbuf* themeOrError)
+static bool detectXFWM4(FFstrbuf* themeOrError)
 {
-    const char* theme = ffSettingsGetXFConf(instance, "xfwm4", "/general/theme", FF_VARIANT_TYPE_STRING).strValue;
+    const char* theme = ffSettingsGetXFConf("xfwm4", "/general/theme", FF_VARIANT_TYPE_STRING).strValue;
 
     if(theme == NULL)
     {
@@ -129,10 +129,10 @@ static bool detectXFWM4(FFinstance* instance, FFstrbuf* themeOrError)
     return true;
 }
 
-static bool detectOpenbox(FFinstance* instance, const FFstrbuf* dePrettyName, FFstrbuf* themeOrError)
+static bool detectOpenbox(const FFstrbuf* dePrettyName, FFstrbuf* themeOrError)
 {
     FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateA(64);
-    ffStrbufAppend(&absolutePath, &instance->state.platform.homeDir);
+    ffStrbufAppend(&absolutePath, &instance.state.platform.homeDir);
 
     //TODO: use config dirs
     if(ffStrbufIgnCaseCompS(dePrettyName, "LXQT") == 0)
@@ -188,9 +188,9 @@ static bool detectOpenbox(FFinstance* instance, const FFstrbuf* dePrettyName, FF
     return true;
 }
 
-bool ffDetectWmTheme(FFinstance* instance, FFstrbuf* themeOrError)
+bool ffDetectWmTheme(FFstrbuf* themeOrError)
 {
-    const FFDisplayServerResult* wm = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* wm = ffConnectDisplayServer();
 
     if(wm->wmPrettyName.length == 0)
     {
@@ -199,10 +199,10 @@ bool ffDetectWmTheme(FFinstance* instance, FFstrbuf* themeOrError)
     }
 
     if(ffStrbufIgnCaseCompS(&wm->wmPrettyName, FF_WM_PRETTY_KWIN) == 0)
-        return detectWMThemeFromConfigFile(instance, "kwinrc", "theme =", "Breeze", themeOrError);
+        return detectWMThemeFromConfigFile("kwinrc", "theme =", "Breeze", themeOrError);
 
     if(ffStrbufIgnCaseCompS(&wm->wmPrettyName, FF_WM_PRETTY_XFWM4) == 0)
-        return detectXFWM4(instance, themeOrError);
+        return detectXFWM4(themeOrError);
 
     if(ffStrbufIgnCaseCompS(&wm->wmPrettyName, FF_WM_PRETTY_MUTTER) == 0)
     {
@@ -210,19 +210,19 @@ bool ffDetectWmTheme(FFinstance* instance, FFstrbuf* themeOrError)
             ffStrbufIgnCaseCompS(&wm->dePrettyName, FF_DE_PRETTY_GNOME) == 0 ||
             ffStrbufIgnCaseEqualS(&wm->dePrettyName, FF_DE_PRETTY_GNOME_CLASSIC)
         )
-            return detectMutter(instance, themeOrError);
+            return detectMutter(themeOrError);
         else
-            return detectGTKThemeAsWMTheme(instance, themeOrError);
+            return detectGTKThemeAsWMTheme(themeOrError);
     }
 
     if(ffStrbufIgnCaseCompS(&wm->wmPrettyName, FF_WM_PRETTY_MUFFIN) == 0)
-        return detectMuffin(instance, themeOrError);
+        return detectMuffin(themeOrError);
 
     if(ffStrbufIgnCaseCompS(&wm->wmPrettyName, FF_WM_PRETTY_MARCO) == 0)
-        return detectWMThemeFromSettings(instance, "/org/mate/Marco/general/theme", "org.mate.Marco.general", NULL, "theme", themeOrError);
+        return detectWMThemeFromSettings("/org/mate/Marco/general/theme", "org.mate.Marco.general", NULL, "theme", themeOrError);
 
     if(ffStrbufIgnCaseCompS(&wm->wmPrettyName, FF_WM_PRETTY_OPENBOX) == 0)
-        return detectOpenbox(instance, &wm->dePrettyName, themeOrError);
+        return detectOpenbox(&wm->dePrettyName, themeOrError);
 
     ffStrbufAppendS(themeOrError, "Unknown WM: ");
     ffStrbufAppend(themeOrError, &wm->wmPrettyName);
diff --git a/src/detection/wmtheme/wmtheme_nosupport.c b/src/detection/wmtheme/wmtheme_nosupport.c
index 1f1dca61c..2b899e98c 100644
--- a/src/detection/wmtheme/wmtheme_nosupport.c
+++ b/src/detection/wmtheme/wmtheme_nosupport.c
@@ -1,9 +1,8 @@
 #include "fastfetch.h"
 #include "wmtheme.h"
 
-bool ffDetectWmTheme(FFinstance* instance, FFstrbuf* themeOrError)
+bool ffDetectWmTheme(FFstrbuf* themeOrError)
 {
-    FF_UNUSED(instance);
     ffStrbufAppendS(themeOrError, "Not supported on this platform");
     return false;
 }
diff --git a/src/detection/wmtheme/wmtheme_windows.c b/src/detection/wmtheme/wmtheme_windows.c
index 67ea08f83..5e5cc26e1 100644
--- a/src/detection/wmtheme/wmtheme_windows.c
+++ b/src/detection/wmtheme/wmtheme_windows.c
@@ -60,7 +60,7 @@ const char* colorHexToString(DWORD hex)
     }
 }
 
-bool ffDetectWmTheme(FF_MAYBE_UNUSED FFinstance* instance, FFstrbuf* themeOrError)
+bool ffDetectWmTheme(FFstrbuf* themeOrError)
 {
     {
         FF_HKEY_AUTO_DESTROY hKey = NULL;
diff --git a/src/fastfetch.c b/src/fastfetch.c
index 8de3e4f14..7fc96cdcb 100644
--- a/src/fastfetch.c
+++ b/src/fastfetch.c
@@ -485,27 +485,27 @@ static inline void printCommandHelp(const char* command)
         fprintf(stderr, "No specific help for command %s provided\n", command);
 }
 
-static void listAvailablePresets(FFinstance* instance)
+static void listAvailablePresets(void)
 {
-    FF_LIST_FOR_EACH(FFstrbuf, path, instance->state.platform.dataDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, path, instance.state.platform.dataDirs)
     {
         ffStrbufAppendS(path, "fastfetch/presets/");
         ffListFilesRecursively(path->chars);
     }
 }
 
-static void listAvailableLogos(FFinstance* instance)
+static void listAvailableLogos(void)
 {
-    FF_LIST_FOR_EACH(FFstrbuf, path, instance->state.platform.dataDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, path, instance.state.platform.dataDirs)
     {
         ffStrbufAppendS(path, "fastfetch/logos/");
         ffListFilesRecursively(path->chars);
     }
 }
 
-static void listConfigPaths(FFinstance* instance)
+static void listConfigPaths(void)
 {
-    FF_LIST_FOR_EACH(FFstrbuf, folder, instance->state.platform.configDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, folder, instance.state.platform.configDirs)
     {
         bool exists = false;
         ffStrbufAppendS(folder, "fastfetch/config.jsonc");
@@ -520,31 +520,31 @@ static void listConfigPaths(FFinstance* instance)
     }
 }
 
-static void listDataPaths(FFinstance* instance)
+static void listDataPaths(void)
 {
-    FF_LIST_FOR_EACH(FFstrbuf, folder, instance->state.platform.dataDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, folder, instance.state.platform.dataDirs)
     {
         ffStrbufAppendS(folder, "fastfetch/");
         puts(folder->chars);
     }
 }
 
-static void parseOption(FFinstance* instance, FFdata* data, const char* key, const char* value);
+static void parseOption(FFdata* data, const char* key, const char* value);
 
-static bool parseJsoncFile(FFinstance* instance, const char* path)
+static bool parseJsoncFile(const char* path)
 {
     yyjson_read_err error;
     yyjson_doc* doc = yyjson_read_file(path, YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS | YYJSON_READ_ALLOW_INF_AND_NAN, NULL, &error);
     if (doc)
     {
-        instance->state.configDoc = doc;
+        instance.state.configDoc = doc;
         const char* error = NULL;
 
         if (
-            (error = ffParseLogoJsonConfig(instance)) ||
-            (error = ffParseGeneralJsonConfig(instance)) ||
-            (error = ffParseDisplayJsonConfig(instance)) ||
-            (error = ffParseLibraryJsonConfig(instance)) ||
+            (error = ffParseLogoJsonConfig()) ||
+            (error = ffParseGeneralJsonConfig()) ||
+            (error = ffParseDisplayJsonConfig()) ||
+            (error = ffParseLibraryJsonConfig()) ||
             false
         ) {
             fputs(error, stderr);
@@ -560,7 +560,7 @@ static bool parseJsoncFile(FFinstance* instance, const char* path)
     return false;
 }
 
-static bool parseConfigFile(FFinstance* instance, FFdata* data, const char* path)
+static bool parseConfigFile(FFdata* data, const char* path)
 {
     FILE* file = fopen(path, "r");
     if(file == NULL)
@@ -593,7 +593,7 @@ static bool parseConfigFile(FFinstance* instance, FFdata* data, const char* path
         //If the line has no white space, it is only a key
         if(valueStart == NULL)
         {
-            parseOption(instance, data, lineStart, NULL);
+            parseOption(data, lineStart, NULL);
             continue;
         }
 
@@ -613,7 +613,7 @@ static bool parseConfigFile(FFinstance* instance, FFdata* data, const char* path
             --lineEnd;
         }
 
-        parseOption(instance, data, lineStart, valueStart);
+        parseOption(data, lineStart, valueStart);
     }
 
     if(line != NULL)
@@ -623,9 +623,9 @@ static bool parseConfigFile(FFinstance* instance, FFdata* data, const char* path
     return true;
 }
 
-static void generateConfigFile(FFinstance* instance, bool force)
+static void generateConfigFile(bool force)
 {
-    FFstrbuf* filename = (FFstrbuf*) ffListGet(&instance->state.platform.configDirs, 0);
+    FFstrbuf* filename = (FFstrbuf*) ffListGet(&instance.state.platform.configDirs, 0);
     // Paths generated in `init.c/initConfigDirs` end with `/`
     ffStrbufAppendS(filename, "fastfetch/config.conf");
 
@@ -642,7 +642,7 @@ static void generateConfigFile(FFinstance* instance, bool force)
     }
 }
 
-static void optionParseConfigFile(FFinstance* instance, FFdata* data, const char* key, const char* value)
+static void optionParseConfigFile(FFdata* data, const char* key, const char* value)
 {
     if(value == NULL)
     {
@@ -652,21 +652,21 @@ static void optionParseConfigFile(FFinstance* instance, FFdata* data, const char
 
     //Try to load as an absolute path
 
-    if(parseConfigFile(instance, data, value))
+    if(parseConfigFile(data, value))
         return;
 
     //Try to load as a relative path
 
     FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateA(128);
 
-    FF_LIST_FOR_EACH(FFstrbuf, path, instance->state.platform.dataDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, path, instance.state.platform.dataDirs)
     {
         //We need to copy it, because if a config file loads a config file, the value of path must be unchanged
         ffStrbufSet(&absolutePath, path);
         ffStrbufAppendS(&absolutePath, "fastfetch/presets/");
         ffStrbufAppendS(&absolutePath, value);
 
-        bool success = parseConfigFile(instance, data, absolutePath.chars);
+        bool success = parseConfigFile(data, absolutePath.chars);
 
         if(success)
             return;
@@ -688,7 +688,7 @@ static inline void optionCheckString(const char* key, const char* value, FFstrbu
     ffStrbufEnsureFree(buffer, 63); //This is not needed, as ffStrbufSetS will resize capacity if needed, but giving a higher start should improve performance
 }
 
-static void parseOption(FFinstance* instance, FFdata* data, const char* key, const char* value)
+static void parseOption(FFdata* data, const char* key, const char* value)
 {
     ///////////////////////
     //Informative options//
@@ -759,7 +759,7 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         }
         else if(ffStrEqualsIgnCase(subkey, "-logos"))
         {
-            ffLogoBuiltinPrint(instance);
+            ffLogoBuiltinPrint();
             exit(0);
         }
         else
@@ -775,17 +775,17 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         }
         else if(ffStrEqualsIgnCase(subkey, "-presets"))
         {
-            listAvailablePresets(instance);
+            listAvailablePresets();
             exit(0);
         }
         else if(ffStrEqualsIgnCase(subkey, "-config-paths"))
         {
-            listConfigPaths(instance);
+            listConfigPaths();
             exit(0);
         }
         else if(ffStrEqualsIgnCase(subkey, "-data-paths"))
         {
-            listDataPaths(instance);
+            listDataPaths();
             exit(0);
         }
         else if(ffStrEqualsIgnCase(subkey, "-features"))
@@ -798,7 +798,7 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
             puts("Builtin logos:");
             ffLogoBuiltinList();
             puts("\nCustom logos:");
-            listAvailableLogos(instance);
+            listAvailableLogos();
             exit(0);
         }
         else if(ffStrEqualsIgnCase(subkey, "-logos-autocompletion"))
@@ -815,75 +815,75 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
     ///////////////////
 
     else if(ffStrEqualsIgnCase(key, "-r") || ffStrEqualsIgnCase(key, "--recache"))
-        instance->config.recache = ffOptionParseBoolean(value);
+        instance.config.recache = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "--load-config"))
-        optionParseConfigFile(instance, data, key, value);
+        optionParseConfigFile(data, key, value);
     else if(ffStrEqualsIgnCase(key, "--gen-config"))
-        generateConfigFile(instance, false);
+        generateConfigFile(false);
     else if(ffStrEqualsIgnCase(key, "--gen-config-force"))
-        generateConfigFile(instance, true);
+        generateConfigFile(true);
     else if(ffStrEqualsIgnCase(key, "--thread") || ffStrEqualsIgnCase(key, "--multithreading"))
-        instance->config.multithreading = ffOptionParseBoolean(value);
+        instance.config.multithreading = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "--stat"))
     {
-        if((instance->config.stat = ffOptionParseBoolean(value)))
-            instance->config.showErrors = true;
+        if((instance.config.stat = ffOptionParseBoolean(value)))
+            instance.config.showErrors = true;
     }
     else if(ffStrEqualsIgnCase(key, "--allow-slow-operations"))
-        instance->config.allowSlowOperations = ffOptionParseBoolean(value);
+        instance.config.allowSlowOperations = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "--escape-bedrock"))
-        instance->config.escapeBedrock = ffOptionParseBoolean(value);
+        instance.config.escapeBedrock = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "--pipe"))
-        instance->config.pipe = ffOptionParseBoolean(value);
+        instance.config.pipe = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "--load-user-config"))
         data->loadUserConfig = ffOptionParseBoolean(value);
 
     #if defined(__linux__) || defined(__FreeBSD__)
     else if(ffStrEqualsIgnCase(key, "--player-name"))
-        ffOptionParseString(key, value, &instance->config.playerName);
+        ffOptionParseString(key, value, &instance.config.playerName);
     else if (ffStrEqualsIgnCase(key, "--os-file"))
-        ffOptionParseString(key, value, &instance->config.osFile);
+        ffOptionParseString(key, value, &instance.config.osFile);
     #endif
 
     ////////////////
     //Logo options//
     ////////////////
 
-    else if(ffParseLogoCommandOptions(&instance->config.logo, key, value)) {}
+    else if(ffParseLogoCommandOptions(&instance.config.logo, key, value)) {}
 
     ///////////////////
     //Display options//
     ///////////////////
 
     else if(ffStrEqualsIgnCase(key, "--show-errors"))
-        instance->config.showErrors = ffOptionParseBoolean(value);
+        instance.config.showErrors = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "--disable-linewrap"))
-        instance->config.disableLinewrap = ffOptionParseBoolean(value);
+        instance.config.disableLinewrap = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "--hide-cursor"))
-        instance->config.hideCursor = ffOptionParseBoolean(value);
+        instance.config.hideCursor = ffOptionParseBoolean(value);
     else if(ffStrEqualsIgnCase(key, "-s") || ffStrEqualsIgnCase(key, "--structure"))
         ffOptionParseString(key, value, &data->structure);
     else if(ffStrEqualsIgnCase(key, "--separator"))
-        ffOptionParseString(key, value, &instance->config.keyValueSeparator);
+        ffOptionParseString(key, value, &instance.config.keyValueSeparator);
     else if(ffStrEqualsIgnCase(key, "--color-keys"))
     {
-        optionCheckString(key, value, &instance->config.colorKeys);
-        ffOptionParseColor(value, &instance->config.colorKeys);
+        optionCheckString(key, value, &instance.config.colorKeys);
+        ffOptionParseColor(value, &instance.config.colorKeys);
     }
     else if(ffStrEqualsIgnCase(key, "--color-title"))
     {
-        optionCheckString(key, value, &instance->config.colorTitle);
-        ffOptionParseColor(value, &instance->config.colorTitle);
+        optionCheckString(key, value, &instance.config.colorTitle);
+        ffOptionParseColor(value, &instance.config.colorTitle);
     }
     else if(ffStrEqualsIgnCase(key, "-c") || ffStrEqualsIgnCase(key, "--color"))
     {
-        optionCheckString(key, value, &instance->config.colorKeys);
-        ffOptionParseColor(value, &instance->config.colorKeys);
-        ffStrbufSet(&instance->config.colorTitle, &instance->config.colorKeys);
+        optionCheckString(key, value, &instance.config.colorKeys);
+        ffOptionParseColor(value, &instance.config.colorKeys);
+        ffStrbufSet(&instance.config.colorTitle, &instance.config.colorKeys);
     }
     else if(ffStrEqualsIgnCase(key, "--binary-prefix"))
     {
-        instance->config.binaryPrefixType = (FFBinaryPrefixType) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
+        instance.config.binaryPrefixType = (FFBinaryPrefixType) ffOptionParseEnum(key, value, (FFKeyValuePair[]) {
             { "iec", FF_BINARY_PREFIX_TYPE_IEC },
             { "si", FF_BINARY_PREFIX_TYPE_SI },
             { "jedec", FF_BINARY_PREFIX_TYPE_JEDEC },
@@ -891,64 +891,64 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         });
     }
     else if(ffStrEqualsIgnCase(key, "--percent-type"))
-        instance->config.percentType = ffOptionParseUInt32(key, value);
+        instance.config.percentType = ffOptionParseUInt32(key, value);
     else if(ffStrEqualsIgnCase(key, "--no-buffer"))
-        instance->config.noBuffer = ffOptionParseBoolean(value);
+        instance.config.noBuffer = ffOptionParseBoolean(value);
 
     ///////////////////////
     //Module args options//
     ///////////////////////
 
-    else if(ffParseOSCommandOptions(&instance->config.os, key, value)) {}
-    else if(ffParseHostCommandOptions(&instance->config.host, key, value)) {}
-    else if(ffParseOSCommandOptions(&instance->config.os, key, value)) {}
-    else if(ffParseBiosCommandOptions(&instance->config.bios, key, value)) {}
-    else if(ffParseBoardCommandOptions(&instance->config.board, key, value)) {}
-    else if(ffParseChassisCommandOptions(&instance->config.chassis, key, value)) {}
-    else if(ffParseCommandCommandOptions(&instance->config.command, key, value)) {}
-    else if(ffParseCustomCommandOptions(&instance->config.custom, key, value)) {}
-    else if(ffParseKernelCommandOptions(&instance->config.kernel, key, value)) {}
-    else if(ffParseUptimeCommandOptions(&instance->config.uptime, key, value)) {}
-    else if(ffParseProcessesCommandOptions(&instance->config.processes, key, value)) {}
-    else if(ffParsePackagesCommandOptions(&instance->config.packages, key, value)) {}
-    else if(ffParseShellCommandOptions(&instance->config.shell, key, value)) {}
-    else if(ffParseDisplayCommandOptions(&instance->config.display, key, value)) {}
-    else if(ffParseBrightnessCommandOptions(&instance->config.brightness, key, value)) {}
-    else if(ffParseDECommandOptions(&instance->config.de, key, value)) {}
-    else if(ffParseWifiCommandOptions(&instance->config.wifi, key, value)) {}
-    else if(ffParseWMCommandOptions(&instance->config.wm, key, value)) {}
-    else if(ffParseWMThemeCommandOptions(&instance->config.wmTheme, key, value)) {}
-    else if(ffParseThemeCommandOptions(&instance->config.theme, key, value)) {}
-    else if(ffParseIconsCommandOptions(&instance->config.icons, key, value)) {}
-    else if(ffParseWallpaperCommandOptions(&instance->config.wallpaper, key, value)) {}
-    else if(ffParseFontCommandOptions(&instance->config.font, key, value)) {}
-    else if(ffParseCursorCommandOptions(&instance->config.cursor, key, value)) {}
-    else if(ffParseTerminalCommandOptions(&instance->config.terminal, key, value)) {}
-    else if(ffParseTerminalFontCommandOptions(&instance->config.terminalFont, key, value)) {}
-    else if(ffParseCPUCommandOptions(&instance->config.cpu, key, value)) {}
-    else if(ffParseCPUUsageCommandOptions(&instance->config.cpuUsage, key, value)) {}
-    else if(ffParseGPUCommandOptions(&instance->config.gpu, key, value)) {}
-    else if(ffParseMemoryCommandOptions(&instance->config.memory, key, value)) {}
-    else if(ffParseSwapCommandOptions(&instance->config.swap, key, value)) {}
-    else if(ffParseDiskCommandOptions(&instance->config.disk, key, value)) {}
-    else if(ffParseBatteryCommandOptions(&instance->config.battery, key, value)) {}
-    else if(ffParsePowerAdapterCommandOptions(&instance->config.powerAdapter, key, value)) {}
-    else if(ffParseLocaleCommandOptions(&instance->config.locale, key, value)) {}
-    else if(ffParseLocalIpCommandOptions(&instance->config.localIP, key, value)) {}
-    else if(ffParsePublicIpCommandOptions(&instance->config.publicIP, key, value)) {}
-    else if(ffParseWeatherCommandOptions(&instance->config.weather, key, value)) {}
-    else if(ffParsePlayerCommandOptions(&instance->config.player, key, value)) {}
-    else if(ffParseMediaCommandOptions(&instance->config.media, key, value)) {}
-    else if(ffParseDateTimeCommandOptions(&instance->config.dateTime, key, value)) {}
-    else if(ffParseVulkanCommandOptions(&instance->config.vulkan, key, value)) {}
-    else if(ffParseOpenGLCommandOptions(&instance->config.openGL, key, value)) {}
-    else if(ffParseOpenCLCommandOptions(&instance->config.openCL, key, value)) {}
-    else if(ffParseUsersCommandOptions(&instance->config.users, key, value)) {}
-    else if(ffParseBluetoothCommandOptions(&instance->config.bluetooth, key, value)) {}
-    else if(ffParseSeparatorCommandOptions(&instance->config.separator, key, value)) {}
-    else if(ffParseSoundCommandOptions(&instance->config.sound, key, value)) {}
-    else if(ffParseGamepadCommandOptions(&instance->config.gamepad, key, value)) {}
-    else if(ffParseColorsCommandOptions(&instance->config.colors, key, value)) {}
+    else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
+    else if(ffParseHostCommandOptions(&instance.config.host, key, value)) {}
+    else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
+    else if(ffParseBiosCommandOptions(&instance.config.bios, key, value)) {}
+    else if(ffParseBoardCommandOptions(&instance.config.board, key, value)) {}
+    else if(ffParseChassisCommandOptions(&instance.config.chassis, key, value)) {}
+    else if(ffParseCommandCommandOptions(&instance.config.command, key, value)) {}
+    else if(ffParseCustomCommandOptions(&instance.config.custom, key, value)) {}
+    else if(ffParseKernelCommandOptions(&instance.config.kernel, key, value)) {}
+    else if(ffParseUptimeCommandOptions(&instance.config.uptime, key, value)) {}
+    else if(ffParseProcessesCommandOptions(&instance.config.processes, key, value)) {}
+    else if(ffParsePackagesCommandOptions(&instance.config.packages, key, value)) {}
+    else if(ffParseShellCommandOptions(&instance.config.shell, key, value)) {}
+    else if(ffParseDisplayCommandOptions(&instance.config.display, key, value)) {}
+    else if(ffParseBrightnessCommandOptions(&instance.config.brightness, key, value)) {}
+    else if(ffParseDECommandOptions(&instance.config.de, key, value)) {}
+    else if(ffParseWifiCommandOptions(&instance.config.wifi, key, value)) {}
+    else if(ffParseWMCommandOptions(&instance.config.wm, key, value)) {}
+    else if(ffParseWMThemeCommandOptions(&instance.config.wmTheme, key, value)) {}
+    else if(ffParseThemeCommandOptions(&instance.config.theme, key, value)) {}
+    else if(ffParseIconsCommandOptions(&instance.config.icons, key, value)) {}
+    else if(ffParseWallpaperCommandOptions(&instance.config.wallpaper, key, value)) {}
+    else if(ffParseFontCommandOptions(&instance.config.font, key, value)) {}
+    else if(ffParseCursorCommandOptions(&instance.config.cursor, key, value)) {}
+    else if(ffParseTerminalCommandOptions(&instance.config.terminal, key, value)) {}
+    else if(ffParseTerminalFontCommandOptions(&instance.config.terminalFont, key, value)) {}
+    else if(ffParseCPUCommandOptions(&instance.config.cpu, key, value)) {}
+    else if(ffParseCPUUsageCommandOptions(&instance.config.cpuUsage, key, value)) {}
+    else if(ffParseGPUCommandOptions(&instance.config.gpu, key, value)) {}
+    else if(ffParseMemoryCommandOptions(&instance.config.memory, key, value)) {}
+    else if(ffParseSwapCommandOptions(&instance.config.swap, key, value)) {}
+    else if(ffParseDiskCommandOptions(&instance.config.disk, key, value)) {}
+    else if(ffParseBatteryCommandOptions(&instance.config.battery, key, value)) {}
+    else if(ffParsePowerAdapterCommandOptions(&instance.config.powerAdapter, key, value)) {}
+    else if(ffParseLocaleCommandOptions(&instance.config.locale, key, value)) {}
+    else if(ffParseLocalIpCommandOptions(&instance.config.localIP, key, value)) {}
+    else if(ffParsePublicIpCommandOptions(&instance.config.publicIP, key, value)) {}
+    else if(ffParseWeatherCommandOptions(&instance.config.weather, key, value)) {}
+    else if(ffParsePlayerCommandOptions(&instance.config.player, key, value)) {}
+    else if(ffParseMediaCommandOptions(&instance.config.media, key, value)) {}
+    else if(ffParseDateTimeCommandOptions(&instance.config.dateTime, key, value)) {}
+    else if(ffParseVulkanCommandOptions(&instance.config.vulkan, key, value)) {}
+    else if(ffParseOpenGLCommandOptions(&instance.config.openGL, key, value)) {}
+    else if(ffParseOpenCLCommandOptions(&instance.config.openCL, key, value)) {}
+    else if(ffParseUsersCommandOptions(&instance.config.users, key, value)) {}
+    else if(ffParseBluetoothCommandOptions(&instance.config.bluetooth, key, value)) {}
+    else if(ffParseSeparatorCommandOptions(&instance.config.separator, key, value)) {}
+    else if(ffParseSoundCommandOptions(&instance.config.sound, key, value)) {}
+    else if(ffParseGamepadCommandOptions(&instance.config.gamepad, key, value)) {}
+    else if(ffParseColorsCommandOptions(&instance.config.colors, key, value)) {}
 
     ///////////////////
     //Library options//
@@ -958,51 +958,51 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
     {
         const char* subkey = key + strlen("--lib");
         if(ffStrEqualsIgnCase(subkey, "-PCI"))
-            ffOptionParseString(key, value, &instance->config.libPCI);
+            ffOptionParseString(key, value, &instance.config.libPCI);
         else if(ffStrEqualsIgnCase(subkey, "-vulkan"))
-            ffOptionParseString(key, value, &instance->config.libVulkan);
+            ffOptionParseString(key, value, &instance.config.libVulkan);
         else if(ffStrEqualsIgnCase(subkey, "-freetype"))
-            ffOptionParseString(key, value, &instance->config.libfreetype);
+            ffOptionParseString(key, value, &instance.config.libfreetype);
         else if(ffStrEqualsIgnCase(subkey, "-wayland"))
-            ffOptionParseString(key, value, &instance->config.libWayland);
+            ffOptionParseString(key, value, &instance.config.libWayland);
         else if(ffStrEqualsIgnCase(subkey, "-xcb-randr"))
-            ffOptionParseString(key, value, &instance->config.libXcbRandr);
+            ffOptionParseString(key, value, &instance.config.libXcbRandr);
         else if(ffStrEqualsIgnCase(subkey, "-xcb"))
-            ffOptionParseString(key, value, &instance->config.libXcb);
+            ffOptionParseString(key, value, &instance.config.libXcb);
         else if(ffStrEqualsIgnCase(subkey, "-Xrandr"))
-            ffOptionParseString(key, value, &instance->config.libXrandr);
+            ffOptionParseString(key, value, &instance.config.libXrandr);
         else if(ffStrEqualsIgnCase(subkey, "-X11"))
-            ffOptionParseString(key, value, &instance->config.libX11);
+            ffOptionParseString(key, value, &instance.config.libX11);
         else if(ffStrEqualsIgnCase(subkey, "-gio"))
-            ffOptionParseString(key, value, &instance->config.libGIO);
+            ffOptionParseString(key, value, &instance.config.libGIO);
         else if(ffStrEqualsIgnCase(subkey, "-DConf"))
-            ffOptionParseString(key, value, &instance->config.libDConf);
+            ffOptionParseString(key, value, &instance.config.libDConf);
         else if(ffStrEqualsIgnCase(subkey, "-dbus"))
-            ffOptionParseString(key, value, &instance->config.libDBus);
+            ffOptionParseString(key, value, &instance.config.libDBus);
         else if(ffStrEqualsIgnCase(subkey, "-XFConf"))
-            ffOptionParseString(key, value, &instance->config.libXFConf);
+            ffOptionParseString(key, value, &instance.config.libXFConf);
         else if(ffStrEqualsIgnCase(subkey, "-sqlite") || ffStrEqualsIgnCase(subkey, "-sqlite3"))
-            ffOptionParseString(key, value, &instance->config.libSQLite3);
+            ffOptionParseString(key, value, &instance.config.libSQLite3);
         else if(ffStrEqualsIgnCase(subkey, "-rpm"))
-            ffOptionParseString(key, value, &instance->config.librpm);
+            ffOptionParseString(key, value, &instance.config.librpm);
         else if(ffStrEqualsIgnCase(subkey, "-imagemagick"))
-            ffOptionParseString(key, value, &instance->config.libImageMagick);
+            ffOptionParseString(key, value, &instance.config.libImageMagick);
         else if(ffStrEqualsIgnCase(subkey, "-z"))
-            ffOptionParseString(key, value, &instance->config.libZ);
+            ffOptionParseString(key, value, &instance.config.libZ);
         else if(ffStrEqualsIgnCase(subkey, "-chafa"))
-            ffOptionParseString(key, value, &instance->config.libChafa);
+            ffOptionParseString(key, value, &instance.config.libChafa);
         else if(ffStrEqualsIgnCase(subkey, "-egl"))
-            ffOptionParseString(key, value, &instance->config.libEGL);
+            ffOptionParseString(key, value, &instance.config.libEGL);
         else if(ffStrEqualsIgnCase(subkey, "-glx"))
-            ffOptionParseString(key, value, &instance->config.libGLX);
+            ffOptionParseString(key, value, &instance.config.libGLX);
         else if(ffStrEqualsIgnCase(subkey, "-osmesa"))
-            ffOptionParseString(key, value, &instance->config.libOSMesa);
+            ffOptionParseString(key, value, &instance.config.libOSMesa);
         else if(ffStrEqualsIgnCase(subkey, "-opencl"))
-            ffOptionParseString(key, value, &instance->config.libOpenCL);
+            ffOptionParseString(key, value, &instance.config.libOpenCL);
         else if(ffStrEqualsIgnCase(key, "-pulse"))
-            ffOptionParseString(key, value, &instance->config.libPulse);
+            ffOptionParseString(key, value, &instance.config.libPulse);
         else if(ffStrEqualsIgnCase(subkey, "-nm"))
-            ffOptionParseString(key, value, &instance->config.libnm);
+            ffOptionParseString(key, value, &instance.config.libnm);
         else
             goto error;
     }
@@ -1019,34 +1019,34 @@ error:
     }
 }
 
-static void parseConfigFiles(FFinstance* instance, FFdata* data)
+static void parseConfigFiles(FFdata* data)
 {
-    for(uint32_t i = instance->state.platform.configDirs.length; i > 0; --i)
+    for(uint32_t i = instance.state.platform.configDirs.length; i > 0; --i)
     {
-        FFstrbuf* dir = ffListGet(&instance->state.platform.configDirs, i - 1);
+        FFstrbuf* dir = ffListGet(&instance.state.platform.configDirs, i - 1);
         uint32_t dirLength = dir->length;
 
         ffStrbufAppendS(dir, "fastfetch/config.jsonc");
-        bool success = parseJsoncFile(instance, dir->chars);
+        bool success = parseJsoncFile(dir->chars);
         ffStrbufSubstrBefore(dir, dirLength);
         if (success) return;
     }
 
-    for(uint32_t i = instance->state.platform.configDirs.length; i > 0; --i)
+    for(uint32_t i = instance.state.platform.configDirs.length; i > 0; --i)
     {
         if(!data->loadUserConfig)
             return;
 
-        FFstrbuf* dir = ffListGet(&instance->state.platform.configDirs, i - 1);
+        FFstrbuf* dir = ffListGet(&instance.state.platform.configDirs, i - 1);
         uint32_t dirLength = dir->length;
 
         ffStrbufAppendS(dir, "fastfetch/config.conf");
-        parseConfigFile(instance, data, dir->chars);
+        parseConfigFile(data, dir->chars);
         ffStrbufSubstrBefore(dir, dirLength);
     }
 }
 
-static void parseArguments(FFinstance* instance, FFdata* data, int argc, const char** argv)
+static void parseArguments(FFdata* data, int argc, const char** argv)
 {
     if(!data->loadUserConfig)
         return;
@@ -1057,139 +1057,138 @@ static void parseArguments(FFinstance* instance, FFdata* data, int argc, const c
             *argv[i + 1] == '-' &&
             strcasecmp(argv[i], "--separator-string") != 0 // Separator string can start with a -
         )) {
-            parseOption(instance, data, argv[i], NULL);
+            parseOption(data, argv[i], NULL);
         }
         else
         {
-            parseOption(instance, data, argv[i], argv[i + 1]);
+            parseOption(data, argv[i], argv[i + 1]);
             ++i;
         }
     }
 }
 
-static void parseStructureCommand(FFinstance* instance, const char* line)
+static void parseStructureCommand(const char* line)
 {
     if(ffStrEqualsIgnCase(line, FF_BREAK_MODULE_NAME))
-        ffPrintBreak(instance);
+        ffPrintBreak();
     else if(ffStrEqualsIgnCase(line, FF_TITLE_MODULE_NAME))
-        ffPrintTitle(instance, &instance->config.title);
+        ffPrintTitle(&instance.config.title);
     else if(ffStrEqualsIgnCase(line, FF_SEPARATOR_MODULE_NAME))
-        ffPrintSeparator(instance, &instance->config.separator);
+        ffPrintSeparator(&instance.config.separator);
     else if(ffStrEqualsIgnCase(line, FF_OS_MODULE_NAME))
-        ffPrintOS(instance, &instance->config.os);
+        ffPrintOS(&instance.config.os);
     else if(ffStrEqualsIgnCase(line, FF_HOST_MODULE_NAME))
-        ffPrintHost(instance, &instance->config.host);
+        ffPrintHost(&instance.config.host);
     else if(ffStrEqualsIgnCase(line, FF_BIOS_MODULE_NAME))
-        ffPrintBios(instance, &instance->config.bios);
+        ffPrintBios(&instance.config.bios);
     else if(ffStrEqualsIgnCase(line, FF_BOARD_MODULE_NAME))
-        ffPrintBoard(instance, &instance->config.board);
+        ffPrintBoard(&instance.config.board);
     else if(ffStrEqualsIgnCase(line, FF_BRIGHTNESS_MODULE_NAME))
-        ffPrintBrightness(instance, &instance->config.brightness);
+        ffPrintBrightness(&instance.config.brightness);
     else if(ffStrEqualsIgnCase(line, FF_CHASSIS_MODULE_NAME))
-        ffPrintChassis(instance, &instance->config.chassis);
+        ffPrintChassis(&instance.config.chassis);
     else if(ffStrEqualsIgnCase(line, FF_KERNEL_MODULE_NAME))
-        ffPrintKernel(instance, &instance->config.kernel);
+        ffPrintKernel(&instance.config.kernel);
     else if(ffStrEqualsIgnCase(line, FF_PROCESSES_MODULE_NAME))
-        ffPrintProcesses(instance, &instance->config.processes);
+        ffPrintProcesses(&instance.config.processes);
     else if(ffStrEqualsIgnCase(line, FF_UPTIME_MODULE_NAME))
-        ffPrintUptime(instance, &instance->config.uptime);
+        ffPrintUptime(&instance.config.uptime);
     else if(ffStrEqualsIgnCase(line, FF_PACKAGES_MODULE_NAME))
-        ffPrintPackages(instance, &instance->config.packages);
+        ffPrintPackages(&instance.config.packages);
     else if(ffStrEqualsIgnCase(line, FF_SHELL_MODULE_NAME))
-        ffPrintShell(instance, &instance->config.shell);
+        ffPrintShell(&instance.config.shell);
     else if(ffStrEqualsIgnCase(line, FF_DISPLAY_MODULE_NAME))
-        ffPrintDisplay(instance, &instance->config.display);
+        ffPrintDisplay(&instance.config.display);
     else if(ffStrEqualsIgnCase(line, FF_DE_MODULE_NAME))
-        ffPrintDE(instance, &instance->config.de);
+        ffPrintDE(&instance.config.de);
     else if(ffStrEqualsIgnCase(line, FF_WM_MODULE_NAME))
-        ffPrintWM(instance, &instance->config.wm);
+        ffPrintWM(&instance.config.wm);
     else if(ffStrEqualsIgnCase(line, FF_THEME_MODULE_NAME))
-        ffPrintTheme(instance, &instance->config.theme);
+        ffPrintTheme(&instance.config.theme);
     else if(ffStrEqualsIgnCase(line, FF_WMTHEME_MODULE_NAME))
-        ffPrintWMTheme(instance, &instance->config.wmTheme);
+        ffPrintWMTheme(&instance.config.wmTheme);
     else if(ffStrEqualsIgnCase(line, FF_ICONS_MODULE_NAME))
-        ffPrintIcons(instance, &instance->config.icons);
+        ffPrintIcons(&instance.config.icons);
     else if(ffStrEqualsIgnCase(line, FF_WALLPAPER_MODULE_NAME))
-        ffPrintWallpaper(instance, &instance->config.wallpaper);
+        ffPrintWallpaper(&instance.config.wallpaper);
     else if(ffStrEqualsIgnCase(line, FF_FONT_MODULE_NAME))
-        ffPrintFont(instance, &instance->config.font);
+        ffPrintFont(&instance.config.font);
     else if(ffStrEqualsIgnCase(line, FF_CURSOR_MODULE_NAME))
-        ffPrintCursor(instance, &instance->config.cursor);
+        ffPrintCursor(&instance.config.cursor);
     else if(ffStrEqualsIgnCase(line, FF_TERMINAL_MODULE_NAME))
-        ffPrintTerminal(instance, &instance->config.terminal);
+        ffPrintTerminal(&instance.config.terminal);
     else if(ffStrEqualsIgnCase(line, FF_TERMINALFONT_MODULE_NAME))
-        ffPrintTerminalFont(instance, &instance->config.terminalFont);
+        ffPrintTerminalFont(&instance.config.terminalFont);
     else if(ffStrEqualsIgnCase(line, FF_CPU_MODULE_NAME))
-        ffPrintCPU(instance, &instance->config.cpu);
+        ffPrintCPU(&instance.config.cpu);
     else if(ffStrEqualsIgnCase(line, FF_CPUUSAGE_MODULE_NAME))
-        ffPrintCPUUsage(instance, &instance->config.cpuUsage);
+        ffPrintCPUUsage(&instance.config.cpuUsage);
     else if(ffStrEqualsIgnCase(line, FF_CUSTOM_MODULE_NAME))
-        ffPrintCustom(instance, &instance->config.custom);
+        ffPrintCustom(&instance.config.custom);
     else if(ffStrEqualsIgnCase(line, FF_GPU_MODULE_NAME))
-        ffPrintGPU(instance, &instance->config.gpu);
+        ffPrintGPU(&instance.config.gpu);
     else if(ffStrEqualsIgnCase(line, FF_MEMORY_MODULE_NAME))
-        ffPrintMemory(instance, &instance->config.memory);
+        ffPrintMemory(&instance.config.memory);
     else if(ffStrEqualsIgnCase(line, FF_SWAP_MODULE_NAME))
-        ffPrintSwap(instance, &instance->config.swap);
+        ffPrintSwap(&instance.config.swap);
     else if(ffStrEqualsIgnCase(line, FF_DISK_MODULE_NAME))
-        ffPrintDisk(instance, &instance->config.disk);
+        ffPrintDisk(&instance.config.disk);
     else if(ffStrEqualsIgnCase(line, FF_BATTERY_MODULE_NAME))
-        ffPrintBattery(instance, &instance->config.battery);
+        ffPrintBattery(&instance.config.battery);
     else if(ffStrEqualsIgnCase(line, FF_POWERADAPTER_MODULE_NAME))
-        ffPrintPowerAdapter(instance, &instance->config.powerAdapter);
+        ffPrintPowerAdapter(&instance.config.powerAdapter);
     else if(ffStrEqualsIgnCase(line, FF_LM_MODULE_NAME))
-        ffPrintLM(instance, &instance->config.lm);
+        ffPrintLM(&instance.config.lm);
     else if(ffStrEqualsIgnCase(line, FF_LOCALE_MODULE_NAME))
-        ffPrintLocale(instance, &instance->config.locale);
+        ffPrintLocale(&instance.config.locale);
     else if(ffStrEqualsIgnCase(line, FF_LOCALIP_MODULE_NAME))
-        ffPrintLocalIp(instance, &instance->config.localIP);
+        ffPrintLocalIp(&instance.config.localIP);
     else if(ffStrEqualsIgnCase(line, FF_PUBLICIP_MODULE_NAME))
-        ffPrintPublicIp(instance, &instance->config.publicIP);
+        ffPrintPublicIp(&instance.config.publicIP);
     else if(ffStrEqualsIgnCase(line, FF_WIFI_MODULE_NAME))
-        ffPrintWifi(instance, &instance->config.wifi);
+        ffPrintWifi(&instance.config.wifi);
     else if(ffStrEqualsIgnCase(line, FF_WEATHER_MODULE_NAME))
-        ffPrintWeather(instance, &instance->config.weather);
+        ffPrintWeather(&instance.config.weather);
     else if(ffStrEqualsIgnCase(line, FF_PLAYER_MODULE_NAME))
-        ffPrintPlayer(instance, &instance->config.player);
+        ffPrintPlayer(&instance.config.player);
     else if(ffStrEqualsIgnCase(line, FF_MEDIA_MODULE_NAME))
-        ffPrintMedia(instance, &instance->config.media);
+        ffPrintMedia(&instance.config.media);
     else if(ffStrEqualsIgnCase(line, FF_DATETIME_MODULE_NAME))
-        ffPrintDateTime(instance, &instance->config.dateTime);
+        ffPrintDateTime(&instance.config.dateTime);
     else if(ffStrEqualsIgnCase(line, FF_COLORS_MODULE_NAME))
-        ffPrintColors(instance, &instance->config.colors);
+        ffPrintColors(&instance.config.colors);
     else if(ffStrEqualsIgnCase(line, FF_VULKAN_MODULE_NAME))
-        ffPrintVulkan(instance, &instance->config.vulkan);
+        ffPrintVulkan(&instance.config.vulkan);
     else if(ffStrEqualsIgnCase(line, FF_OPENGL_MODULE_NAME))
-        ffPrintOpenGL(instance, &instance->config.openGL);
+        ffPrintOpenGL(&instance.config.openGL);
     else if(ffStrEqualsIgnCase(line, FF_OPENCL_MODULE_NAME))
-        ffPrintOpenCL(instance, &instance->config.openCL);
+        ffPrintOpenCL(&instance.config.openCL);
     else if(ffStrEqualsIgnCase(line, FF_USERS_MODULE_NAME))
-        ffPrintUsers(instance, &instance->config.users);
+        ffPrintUsers(&instance.config.users);
     else if(ffStrEqualsIgnCase(line, FF_COMMAND_MODULE_NAME))
-        ffPrintCommand(instance, &instance->config.command);
+        ffPrintCommand(&instance.config.command);
     else if(ffStrEqualsIgnCase(line, FF_BLUETOOTH_MODULE_NAME))
-        ffPrintBluetooth(instance, &instance->config.bluetooth);
+        ffPrintBluetooth(&instance.config.bluetooth);
     else if(ffStrEqualsIgnCase(line, FF_SOUND_MODULE_NAME))
-        ffPrintSound(instance, &instance->config.sound);
+        ffPrintSound(&instance.config.sound);
     else if(ffStrEqualsIgnCase(line, FF_GAMEPAD_MODULE_NAME))
-        ffPrintGamepad(instance, &instance->config.gamepad);
+        ffPrintGamepad(&instance.config.gamepad);
     else
-        ffPrintErrorString(instance, line, 0, NULL, NULL, "<no implementation provided>");
+        ffPrintErrorString(line, 0, NULL, NULL, "<no implementation provided>");
 }
 
 int main(int argc, const char** argv)
 {
-    FFinstance instance;
-    ffInitInstance(&instance);
+    ffInitInstance();
 
     //Data stores things only needed for the configuration of fastfetch
     FFdata data;
-    ffStrbufInitA(&data.structure, 256);
+    ffStrbufInit(&data.structure);
     data.loadUserConfig = true;
 
     if(!getenv("NO_CONFIG"))
-        parseConfigFiles(&instance, &data);
-    parseArguments(&instance, &data, argc, argv);
+        parseConfigFiles(&data);
+    parseArguments(&data, argc, argv);
 
     if(data.structure.length > 0 || !instance.state.configDoc)
     {
@@ -1210,7 +1209,7 @@ int main(int argc, const char** argv)
         }
     }
 
-    ffStart(&instance);
+    ffStart();
 
     #if defined(_WIN32)
         if (!instance.config.noBuffer) fflush(stdout);
@@ -1218,7 +1217,7 @@ int main(int argc, const char** argv)
 
     if (data.structure.length == 0 && instance.state.configDoc)
     {
-        ffPrintJsonConfig(&instance);
+        ffPrintJsonConfig();
     }
     else
     {
@@ -1233,7 +1232,7 @@ int main(int argc, const char** argv)
             if(__builtin_expect(instance.config.stat, false))
                 ms = ffTimeGetTick();
 
-            parseStructureCommand(&instance, data.structure.chars + startIndex);
+            parseStructureCommand(data.structure.chars + startIndex);
 
             if(__builtin_expect(instance.config.stat, false))
             {
@@ -1253,9 +1252,9 @@ int main(int argc, const char** argv)
         }
     }
 
-    ffFinish(&instance);
+    ffFinish();
 
     ffStrbufDestroy(&data.structure);
 
-    ffDestroyInstance(&instance);
+    ffDestroyInstance();
 }
diff --git a/src/fastfetch.h b/src/fastfetch.h
index 48d7dfa37..c76882c15 100644
--- a/src/fastfetch.h
+++ b/src/fastfetch.h
@@ -152,16 +152,17 @@ typedef struct FFinstance
     FFconfig config;
     FFstate state;
 } FFinstance;
+extern FFinstance instance; // Defined in `common/init.c`
 
 //////////////////////
 // Init functions //
 //////////////////////
 
 //common/init.c
-void ffInitInstance(FFinstance* instance);
-void ffStart(FFinstance* instance);
-void ffFinish(FFinstance* instance);
-void ffDestroyInstance(FFinstance* instance);
+void ffInitInstance();
+void ffStart();
+void ffFinish();
+void ffDestroyInstance();
 
 void ffListFeatures();
 
@@ -169,11 +170,11 @@ void ffListFeatures();
 // Logo functions //
 ////////////////////
 
-void ffLogoPrint(FFinstance* instance);
-void ffLogoPrintRemaining(FFinstance* instance);
-void ffLogoPrintLine(FFinstance* instance);
+void ffLogoPrint();
+void ffLogoPrintRemaining();
+void ffLogoPrintLine();
 
-void ffLogoBuiltinPrint(FFinstance* instance);
+void ffLogoBuiltinPrint();
 void ffLogoBuiltinList();
 void ffLogoBuiltinListAutocompletion();
 
diff --git a/src/flashfetch.c b/src/flashfetch.c
index b7b18fc9f..3417548f5 100644
--- a/src/flashfetch.c
+++ b/src/flashfetch.c
@@ -2,76 +2,70 @@
 
 #include "modules/modules.h"
 
-int main(int argc, char** argv)
+int main(void)
 {
-    //Disable compiler warnings
-    FF_UNUSED(argc, argv);
-
-    FFinstance instance;
-    ffInitInstance(&instance); //This also applys default configuration to instance.config
+    ffInitInstance(); //This also applys default configuration to instance.config
 
     //Modify instance.config here
 
     // ffPrepareCPUUsage();
     // ffPreparePublicIp(&instance.config.publicIP);
-    // ffPrepareWeather(&instance);
+    // ffPrepareWeather(&instance.config.weather);
 
     //Does things like starting detection threads, disabling line wrap, etc
-    ffStart(&instance);
+    ffStart();
 
     //Printing
-    ffPrintTitle(&instance, &instance.config.title);
-    ffPrintSeparator(&instance, &instance.config.separator);
-    ffPrintOS(&instance, &instance.config.os);
-    ffPrintHost(&instance, &instance.config.host);
-    //ffPrintBios(&instance, &instance.config.bios);
-    //ffPrintBoard(&instance, &instance.config.board);
-    //ffPrintChassis(&instance, &instance.config.chassis);
-    ffPrintKernel(&instance, &instance.config.kernel);
-    //ffPrintProcesses(&instance, &instance.config.processes);
-    ffPrintUptime(&instance, &instance.config.uptime);
-    ffPrintPackages(&instance, &instance.config.packages);
-    ffPrintShell(&instance, &instance.config.shell);
-    ffPrintDisplay(&instance, &instance.config.display);
-    // ffPrintBrightness(&instance);
-    ffPrintDE(&instance, &instance.config.de);
-    ffPrintWM(&instance, &instance.config.wm);
-    ffPrintWMTheme(&instance, &instance.config.wmTheme);
-    ffPrintTheme(&instance, &instance.config.theme);
-    ffPrintIcons(&instance, &instance.config.icons);
-    ffPrintFont(&instance, &instance.config.font);
-    ffPrintCursor(&instance, &instance.config.cursor);
-    ffPrintTerminal(&instance, &instance.config.terminal);
-    ffPrintTerminalFont(&instance, &instance.config.terminalFont);
-    ffPrintCPU(&instance, &instance.config.cpu);
-    ffPrintGPU(&instance, &instance.config.gpu);
-    ffPrintMemory(&instance, &instance.config.memory);
-    ffPrintSwap(&instance, &instance.config.swap);
-    ffPrintDisk(&instance, &instance.config.disk);
-    ffPrintBattery(&instance, &instance.config.battery);
-    ffPrintPowerAdapter(&instance, &instance.config.powerAdapter);
-    //ffPrintPlayer(&instance, &instance.config.player);
-    //ffPrintMedia(&instance, &instance.config.media);
-    //ffPrintLocalIp(&instance);
-    //ffPrintPublicIp(&instance, &instance.config.publicIp);
-    //ffPrintWifi(&instance);
-    //ffPrintCPUUsage(&instance, &instance.config.cpuUsage);
-    ffPrintLocale(&instance, &instance.config.locale);
-    //ffPrintDateTime(&instance);
-    //ffPrintDate(&instance);
-    //ffPrintTime(&instance);
-    //ffPrintVulkan(&instance, &instance.config.vulkan);
-    //ffPrintOpenGL(&instance, &instance.config.openGL);
-    //ffPrintOpenCL(&instance, &instance.config.openCL);
-    //ffPrintUsers(&instance, &instance.config.users);
-    //ffPrintWeather(&instance, &instance.config.weather);
-    //ffPrintBluetooth(&instance);
-    //ffPrintSound(&instance, &instance.config.sound);
-    //ffPrintGamepad(&instance);
-    ffPrintBreak(&instance);
-    ffPrintColors(&instance, &instance.config.colors);
+    ffPrintTitle(&instance.config.title);
+    ffPrintSeparator(&instance.config.separator);
+    ffPrintOS(&instance.config.os);
+    ffPrintHost(&instance.config.host);
+    //ffPrintBios(&instance.config.bios);
+    //ffPrintBoard(&instance.config.board);
+    //ffPrintChassis(&instance.config.chassis);
+    ffPrintKernel(&instance.config.kernel);
+    //ffPrintProcesses(&instance.config.processes);
+    ffPrintUptime(&instance.config.uptime);
+    ffPrintPackages(&instance.config.packages);
+    ffPrintShell(&instance.config.shell);
+    ffPrintDisplay(&instance.config.display);
+    // ffPrintBrightness(&instance.config.brightness);
+    ffPrintDE(&instance.config.de);
+    ffPrintWM(&instance.config.wm);
+    ffPrintWMTheme(&instance.config.wmTheme);
+    ffPrintTheme(&instance.config.theme);
+    ffPrintIcons(&instance.config.icons);
+    ffPrintFont(&instance.config.font);
+    ffPrintCursor(&instance.config.cursor);
+    ffPrintTerminal(&instance.config.terminal);
+    ffPrintTerminalFont(&instance.config.terminalFont);
+    ffPrintCPU(&instance.config.cpu);
+    ffPrintGPU(&instance.config.gpu);
+    ffPrintMemory(&instance.config.memory);
+    ffPrintSwap(&instance.config.swap);
+    ffPrintDisk(&instance.config.disk);
+    ffPrintBattery(&instance.config.battery);
+    ffPrintPowerAdapter(&instance.config.powerAdapter);
+    //ffPrintPlayer(&instance.config.player);
+    //ffPrintMedia(&instance.config.media);
+    //ffPrintLocalIp(&instance.config.localIp);
+    //ffPrintPublicIp(&instance.config.publicIp);
+    //ffPrintWifi(&instance.config.wifi);
+    //ffPrintCPUUsage(&instance.config.cpuUsage);
+    ffPrintLocale(&instance.config.locale);
+    //ffPrintDateTime(&instance.config.dateTime);
+    //ffPrintVulkan(&instance.config.vulkan);
+    //ffPrintOpenGL(&instance.config.openGL);
+    //ffPrintOpenCL(&instance.config.openCL);
+    //ffPrintUsers(&instance.config.users);
+    //ffPrintWeather(&instance.config.weather);
+    //ffPrintBluetooth(&instance.config.bluetooth);
+    //ffPrintSound(&instance.config.sound);
+    //ffPrintGamepad(&instance.config.gamepad);
+    ffPrintBreak();
+    ffPrintColors(&instance.config.colors);
 
-    ffFinish(&instance);
-    ffDestroyInstance(&instance);
+    ffFinish();
+    ffDestroyInstance();
     return 0;
 }
diff --git a/src/logo/builtin.c b/src/logo/builtin.c
index 4962331e3..a86cdfdf1 100644
--- a/src/logo/builtin.c
+++ b/src/logo/builtin.c
@@ -8,7 +8,7 @@
 #define FF_LOGO_COLOR_TITLE(x) logo.colorTitle = x;
 #define FF_LOGO_RETURN return &logo;
 
-const FFlogo* ffLogoBuiltinGetUnknown()
+const FFlogo* ffLogoBuiltinGetUnknown(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("unknown", "question mark", "?")
@@ -38,7 +38,7 @@ const FFlogo* ffLogoBuiltinGetUnknown()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoAlmaLinux()
+static const FFlogo* getLogoAlmaLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("almalinux")
@@ -76,7 +76,7 @@ static const FFlogo* getLogoAlmaLinux()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoAlpine()
+static const FFlogo* getLogoAlpine(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("alpine", "alpinelinux", "alpine-linux")
@@ -110,7 +110,7 @@ static const FFlogo* getLogoAlpine()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoAlpineSmall()
+static const FFlogo* getLogoAlpineSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("alpine_small", "alpine-linux-small")
@@ -130,7 +130,7 @@ static const FFlogo* getLogoAlpineSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoAndroid()
+static const FFlogo* getLogoAndroid(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("android")
@@ -163,7 +163,7 @@ static const FFlogo* getLogoAndroid()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoAndroidSmall()
+static const FFlogo* getLogoAndroidSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("android-small", "android_small")
@@ -183,7 +183,7 @@ static const FFlogo* getLogoAndroidSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoArch()
+static const FFlogo* getLogoArch(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("arch", "archlinux", "arch-linux")
@@ -217,7 +217,7 @@ static const FFlogo* getLogoArch()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoArchSmall()
+static const FFlogo* getLogoArchSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("arch_small", "archlinux_small", "arch-linux-small")
@@ -238,7 +238,7 @@ static const FFlogo* getLogoArchSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoArtix()
+static const FFlogo* getLogoArtix(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("artix", "artixlinux", "artix-linux")
@@ -272,7 +272,7 @@ static const FFlogo* getLogoArtix()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoArtixSmall()
+static const FFlogo* getLogoArtixSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("artix_small", "artixlinux_small", "artix-linux-small")
@@ -293,7 +293,7 @@ static const FFlogo* getLogoArtixSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoArcoLinux()
+static const FFlogo* getLogoArcoLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("arco", "arcolinux", "arco-linux")
@@ -328,7 +328,7 @@ static const FFlogo* getLogoArcoLinux()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoBSD()
+static const FFlogo* getLogoBSD(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("bsd")
@@ -365,7 +365,7 @@ static const FFlogo* getLogoBSD()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoBedrock()
+static const FFlogo* getLogoBedrock(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("bedrock", "bedrocklinux", "bedrock-linux")
@@ -397,7 +397,7 @@ static const FFlogo* getLogoBedrock()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoCachyOS()
+static const FFlogo* getLogoCachyOS(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("cachy", "cachyos", "cachy-linux", "cachyos-linux")
@@ -435,7 +435,7 @@ static const FFlogo* getLogoCachyOS()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoCachyOSSmall()
+static const FFlogo* getLogoCachyOSSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("cachy_small", "cachyos_small", "cachy-linux-small", "cachyos-linux-small")
@@ -458,7 +458,7 @@ static const FFlogo* getLogoCachyOSSmall()
 }
 
 
-static const FFlogo* getLogoCelOS()
+static const FFlogo* getLogoCelOS(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("cel", "celos", "cel-linux", "celos-linux")
@@ -488,7 +488,7 @@ static const FFlogo* getLogoCelOS()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoCentOS()
+static const FFlogo* getLogoCentOS(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("cent", "centos", "cent-linux", "centos-linux")
@@ -525,7 +525,7 @@ static const FFlogo* getLogoCentOS()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoCentOSSmall()
+static const FFlogo* getLogoCentOSSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("cent_small", "centos_small", "cent-linux_small", "cent-linux-small", "centos-linux-small")
@@ -549,7 +549,7 @@ static const FFlogo* getLogoCentOSSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoCRUX()
+static const FFlogo* getLogoCRUX(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("CRUX", "crux")
@@ -583,7 +583,7 @@ static const FFlogo* getLogoCRUX()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoCrystalLinux()
+static const FFlogo* getLogoCrystalLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("crystal", "Crystal", "crystal-linux", "Crystal-Linux")
@@ -619,7 +619,7 @@ static const FFlogo* getLogoCrystalLinux()
 
 
 
-static const FFlogo* getLogoDebian()
+static const FFlogo* getLogoDebian(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("debian", "debian-linux")
@@ -651,7 +651,7 @@ static const FFlogo* getLogoDebian()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoDebianSmall()
+static const FFlogo* getLogoDebianSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("debian_small", "debian-linux-small")
@@ -671,7 +671,7 @@ static const FFlogo* getLogoDebianSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoDevuan()
+static const FFlogo* getLogoDevuan(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("devuan", "devuan-linux")
@@ -700,7 +700,7 @@ static const FFlogo* getLogoDevuan()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoDevuanSmall()
+static const FFlogo* getLogoDevuanSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("devuan_small", "devuan-linux-small")
@@ -721,7 +721,7 @@ static const FFlogo* getLogoDevuanSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoDeepin()
+static const FFlogo* getLogoDeepin(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("deepin", "deepin-linux")
@@ -753,7 +753,7 @@ static const FFlogo* getLogoDeepin()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoEndeavour()
+static const FFlogo* getLogoEndeavour(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("endeavour", "endeavour-linux", "endeavouros", "endeavouros-linux")
@@ -784,7 +784,7 @@ static const FFlogo* getLogoEndeavour()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoEnso()
+static const FFlogo* getLogoEnso(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("enso", "uqc")
@@ -817,7 +817,7 @@ static const FFlogo* getLogoEnso()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoFedora()
+static const FFlogo* getLogoFedora(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("fedora", "fedora-linux")
@@ -851,7 +851,7 @@ static const FFlogo* getLogoFedora()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoFedoraSmall()
+static const FFlogo* getLogoFedoraSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("fedora_small", "fedora-linux-small")
@@ -874,7 +874,7 @@ static const FFlogo* getLogoFedoraSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoFedoraOld()
+static const FFlogo* getLogoFedoraOld(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("fedora_old", "fedora-old", "fedora-linux-old", "fedora-linux_old")
@@ -906,7 +906,7 @@ static const FFlogo* getLogoFedoraOld()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoFreeBSD()
+static const FFlogo* getLogoFreeBSD(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("freebsd")
@@ -936,7 +936,7 @@ static const FFlogo* getLogoFreeBSD()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoFreeBSDSmall()
+static const FFlogo* getLogoFreeBSDSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("freebsd_small")
@@ -956,7 +956,7 @@ static const FFlogo* getLogoFreeBSDSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoGaruda()
+static const FFlogo* getLogoGaruda(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("garuda", "garuda-linux")
@@ -988,7 +988,7 @@ static const FFlogo* getLogoGaruda()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoGarudaSmall()
+static const FFlogo* getLogoGarudaSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("garuda_small", "garudalinux_small", "garuda-linux-small")
@@ -1007,7 +1007,7 @@ static const FFlogo* getLogoGarudaSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoGentoo()
+static const FFlogo* getLogoGentoo(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("gentoo", "gentoo-linux")
@@ -1040,7 +1040,7 @@ static const FFlogo* getLogoGentoo()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoGentooSmall()
+static const FFlogo* getLogoGentooSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("gentoo_small", "gentoo-linux-small")
@@ -1064,7 +1064,7 @@ static const FFlogo* getLogoGentooSmall()
 
 #define FF_RAW_STRING(x) #x
 
-static const FFlogo* getLogoGhostBSD()
+static const FFlogo* getLogoGhostBSD(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("ghostbsd")
@@ -1091,7 +1091,7 @@ static const FFlogo* getLogoGhostBSD()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoKDENeon()
+static const FFlogo* getLogoKDENeon(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("kde", "kde-neon", "neon")
@@ -1124,7 +1124,7 @@ static const FFlogo* getLogoKDENeon()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoKISSLinux()
+static const FFlogo* getLogoKISSLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("kiss", "kiss-linux", "kisslinux")
@@ -1147,7 +1147,7 @@ static const FFlogo* getLogoKISSLinux()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoKubuntu()
+static const FFlogo* getLogoKubuntu(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("kubuntu", "kubuntu-linux", "kde-ubuntu", "ubuntu-kde", "ubuntu-plasma")
@@ -1182,7 +1182,7 @@ static const FFlogo* getLogoKubuntu()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoLangitKetujuh()
+static const FFlogo* getLogoLangitKetujuh(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("l7", "langitketujuh", "LangitKetujuh")
@@ -1210,7 +1210,7 @@ static const FFlogo* getLogoLangitKetujuh()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoLinux()
+static const FFlogo* getLogoLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("linux", "linux-generic")
@@ -1238,7 +1238,7 @@ static const FFlogo* getLogoLinux()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoMacOS()
+static const FFlogo* getLogoMacOS(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("macos", "mac", "apple", "darwin", "osx")
@@ -1273,7 +1273,7 @@ static const FFlogo* getLogoMacOS()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoMacOSSmall()
+static const FFlogo* getLogoMacOSSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("macos_small", "mac_small", "apple_small", "darwin_small", "osx_small")
@@ -1298,7 +1298,7 @@ static const FFlogo* getLogoMacOSSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoMacOSSmall2()
+static const FFlogo* getLogoMacOSSmall2(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("macos_small2", "mac_small2", "apple_small2", "darwin_small2", "osx_small2")
@@ -1323,7 +1323,7 @@ static const FFlogo* getLogoMacOSSmall2()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoManjaro()
+static const FFlogo* getLogoManjaro(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("manjaro", "manjaro-linux")
@@ -1351,7 +1351,7 @@ static const FFlogo* getLogoManjaro()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoManjaroSmall()
+static const FFlogo* getLogoManjaroSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("manjaro_small", "manjaro-linux-small")
@@ -1372,7 +1372,7 @@ static const FFlogo* getLogoManjaroSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoMint()
+static const FFlogo* getLogoMint(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("mint", "linuxmint", "mint-linux", "linux-mint")
@@ -1406,7 +1406,7 @@ static const FFlogo* getLogoMint()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoMintSmall()
+static const FFlogo* getLogoMintSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("mint_small", "linuxmint_small", "mint-linux-small")
@@ -1428,7 +1428,7 @@ static const FFlogo* getLogoMintSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoMintOld()
+static const FFlogo* getLogoMintOld(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("mint_old", "mint-old", "mint-linux_old", "mint-linux-old", "linux-mint_old", "linux-mint-old")
@@ -1459,7 +1459,7 @@ static const FFlogo* getLogoMintOld()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoMsys2()
+static const FFlogo* getLogoMsys2(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("msys2")
@@ -1500,7 +1500,7 @@ static const FFlogo* getLogoMsys2()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoWindows11()
+static const FFlogo* getLogoWindows11(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("Windows 11", "Windows Server 2022")
@@ -1534,7 +1534,7 @@ static const FFlogo* getLogoWindows11()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoWindows11Small()
+static const FFlogo* getLogoWindows11Small(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("Windows 11_small", "Windows 11-small")
@@ -1557,7 +1557,7 @@ static const FFlogo* getLogoWindows11Small()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoWindows8()
+static const FFlogo* getLogoWindows8(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("Windows 8", "Windows 8.1", "Windows 10", "Windows Server 2012", "Windows Server 2012 R2", "Windows Server 2016", "Windows Server 2019")
@@ -1593,7 +1593,7 @@ static const FFlogo* getLogoWindows8()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoWindows()
+static const FFlogo* getLogoWindows(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("Windows", "Windows 7", "Windows Server 2008", "Windows Server 2008 R2")
@@ -1626,7 +1626,7 @@ static const FFlogo* getLogoWindows()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoNixOS()
+static const FFlogo* getLogoNixOS(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("nixos", "nix", "nixos-linux", "nix-linux", "nix-os", "nix_os", "nix_os_linux")
@@ -1661,7 +1661,7 @@ static const FFlogo* getLogoNixOS()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoNixOsOld()
+static const FFlogo* getLogoNixOsOld(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("nixos_old", "nix-old", "nixos-old", "nix_old", "nix-os-old", "nix_os_old")
@@ -1704,7 +1704,7 @@ static const FFlogo* getLogoNixOsOld()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoNixOsSmall()
+static const FFlogo* getLogoNixOsSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("nixos_small", "nix-small", "nixos-small", "nix_small", "nix-os-small", "nix_os_small")
@@ -1725,7 +1725,7 @@ static const FFlogo* getLogoNixOsSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoNobara()
+static const FFlogo* getLogoNobara(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("nobara", "nobara-linux");
@@ -1756,7 +1756,7 @@ static const FFlogo* getLogoNobara()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoOpenSuse()
+static const FFlogo* getLogoOpenSuse(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("suse", "opensuse", "open_suse", "open-suse", "suse-linux")
@@ -1789,7 +1789,7 @@ static const FFlogo* getLogoOpenSuse()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoOpenSuseSmall()
+static const FFlogo* getLogoOpenSuseSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("suse_small", "opensuse_small", "open_suse_small", "open-suse_small")
@@ -1810,7 +1810,7 @@ static const FFlogo* getLogoOpenSuseSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoOpenSuseLeap()
+static const FFlogo* getLogoOpenSuseLeap(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("opensuse_leap", "open_suse_leap", "opensuse-leap", "open-suse-leap", "suse_leap", "suse-leap", "opensuseleap")
@@ -1840,7 +1840,7 @@ static const FFlogo* getLogoOpenSuseLeap()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoOpenSuseTumbleweed()
+static const FFlogo* getLogoOpenSuseTumbleweed(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("opensuse_tumbleweed", "open_suse_tumbleweed", "opensuse-tumbleweed", "open-suse-tumbleweed", "suse_tumbleweed", "suse-tumbleweed", "opensusetumbleweed")
@@ -1867,7 +1867,7 @@ static const FFlogo* getLogoOpenSuseTumbleweed()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoOpenMandriva()
+static const FFlogo* getLogoOpenMandriva(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("openmandriva", "open-mandriva", "open_mandriva")
@@ -1906,7 +1906,7 @@ static const FFlogo* getLogoOpenMandriva()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoPop()
+static const FFlogo* getLogoPop(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("pop", "popos", "pop_os", "pop-linux")
@@ -1941,7 +1941,7 @@ static const FFlogo* getLogoPop()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoParabola()
+static const FFlogo* getLogoParabola(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("parabola", "parabola-gnulinux")
@@ -1971,7 +1971,7 @@ static const FFlogo* getLogoParabola()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoParabolaSmall()
+static const FFlogo* getLogoParabolaSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("parabola_small", "parabola-gnulinux_small")
@@ -1991,7 +1991,7 @@ static const FFlogo* getLogoParabolaSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoPopSmall()
+static const FFlogo* getLogoPopSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("pop_small", "popos_small", "pop_os_small", "pop-linux-small")
@@ -2012,7 +2012,7 @@ static const FFlogo* getLogoPopSmall()
     FF_LOGO_COLOR_TITLE("36"); //cyan
     FF_LOGO_RETURN
 }
-static const FFlogo* getLogoRaspbian()
+static const FFlogo* getLogoRaspbian(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("raspbian", "raspi", "raspberrypi" "raspberrypios"  "pios")
@@ -2050,7 +2050,7 @@ static const FFlogo* getLogoRaspbian()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoRaspbianSmall()
+static const FFlogo* getLogoRaspbianSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("raspbian_small", "raspi_small", "raspberrypi_small" "raspberrypios_small" "pios_small")
@@ -2075,7 +2075,7 @@ static const FFlogo* getLogoRaspbianSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoReborn()
+static const FFlogo* getLogoReborn(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("reborn", "reborn-os", "rebornos", "rebornos-linux", "reborn-os-linux")
@@ -2110,7 +2110,7 @@ static const FFlogo* getLogoReborn()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoRebornSmall()
+static const FFlogo* getLogoRebornSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("reborn_small", "reborn-os-small", "rebornos_small", "rebornos-linux-small", "reborn-os-linux-small")
@@ -2135,7 +2135,7 @@ static const FFlogo* getLogoRebornSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoRedHatEnterpriseLinux()
+static const FFlogo* getLogoRedHatEnterpriseLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("rhel", "redhat", "redhat-linux")
@@ -2167,7 +2167,7 @@ static const FFlogo* getLogoRedHatEnterpriseLinux()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoRedstarOS()
+static const FFlogo* getLogoRedstarOS(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("redstar", "redstar-os", "redstaros", "redstaros-linux", "redstar-os-linux")
@@ -2199,7 +2199,7 @@ static const FFlogo* getLogoRedstarOS()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoRockyLinux()
+static const FFlogo* getLogoRockyLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("rocky", "rocky-linux", "rockylinux")
@@ -2232,7 +2232,7 @@ static const FFlogo* getLogoRockyLinux()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoRosaLinux()
+static const FFlogo* getLogoRosaLinux(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("rosa", "rosa-linux", "rosalinux")
@@ -2266,7 +2266,7 @@ static const FFlogo* getLogoRosaLinux()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoSlackware()
+static const FFlogo* getLogoSlackware(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("slackware", "slackware-linux", "slackwarelinux")
@@ -2302,7 +2302,7 @@ static const FFlogo* getLogoSlackware()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoSlackwareSmall()
+static const FFlogo* getLogoSlackwareSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("slackware-small", "slackware-linux-small", "slackware_small", "slackwarelinux_small")
@@ -2323,7 +2323,7 @@ static const FFlogo* getLogoSlackwareSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoSolus()
+static const FFlogo* getLogoSolus(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("solus", "solus-linux")
@@ -2358,7 +2358,7 @@ static const FFlogo* getLogoSolus()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoSteamOS()
+static const FFlogo* getLogoSteamOS(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("steamos")
@@ -2391,7 +2391,7 @@ static const FFlogo* getLogoSteamOS()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoUbuntu()
+static const FFlogo* getLogoUbuntu(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("ubuntu", "ubuntu-linux")
@@ -2427,7 +2427,7 @@ static const FFlogo* getLogoUbuntu()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoUbuntuOld()
+static const FFlogo* getLogoUbuntuOld(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("ubuntu_old", "ubuntu-linux_old")
@@ -2462,7 +2462,7 @@ static const FFlogo* getLogoUbuntuOld()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoUbuntuSmall()
+static const FFlogo* getLogoUbuntuSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("ubuntu_small", "ubuntu-linux-small")
@@ -2482,7 +2482,7 @@ static const FFlogo* getLogoUbuntuSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoVanilla()
+static const FFlogo* getLogoVanilla(void)
 {
 
     FF_LOGO_INIT
@@ -2515,7 +2515,7 @@ static const FFlogo* getLogoVanilla()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoVoid()
+static const FFlogo* getLogoVoid(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("void", "void-linux")
@@ -2548,7 +2548,7 @@ static const FFlogo* getLogoVoid()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoVoidSmall()
+static const FFlogo* getLogoVoidSmall(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("void_small", "void-linux-small")
@@ -2569,7 +2569,7 @@ static const FFlogo* getLogoVoidSmall()
     FF_LOGO_RETURN
 }
 
-static const FFlogo* getLogoZorin()
+static const FFlogo* getLogoZorin(void)
 {
     FF_LOGO_INIT
     FF_LOGO_NAMES("zorin", "zorin-linux", "zorinos", "zorinos-linux")
@@ -2600,7 +2600,7 @@ static const FFlogo* getLogoZorin()
     FF_LOGO_RETURN
 }
 
-GetLogoMethod* ffLogoBuiltinGetAll()
+GetLogoMethod* ffLogoBuiltinGetAll(void)
 {
     static GetLogoMethod logoMethods[] = {
         ffLogoBuiltinGetUnknown,
diff --git a/src/logo/image/im6.c b/src/logo/image/im6.c
index ba652a370..c9a1e56a4 100644
--- a/src/logo/image/im6.c
+++ b/src/logo/image/im6.c
@@ -12,12 +12,12 @@ static void* logoResize(const void* image, size_t width, size_t height, void* ex
     return ffResizeImage(image, width, height, UndefinedFilter, 1.0, exceptionInfo);
 }
 
-FFLogoImageResult ffLogoPrintImageIM6(FFinstance* instance, FFLogoRequestData* requestData)
+FFLogoImageResult ffLogoPrintImageIM6(FFLogoRequestData* requestData)
 {
-    FF_LIBRARY_LOAD(imageMagick, &instance->config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-6.Q16HDRI" FF_LIBRARY_EXTENSION, 8, "libMagickCore-6.Q16" FF_LIBRARY_EXTENSION, 8)
+    FF_LIBRARY_LOAD(imageMagick, &instance.config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR, "libMagickCore-6.Q16HDRI" FF_LIBRARY_EXTENSION, 8, "libMagickCore-6.Q16" FF_LIBRARY_EXTENSION, 8)
     FF_LIBRARY_LOAD_SYMBOL_ADDRESS(imageMagick, ffResizeImage, ResizeImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
 
-    return ffLogoPrintImageImpl(instance, requestData, &(FFIMData) {
+    return ffLogoPrintImageImpl(requestData, &(FFIMData) {
         .resizeFunc = logoResize,
         .library = imageMagick,
     });
diff --git a/src/logo/image/im7.c b/src/logo/image/im7.c
index 0677b4911..394e124df 100644
--- a/src/logo/image/im7.c
+++ b/src/logo/image/im7.c
@@ -12,16 +12,16 @@ static void* logoResize(const void* image, size_t width, size_t height, void* ex
     return ffResizeImage(image, width, height, UndefinedFilter, exceptionInfo);
 }
 
-FFLogoImageResult ffLogoPrintImageIM7(FFinstance* instance, FFLogoRequestData* requestData)
+FFLogoImageResult ffLogoPrintImageIM7(FFLogoRequestData* requestData)
 {
-    FF_LIBRARY_LOAD(imageMagick, &instance->config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR,
+    FF_LIBRARY_LOAD(imageMagick, &instance.config.libImageMagick, FF_LOGO_IMAGE_RESULT_INIT_ERROR,
         "libMagickCore-7.Q16HDRI" FF_LIBRARY_EXTENSION, 11,
         "libMagickCore-7.Q16" FF_LIBRARY_EXTENSION, 11,
         "libMagickCore-7.Q16HDRI-10" FF_LIBRARY_EXTENSION, -1 // Required for Windows
     )
     FF_LIBRARY_LOAD_SYMBOL_ADDRESS(imageMagick, ffResizeImage, ResizeImage, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
 
-    return ffLogoPrintImageImpl(instance, requestData, &(FFIMData) {
+    return ffLogoPrintImageImpl(requestData, &(FFIMData) {
         .resizeFunc = logoResize,
         .library = imageMagick,
     });
diff --git a/src/logo/image/image.c b/src/logo/image/image.c
index 6c84a9b3b..79dad505b 100644
--- a/src/logo/image/image.c
+++ b/src/logo/image/image.c
@@ -34,51 +34,51 @@ static FFstrbuf base64Encode(FFstrbuf* in)
     return out;
 }
 
-static bool printImageIterm(FFinstance* instance)
+static bool printImageIterm(void)
 {
-    if(instance->config.logo.width == 0 || instance->config.logo.height == 0)
+    if(instance.config.logo.width == 0 || instance.config.logo.height == 0)
     {
         fputs("Logo: `iterm` protocol only works when both `--logo-width` and `--logo-height` being specified\n", stderr);
         return false;
     }
 
     FF_STRBUF_AUTO_DESTROY buf = ffStrbufCreate();
-    if(!ffAppendFileBuffer(instance->config.logo.source.chars, &buf))
+    if(!ffAppendFileBuffer(instance.config.logo.source.chars, &buf))
     {
         fputs("Logo: Failed to load image file\n", stderr);
         return false;
     }
 
-    ffPrintCharTimes('\n', instance->config.logo.paddingTop);
-    ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
+    ffPrintCharTimes('\n', instance.config.logo.paddingTop);
+    ffPrintCharTimes(' ', instance.config.logo.paddingLeft);
 
     FF_STRBUF_AUTO_DESTROY base64 = base64Encode(&buf);
-    instance->state.logoWidth = instance->config.logo.width + instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
-    instance->state.logoHeight = instance->config.logo.paddingTop + instance->config.logo.height;
+    instance.state.logoWidth = instance.config.logo.width + instance.config.logo.paddingLeft + instance.config.logo.paddingRight;
+    instance.state.logoHeight = instance.config.logo.paddingTop + instance.config.logo.height;
     printf("\033]1337;File=inline=1;width=%u;height=%u;preserveAspectRatio=%u:%s\a\033[9999999D\n\033[%uA",
-        (unsigned) instance->config.logo.width,
-        (unsigned) instance->config.logo.height,
-        (unsigned) instance->config.logo.preserveAspectRadio,
+        (unsigned) instance.config.logo.width,
+        (unsigned) instance.config.logo.height,
+        (unsigned) instance.config.logo.preserveAspectRadio,
         base64.chars,
-        (unsigned) instance->state.logoHeight
+        (unsigned) instance.state.logoHeight
     );
 
     return true;
 }
 
-static bool printImageKittyDirect(FFinstance* instance)
+static bool printImageKittyDirect(void)
 {
-    ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
-    ffPrintCharTimes('\n', instance->config.logo.paddingTop);
-    FFstrbuf base64 = base64Encode(&instance->config.logo.source);
+    ffPrintCharTimes(' ', instance.config.logo.paddingLeft);
+    ffPrintCharTimes('\n', instance.config.logo.paddingTop);
+    FFstrbuf base64 = base64Encode(&instance.config.logo.source);
     printf("\033_Ga=T,f=100,t=f,c=%u,r=%u,C=1;%s\033\\\033[9999999D",
-        (unsigned) instance->config.logo.width,
-        (unsigned) instance->config.logo.height,
+        (unsigned) instance.config.logo.width,
+        (unsigned) instance.config.logo.height,
         base64.chars
     );
 
-    instance->state.logoWidth = instance->config.logo.width + instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
-    instance->state.logoHeight = instance->config.logo.paddingTop + instance->config.logo.height;
+    instance.state.logoWidth = instance.config.logo.width + instance.config.logo.paddingLeft + instance.config.logo.paddingRight;
+    instance.state.logoHeight = instance.config.logo.paddingTop + instance.config.logo.height;
 
     ffStrbufDestroy(&base64);
 
@@ -122,9 +122,9 @@ static inline char* realpath(const char* restrict file_name, char* restrict reso
 #include <stdlib.h>
 #include <zlib.h>
 
-static bool compressBlob(const FFinstance* instance, void** blob, size_t* length)
+static bool compressBlob(void** blob, size_t* length)
 {
-    FF_LIBRARY_LOAD(zlib, &instance->config.libZ, false, "libz" FF_LIBRARY_EXTENSION, 2)
+    FF_LIBRARY_LOAD(zlib, &instance.config.libZ, false, "libz" FF_LIBRARY_EXTENSION, 2)
     FF_LIBRARY_LOAD_SYMBOL(zlib, compressBound, false)
     FF_LIBRARY_LOAD_SYMBOL(zlib, compress2, false)
 
@@ -202,36 +202,36 @@ static void writeCacheUint32(FFLogoRequestData* requestData, uint32_t value, con
     writeCacheStrbuf(requestData, &content, cacheFileName);
 }
 
-static void printImagePixels(FFinstance* instance, FFLogoRequestData* requestData, const FFstrbuf* result, const char* cacheFileName)
+static void printImagePixels(FFLogoRequestData* requestData, const FFstrbuf* result, const char* cacheFileName)
 {
     //Calculate character dimensions
-    instance->state.logoWidth = requestData->logoCharacterWidth + instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
+    instance.state.logoWidth = requestData->logoCharacterWidth + instance.config.logo.paddingLeft + instance.config.logo.paddingRight;
 
-    instance->state.logoHeight = requestData->logoCharacterHeight + instance->config.logo.paddingTop;
+    instance.state.logoHeight = requestData->logoCharacterHeight + instance.config.logo.paddingTop;
     if(requestData->type == FF_LOGO_TYPE_IMAGE_KITTY)
-        instance->state.logoHeight -= 1;
+        instance.state.logoHeight -= 1;
 
     //Write cache files
     writeCacheStrbuf(requestData, result, cacheFileName);
 
-    if(instance->config.logo.width == 0)
-        writeCacheUint32(requestData, instance->state.logoWidth, FF_CACHE_FILE_WIDTH);
+    if(instance.config.logo.width == 0)
+        writeCacheUint32(requestData, instance.state.logoWidth, FF_CACHE_FILE_WIDTH);
 
-    if(instance->config.logo.height == 0)
-        writeCacheUint32(requestData, instance->state.logoHeight, FF_CACHE_FILE_HEIGHT);
+    if(instance.config.logo.height == 0)
+        writeCacheUint32(requestData, instance.state.logoHeight, FF_CACHE_FILE_HEIGHT);
 
     //Write result to stdout
-    ffPrintCharTimes('\n', instance->config.logo.paddingTop);
-    ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
+    ffPrintCharTimes('\n', instance.config.logo.paddingTop);
+    ffPrintCharTimes(' ', instance.config.logo.paddingLeft);
     fflush(stdout);
     ffWriteFDBuffer(FFUnixFD2NativeFD(STDOUT_FILENO), result);
 
     //Go to upper left corner
     fputs("\033[9999999D", stdout);
-    printf("\033[%uA", instance->state.logoHeight);
+    printf("\033[%uA", instance.state.logoHeight);
 }
 
-static bool printImageSixel(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+static bool printImageSixel(FFLogoRequestData* requestData, const ImageData* imageData)
 {
     imageData->ffCopyMagickString(imageData->imageInfo->magick, "SIXEL", 6);
 
@@ -244,7 +244,7 @@ static bool printImageSixel(FFinstance* instance, FFLogoRequestData* requestData
     result.chars = (char*) blob;
     result.length = (uint32_t) length;
 
-    printImagePixels(instance, requestData, &result, FF_CACHE_FILE_SIXEL);
+    printImagePixels(requestData, &result, FF_CACHE_FILE_SIXEL);
 
     free(blob);
     return true;
@@ -267,7 +267,7 @@ static void appendKittyChunk(FFstrbuf* result, const char** blob, size_t* length
     *blob += chunkSize;
 }
 
-static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+static bool printImageKitty(FFLogoRequestData* requestData, const ImageData* imageData)
 {
     imageData->ffCopyMagickString(imageData->imageInfo->magick, "RGBA", 5);
 
@@ -277,7 +277,7 @@ static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData
         return false;
 
     #ifdef FF_HAVE_ZLIB
-        bool isCompressed = compressBlob(instance, &blob, &length);
+        bool isCompressed = compressBlob(&blob, &length);
     #else
         bool isCompressed = false;
     #endif
@@ -299,7 +299,7 @@ static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData
     while(remainingLength > 0)
         appendKittyChunk(&result, &currentPos, &remainingLength, true);
 
-    printImagePixels(instance, requestData, &result, isCompressed ? FF_CACHE_FILE_KITTY_COMPRESSED : FF_CACHE_FILE_KITTY_UNCOMPRESSED);
+    printImagePixels(requestData, &result, isCompressed ? FF_CACHE_FILE_KITTY_COMPRESSED : FF_CACHE_FILE_KITTY_UNCOMPRESSED);
 
     free(chars);
     return true;
@@ -307,9 +307,9 @@ static bool printImageKitty(FFinstance* instance, FFLogoRequestData* requestData
 
 #ifdef FF_HAVE_CHAFA
 #include <chafa.h>
-static bool printImageChafa(FFinstance* instance, FFLogoRequestData* requestData, const ImageData* imageData)
+static bool printImageChafa(FFLogoRequestData* requestData, const ImageData* imageData)
 {
-    FF_LIBRARY_LOAD(chafa, &instance->config.libChafa, false,
+    FF_LIBRARY_LOAD(chafa, &instance.config.libChafa, false,
         "libchafa" FF_LIBRARY_EXTENSION, 1,
         "libchafa-0" FF_LIBRARY_EXTENSION, -1 // Required for Windows
     )
@@ -333,36 +333,36 @@ static bool printImageChafa(FFinstance* instance, FFLogoRequestData* requestData
 
     ChafaSymbolMap* symbolMap = ffchafa_symbol_map_new();
     GError* error = NULL;
-    if(!ffchafa_symbol_map_apply_selectors(symbolMap, instance->config.logo.chafaSymbols.chars, &error))
+    if(!ffchafa_symbol_map_apply_selectors(symbolMap, instance.config.logo.chafaSymbols.chars, &error))
         fputs(error->message, stderr);
 
     ChafaCanvasConfig* canvasConfig = ffchafa_canvas_config_new();
     ffchafa_canvas_config_set_geometry(canvasConfig, (gint) requestData->logoCharacterWidth, (gint) requestData->logoCharacterHeight);
     ffchafa_canvas_config_set_symbol_map(canvasConfig, symbolMap);
 
-    if(instance->config.logo.chafaFgOnly)
+    if(instance.config.logo.chafaFgOnly)
     {
         FF_LIBRARY_LOAD_SYMBOL_LAZY(chafa, chafa_canvas_config_set_fg_only_enabled);
         if(ffchafa_canvas_config_set_fg_only_enabled)
             ffchafa_canvas_config_set_fg_only_enabled(canvasConfig, true);
     }
-    if(instance->config.logo.chafaCanvasMode < CHAFA_CANVAS_MODE_MAX)
+    if(instance.config.logo.chafaCanvasMode < CHAFA_CANVAS_MODE_MAX)
     {
         FF_LIBRARY_LOAD_SYMBOL_LAZY(chafa, chafa_canvas_config_set_canvas_mode);
         if(ffchafa_canvas_config_set_canvas_mode)
-            ffchafa_canvas_config_set_canvas_mode(canvasConfig, (ChafaCanvasMode) instance->config.logo.chafaCanvasMode);
+            ffchafa_canvas_config_set_canvas_mode(canvasConfig, (ChafaCanvasMode) instance.config.logo.chafaCanvasMode);
     }
-    if(instance->config.logo.chafaColorSpace < CHAFA_COLOR_SPACE_MAX)
+    if(instance.config.logo.chafaColorSpace < CHAFA_COLOR_SPACE_MAX)
     {
         FF_LIBRARY_LOAD_SYMBOL_LAZY(chafa, chafa_canvas_config_set_color_space)
         if(ffchafa_canvas_config_set_color_space)
-            ffchafa_canvas_config_set_color_space(canvasConfig, (ChafaColorSpace) instance->config.logo.chafaColorSpace);
+            ffchafa_canvas_config_set_color_space(canvasConfig, (ChafaColorSpace) instance.config.logo.chafaColorSpace);
     }
-    if(instance->config.logo.chafaDitherMode < CHAFA_DITHER_MODE_MAX)
+    if(instance.config.logo.chafaDitherMode < CHAFA_DITHER_MODE_MAX)
     {
         FF_LIBRARY_LOAD_SYMBOL_LAZY(chafa, chafa_canvas_config_set_dither_mode)
         if(ffchafa_canvas_config_set_dither_mode)
-            ffchafa_canvas_config_set_dither_mode(canvasConfig, (ChafaDitherMode) instance->config.logo.chafaDitherMode);
+            ffchafa_canvas_config_set_dither_mode(canvasConfig, (ChafaDitherMode) instance.config.logo.chafaDitherMode);
     }
 
     ChafaCanvas* canvas = ffchafa_canvas_new(canvasConfig);
@@ -381,7 +381,7 @@ static bool printImageChafa(FFinstance* instance, FFLogoRequestData* requestData
     result.length = (uint32_t) str->len;
     result.chars = str->str;
 
-    ffLogoPrintChars(instance, result.chars, false);
+    ffLogoPrintChars(result.chars, false);
     writeCacheStrbuf(requestData, &result, FF_CACHE_FILE_CHAFA);
 
     // FIXME: These functions must be imported from `libglib` dlls on Windows
@@ -403,7 +403,7 @@ static bool printImageChafa(FFinstance* instance, FFLogoRequestData* requestData
 }
 #endif
 
-FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData* requestData, const FFIMData* imData)
+FFLogoImageResult ffLogoPrintImageImpl(FFLogoRequestData* requestData, const FFIMData* imData)
 {
     FF_LIBRARY_LOAD_SYMBOL(imData->library, MagickCoreGenesis, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
     FF_LIBRARY_LOAD_SYMBOL(imData->library, MagickCoreTerminus, FF_LOGO_IMAGE_RESULT_INIT_ERROR);
@@ -438,7 +438,7 @@ FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData*
     }
 
     //+1, because we need to copy the null byte too
-    imageData.ffCopyMagickString(imageInfoIn->filename, instance->config.logo.source.chars, instance->config.logo.source.length + 1);
+    imageData.ffCopyMagickString(imageInfoIn->filename, instance.config.logo.source.chars, instance.config.logo.source.length + 1);
 
     imageData.image = ffReadImage(imageInfoIn, imageData.exceptionInfo);
     ffDestroyImageInfo(imageInfoIn);
@@ -493,13 +493,13 @@ FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData*
     if(requestData->type == FF_LOGO_TYPE_IMAGE_CHAFA)
     {
         #ifdef FF_HAVE_CHAFA
-            printSuccessful = printImageChafa(instance, requestData, &imageData);
+            printSuccessful = printImageChafa(requestData, &imageData);
         #endif
     }
     else if(requestData->type == FF_LOGO_TYPE_IMAGE_KITTY)
-        printSuccessful = printImageKitty(instance, requestData, &imageData);
+        printSuccessful = printImageKitty(requestData, &imageData);
     else if(requestData->type == FF_LOGO_TYPE_IMAGE_SIXEL)
-        printSuccessful = printImageSixel(instance, requestData, &imageData);
+        printSuccessful = printImageSixel(requestData, &imageData);
 
     ffDestroyImageInfo(imageData.imageInfo);
     ffDestroyImage(imageData.image);
@@ -544,7 +544,7 @@ static uint32_t readCachedUint32(FFLogoRequestData* requestData, const char* cac
     return result;
 }
 
-static bool printCachedChars(FFinstance* instance, FFLogoRequestData* requestData)
+static bool printCachedChars(FFLogoRequestData* requestData)
 {
     FF_STRBUF_AUTO_DESTROY content = ffStrbufCreateA(32768);
 
@@ -554,13 +554,13 @@ static bool printCachedChars(FFinstance* instance, FFLogoRequestData* requestDat
     if(content.length == 0)
         return false;
 
-    ffLogoPrintChars(instance, content.chars, false);
+    ffLogoPrintChars(content.chars, false);
     return true;
 }
 
-static bool printCachedPixel(FFinstance* instance, FFLogoRequestData* requestData)
+static bool printCachedPixel(FFLogoRequestData* requestData)
 {
-    requestData->logoCharacterWidth = instance->config.logo.width;
+    requestData->logoCharacterWidth = instance.config.logo.width;
     if(requestData->logoCharacterWidth == 0)
     {
         requestData->logoCharacterWidth = readCachedUint32(requestData, FF_CACHE_FILE_WIDTH);
@@ -568,7 +568,7 @@ static bool printCachedPixel(FFinstance* instance, FFLogoRequestData* requestDat
             return false;
     }
 
-    requestData->logoCharacterHeight = instance->config.logo.height;
+    requestData->logoCharacterHeight = instance.config.logo.height;
     if(requestData->logoCharacterHeight == 0)
     {
         requestData->logoCharacterHeight = readCachedUint32(requestData, FF_CACHE_FILE_HEIGHT);
@@ -589,8 +589,8 @@ static bool printCachedPixel(FFinstance* instance, FFLogoRequestData* requestDat
     if(fd == -1)
         return false;
 
-    ffPrintCharTimes('\n', instance->config.logo.paddingTop);
-    ffPrintCharTimes(' ', instance->config.logo.paddingLeft);
+    ffPrintCharTimes('\n', instance.config.logo.paddingTop);
+    ffPrintCharTimes(' ', instance.config.logo.paddingLeft);
     fflush(stdout);
 
     char buffer[32768];
@@ -600,21 +600,21 @@ static bool printCachedPixel(FFinstance* instance, FFLogoRequestData* requestDat
 
     close(fd);
 
-    instance->state.logoWidth = requestData->logoCharacterWidth + instance->config.logo.paddingLeft + instance->config.logo.paddingRight;
-    instance->state.logoHeight = requestData->logoCharacterHeight + instance->config.logo.paddingTop;
+    instance.state.logoWidth = requestData->logoCharacterWidth + instance.config.logo.paddingLeft + instance.config.logo.paddingRight;
+    instance.state.logoHeight = requestData->logoCharacterHeight + instance.config.logo.paddingTop;
 
     //Go to upper left corner
     fputs("\033[9999999D", stdout);
-    printf("\033[%uA", instance->state.logoHeight);
+    printf("\033[%uA", instance.state.logoHeight);
     return true;
 }
 
-static bool printCached(FFinstance* instance, FFLogoRequestData* requestData)
+static bool printCached(FFLogoRequestData* requestData)
 {
     if(requestData->type == FF_LOGO_TYPE_IMAGE_CHAFA)
-        return printCachedChars(instance, requestData);
+        return printCachedChars(requestData);
     else
-        return printCachedPixel(instance, requestData);
+        return printCachedPixel(requestData);
 }
 
 static bool getCharacterPixelDimensions(FFLogoRequestData* requestData)
@@ -654,7 +654,7 @@ static bool getCharacterPixelDimensions(FFLogoRequestData* requestData)
     return requestData->characterPixelWidth > 1.0 && requestData->characterPixelHeight > 1.0;
 }
 
-static bool printImageIfExistsSlowPath(FFinstance* instance, FFLogoType type, bool printError)
+static bool printImageIfExistsSlowPath(FFLogoType type, bool printError)
 {
     FFLogoRequestData requestData;
     requestData.type = type;
@@ -662,7 +662,7 @@ static bool printImageIfExistsSlowPath(FFinstance* instance, FFLogoType type, bo
     requestData.characterPixelHeight = 1;
 
     if(
-        (type != FF_LOGO_TYPE_IMAGE_CHAFA || instance->config.logo.width == 0 || instance->config.logo.height == 0) &&
+        (type != FF_LOGO_TYPE_IMAGE_CHAFA || instance.config.logo.width == 0 || instance.config.logo.height == 0) &&
         !getCharacterPixelDimensions(&requestData)
     ) {
         if(printError)
@@ -670,15 +670,15 @@ static bool printImageIfExistsSlowPath(FFinstance* instance, FFLogoType type, bo
         return false;
     }
 
-    requestData.logoPixelWidth = simpleCeil((double) instance->config.logo.width * requestData.characterPixelWidth);
-    requestData.logoPixelHeight = simpleCeil((double) instance->config.logo.height * requestData.characterPixelHeight);
+    requestData.logoPixelWidth = simpleCeil((double) instance.config.logo.width * requestData.characterPixelWidth);
+    requestData.logoPixelHeight = simpleCeil((double) instance.config.logo.height * requestData.characterPixelHeight);
 
     ffStrbufInit(&requestData.cacheDir);
-    ffStrbufAppend(&requestData.cacheDir, &instance->state.platform.cacheDir);
+    ffStrbufAppend(&requestData.cacheDir, &instance.state.platform.cacheDir);
     ffStrbufAppendS(&requestData.cacheDir, "fastfetch/images");
 
     ffStrbufEnsureFree(&requestData.cacheDir, PATH_MAX);
-    if(realpath(instance->config.logo.source.chars, requestData.cacheDir.chars + requestData.cacheDir.length) == NULL)
+    if(realpath(instance.config.logo.source.chars, requestData.cacheDir.chars + requestData.cacheDir.length) == NULL)
     {
         //We can safely return here, because if realpath failed, we surely won't be able to read the file
         ffStrbufDestroy(&requestData.cacheDir);
@@ -694,7 +694,7 @@ static bool printImageIfExistsSlowPath(FFinstance* instance, FFLogoType type, bo
     ffStrbufAppendF(&requestData.cacheDir, "%u", requestData.logoPixelHeight);
     ffStrbufAppendC(&requestData.cacheDir, '/');
 
-    if(!instance->config.recache && printCached(instance, &requestData))
+    if(!instance.config.recache && printCached(&requestData))
     {
         ffStrbufDestroy(&requestData.cacheDir);
         return true;
@@ -703,12 +703,12 @@ static bool printImageIfExistsSlowPath(FFinstance* instance, FFLogoType type, bo
     FFLogoImageResult result = FF_LOGO_IMAGE_RESULT_INIT_ERROR;
 
     #ifdef FF_HAVE_IMAGEMAGICK7
-        result = ffLogoPrintImageIM7(instance, &requestData);
+        result = ffLogoPrintImageIM7(&requestData);
     #endif
 
     #ifdef FF_HAVE_IMAGEMAGICK6
         if(result == FF_LOGO_IMAGE_RESULT_INIT_ERROR)
-            result = ffLogoPrintImageIM6(instance, &requestData);
+            result = ffLogoPrintImageIM6(&requestData);
     #endif
 
     ffStrbufDestroy(&requestData.cacheDir);
@@ -729,25 +729,25 @@ static bool printImageIfExistsSlowPath(FFinstance* instance, FFLogoType type, bo
 
 #endif //FF_HAVE_IMAGEMAGICK{6, 7}
 
-bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type, bool printError)
+bool ffLogoPrintImageIfExists(FFLogoType type, bool printError)
 {
-    if(!ffPathExists(instance->config.logo.source.chars, FF_PATHTYPE_FILE))
+    if(!ffPathExists(instance.config.logo.source.chars, FF_PATHTYPE_FILE))
     {
         if(printError)
-            fprintf(stderr, "Logo: Image source \"%s\" does not exist\n", instance->config.logo.source.chars);
+            fprintf(stderr, "Logo: Image source \"%s\" does not exist\n", instance.config.logo.source.chars);
         return false;
     }
 
     if(type == FF_LOGO_TYPE_IMAGE_ITERM)
-        return printImageIterm(instance);
+        return printImageIterm();
 
     if(
         type == FF_LOGO_TYPE_IMAGE_KITTY &&
-        ffStrbufEndsWithIgnCaseS(&instance->config.logo.source, ".png") &&
-        instance->config.logo.width &&
-        instance->config.logo.height
+        ffStrbufEndsWithIgnCaseS(&instance.config.logo.source, ".png") &&
+        instance.config.logo.width &&
+        instance.config.logo.height
     )
-        return printImageKittyDirect(instance);
+        return printImageKittyDirect();
 
     #if !defined(FF_HAVE_CHAFA)
         if(type == FF_LOGO_TYPE_IMAGE_CHAFA)
@@ -763,6 +763,6 @@ bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type, bool printE
             fputs("Logo: Image Magick support is not compiled in\n", stderr);
         return false;
     #else
-        return printImageIfExistsSlowPath(instance, type, printError);
+        return printImageIfExistsSlowPath(type, printError);
     #endif
 }
diff --git a/src/logo/image/image.h b/src/logo/image/image.h
index 83d77131a..7d54edd8a 100644
--- a/src/logo/image/image.h
+++ b/src/logo/image/image.h
@@ -35,17 +35,17 @@ typedef struct FFIMData
     void*(*resizeFunc)(const void* image, size_t width, size_t height, void* exceptionInfo);
 } FFIMData;
 
-FFLogoImageResult ffLogoPrintImageImpl(FFinstance* instance, FFLogoRequestData* requestData, const FFIMData* imData);
+FFLogoImageResult ffLogoPrintImageImpl(FFLogoRequestData* requestData, const FFIMData* imData);
 
 #endif
 
 #ifdef FF_HAVE_IMAGEMAGICK7
-FFLogoImageResult ffLogoPrintImageIM7(FFinstance* instance, FFLogoRequestData* requestData);
+FFLogoImageResult ffLogoPrintImageIM7(FFLogoRequestData* requestData);
 #endif
 
 #ifdef FF_HAVE_IMAGEMAGICK6
 #include <math.h>
-FFLogoImageResult ffLogoPrintImageIM6(FFinstance* instance, FFLogoRequestData* requestData);
+FFLogoImageResult ffLogoPrintImageIM6(FFLogoRequestData* requestData);
 #endif
 
 #endif
diff --git a/src/logo/logo.c b/src/logo/logo.c
index 2e2e54f8f..17e91b24a 100644
--- a/src/logo/logo.c
+++ b/src/logo/logo.c
@@ -8,21 +8,21 @@
 #include <ctype.h>
 #include <string.h>
 
-static void ffLogoPrintCharsRaw(FFinstance* instance, const char* data, size_t length)
+static void ffLogoPrintCharsRaw(const char* data, size_t length)
 {
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
     fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
     ffPrintCharTimes('\n', options->paddingTop);
     ffPrintCharTimes(' ', options->paddingLeft);
     fwrite(data, length, 1, stdout);
-    instance->state.logoHeight = options->paddingTop + options->height;
-    instance->state.logoWidth = options->paddingLeft + options->width + options->paddingRight;
-    printf("\033[9999999D\n\033[%uA", instance->state.logoHeight);
+    instance.state.logoHeight = options->paddingTop + options->height;
+    instance.state.logoWidth = options->paddingLeft + options->width + options->paddingRight;
+    printf("\033[9999999D\n\033[%uA", instance.state.logoHeight);
 }
 
-void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement)
+void ffLogoPrintChars(const char* data, bool doColorReplacement)
 {
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
 
     uint32_t currentlineLength = 0;
 
@@ -30,7 +30,7 @@ void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplac
     ffPrintCharTimes('\n', options->paddingTop);
     ffPrintCharTimes(' ', options->paddingLeft);
 
-    instance->state.logoHeight = options->paddingTop;
+    instance.state.logoHeight = options->paddingTop;
 
     //Use logoColor[0] as the default color
     if(doColorReplacement)
@@ -52,11 +52,11 @@ void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplac
 
             ffPrintCharTimes(' ', options->paddingLeft);
 
-            if(currentlineLength > instance->state.logoWidth)
-                instance->state.logoWidth = currentlineLength;
+            if(currentlineLength > instance.state.logoWidth)
+                instance.state.logoWidth = currentlineLength;
 
             currentlineLength = 0;
-            ++instance->state.logoHeight;
+            ++instance.state.logoHeight;
             continue;
         }
 
@@ -155,26 +155,26 @@ void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplac
     fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
     //Happens if the last line is the longest
-    if(currentlineLength > instance->state.logoWidth)
-        instance->state.logoWidth = currentlineLength;
+    if(currentlineLength > instance.state.logoWidth)
+        instance.state.logoWidth = currentlineLength;
 
-    instance->state.logoWidth += options->paddingLeft + options->paddingRight;
+    instance.state.logoWidth += options->paddingLeft + options->paddingRight;
 
     //Go to the leftmost position
     fputs("\033[9999999D", stdout);
 
     //If the logo height is > 1, go up the height
-    if(instance->state.logoHeight > 0)
-        printf("\033[%uA", instance->state.logoHeight);
+    if(instance.state.logoHeight > 0)
+        printf("\033[%uA", instance.state.logoHeight);
 }
 
-static void logoApplyColors(FFinstance* instance, const FFlogo* logo)
+static void logoApplyColors(const FFlogo* logo)
 {
-    if(instance->config.colorKeys.length == 0)
-        ffStrbufAppendS(&instance->config.colorKeys, logo->colorKeys);
+    if(instance.config.colorKeys.length == 0)
+        ffStrbufAppendS(&instance.config.colorKeys, logo->colorKeys);
 
-    if(instance->config.colorTitle.length == 0)
-        ffStrbufAppendS(&instance->config.colorTitle, logo->colorTitle);
+    if(instance.config.colorTitle.length == 0)
+        ffStrbufAppendS(&instance.config.colorTitle, logo->colorTitle);
 }
 
 static bool logoHasName(const FFlogo* logo, const char* name)
@@ -208,9 +208,9 @@ static const FFlogo* logoGetBuiltin(const char* name)
     return NULL;
 }
 
-static const FFlogo* logoGetBuiltinDetected(const FFinstance* instance)
+static const FFlogo* logoGetBuiltinDetected(void)
 {
-    const FFOSResult* os = ffDetectOS(instance);
+    const FFOSResult* os = ffDetectOS();
 
     const FFlogo* logo = logoGetBuiltin(os->id.chars);
     if(logo != NULL)
@@ -228,23 +228,23 @@ static const FFlogo* logoGetBuiltinDetected(const FFinstance* instance)
     if(logo != NULL)
         return logo;
 
-    logo = logoGetBuiltin(instance->state.platform.systemName.chars);
+    logo = logoGetBuiltin(instance.state.platform.systemName.chars);
     if(logo != NULL)
         return logo;
 
     return ffLogoBuiltinGetUnknown();
 }
 
-static inline void logoApplyColorsDetected(FFinstance* instance)
+static inline void logoApplyColorsDetected(void)
 {
-    logoApplyColors(instance, logoGetBuiltinDetected(instance));
+    logoApplyColors(logoGetBuiltinDetected());
 }
 
-static void logoPrintStruct(FFinstance* instance, const FFlogo* logo)
+static void logoPrintStruct(const FFlogo* logo)
 {
-    logoApplyColors(instance, logo);
+    logoApplyColors(logo);
 
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
 
     const char** colors = logo->builtinColors;
     for(int i = 0; *colors != NULL && i < FASTFETCH_LOGO_MAX_COLORS; i++, colors++)
@@ -253,21 +253,21 @@ static void logoPrintStruct(FFinstance* instance, const FFlogo* logo)
             ffStrbufAppendS(&options->colors[i], *colors);
     }
 
-    ffLogoPrintChars(instance, logo->data, true);
+    ffLogoPrintChars(logo->data, true);
 }
 
-static void logoPrintNone(FFinstance* instance)
+static void logoPrintNone(void)
 {
-    logoApplyColorsDetected(instance);
-    instance->state.logoHeight = 0;
-    instance->state.logoWidth = 0;
+    logoApplyColorsDetected();
+    instance.state.logoHeight = 0;
+    instance.state.logoWidth = 0;
 }
 
-static bool logoPrintBuiltinIfExists(FFinstance* instance, const char* name)
+static bool logoPrintBuiltinIfExists(const char* name)
 {
     if(strcasecmp(name, "none") == 0)
     {
-        logoPrintNone(instance);
+        logoPrintNone();
         return true;
     }
 
@@ -275,36 +275,36 @@ static bool logoPrintBuiltinIfExists(FFinstance* instance, const char* name)
     if(logo == NULL)
         return false;
 
-    logoPrintStruct(instance, logo);
+    logoPrintStruct(logo);
 
     return true;
 }
 
-static inline void logoPrintDetected(FFinstance* instance)
+static inline void logoPrintDetected(void)
 {
-    logoPrintStruct(instance, logoGetBuiltinDetected(instance));
+    logoPrintStruct(logoGetBuiltinDetected());
 }
 
-static bool logoPrintData(FFinstance* instance, bool doColorReplacement) {
-    FFLogoOptions* options = &instance->config.logo;
+static bool logoPrintData(bool doColorReplacement) {
+    FFLogoOptions* options = &instance.config.logo;
     if(options->source.length == 0)
         return false;
 
-    ffLogoPrintChars(instance, options->source.chars, doColorReplacement);
-    logoApplyColorsDetected(instance);
+    ffLogoPrintChars(options->source.chars, doColorReplacement);
+    logoApplyColorsDetected();
     return true;
 }
 
-static void updateLogoPath(FFinstance* instance)
+static void updateLogoPath(void)
 {
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
 
     if(ffPathExists(options->source.chars, FF_PATHTYPE_FILE))
         return;
 
     FF_STRBUF_AUTO_DESTROY fullPath = ffStrbufCreate();
 
-    FF_LIST_FOR_EACH(FFstrbuf, dataDir, instance->state.platform.dataDirs)
+    FF_LIST_FOR_EACH(FFstrbuf, dataDir, instance.state.platform.dataDirs)
     {
         //We need to copy it, because multiple threads might be using dataDirs at the same time
         ffStrbufSet(&fullPath, dataDir);
@@ -319,9 +319,9 @@ static void updateLogoPath(FFinstance* instance)
     }
 }
 
-static bool logoPrintFileIfExists(FFinstance* instance, bool doColorReplacement, bool raw)
+static bool logoPrintFileIfExists(bool doColorReplacement, bool raw)
 {
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
 
     FF_STRBUF_AUTO_DESTROY content = ffStrbufCreate();
 
@@ -331,50 +331,50 @@ static bool logoPrintFileIfExists(FFinstance* instance, bool doColorReplacement,
         return false;
     }
 
-    logoApplyColorsDetected(instance);
+    logoApplyColorsDetected();
     if(raw)
-        ffLogoPrintCharsRaw(instance, content.chars, content.length);
+        ffLogoPrintCharsRaw(content.chars, content.length);
     else
-        ffLogoPrintChars(instance, content.chars, doColorReplacement);
+        ffLogoPrintChars(content.chars, doColorReplacement);
 
     return true;
 }
 
-static bool logoPrintImageIfExists(FFinstance* instance, FFLogoType logo, bool printError)
+static bool logoPrintImageIfExists(FFLogoType logo, bool printError)
 {
-    if(!ffLogoPrintImageIfExists(instance, logo, printError))
+    if(!ffLogoPrintImageIfExists(logo, printError))
         return false;
 
-    logoApplyColorsDetected(instance);
+    logoApplyColorsDetected();
     return true;
 }
 
-static bool logoTryKnownType(FFinstance* instance)
+static bool logoTryKnownType(void)
 {
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
 
     if(options->type == FF_LOGO_TYPE_NONE)
     {
-        logoApplyColorsDetected(instance);
+        logoApplyColorsDetected();
         return true;
     }
 
     if(options->type == FF_LOGO_TYPE_BUILTIN)
-        return logoPrintBuiltinIfExists(instance, options->source.chars);
+        return logoPrintBuiltinIfExists(options->source.chars);
 
     if(options->type == FF_LOGO_TYPE_DATA)
-        return logoPrintData(instance, true);
+        return logoPrintData(true);
 
     if(options->type == FF_LOGO_TYPE_DATA_RAW)
-        return logoPrintData(instance, false);
+        return logoPrintData(false);
 
-    updateLogoPath(instance); //We sure have a file, resolve relative paths
+    updateLogoPath(); //We sure have a file, resolve relative paths
 
     if(options->type == FF_LOGO_TYPE_FILE)
-        return logoPrintFileIfExists(instance, true, false);
+        return logoPrintFileIfExists(true, false);
 
     if(options->type == FF_LOGO_TYPE_FILE_RAW)
-        return logoPrintFileIfExists(instance, false, false);
+        return logoPrintFileIfExists(false, false);
 
     if(options->type == FF_LOGO_TYPE_IMAGE_RAW)
     {
@@ -384,54 +384,54 @@ static bool logoTryKnownType(FFinstance* instance)
             return false;
         }
 
-        return logoPrintFileIfExists(instance, false, true);
+        return logoPrintFileIfExists(false, true);
     }
 
-    return logoPrintImageIfExists(instance, options->type, true);
+    return logoPrintImageIfExists(options->type, true);
 }
 
-static void logoPrintKnownType(FFinstance* instance)
+static void logoPrintKnownType(void)
 {
-    if(!logoTryKnownType(instance))
-        logoPrintDetected(instance);
+    if(!logoTryKnownType())
+        logoPrintDetected();
 }
 
-void ffLogoPrint(FFinstance* instance)
+void ffLogoPrint(void)
 {
     //In pipe mode, we don't have a logo or padding.
     //We also don't need to set main color, because it won't be printed anyway.
     //So we can return quickly here.
-    if(instance->config.pipe)
+    if(instance.config.pipe)
     {
-        instance->state.logoHeight = 0;
-        instance->state.logoWidth = 0;
+        instance.state.logoHeight = 0;
+        instance.state.logoWidth = 0;
         return;
     }
 
-    const FFLogoOptions* options = &instance->config.logo;
+    const FFLogoOptions* options = &instance.config.logo;
 
     //If the source is not set, we can directly print the detected logo.
     if(options->source.length == 0)
     {
-        logoPrintDetected(instance);
+        logoPrintDetected();
         return;
     }
 
     //If the source and source type is set to something else than auto, always print with the set type.
     if(options->source.length > 0 && options->type != FF_LOGO_TYPE_AUTO)
     {
-        logoPrintKnownType(instance);
+        logoPrintKnownType();
         return;
     }
 
     //If source matches the name of a builtin logo, print it and return.
-    if(logoPrintBuiltinIfExists(instance, options->source.chars))
+    if(logoPrintBuiltinIfExists(options->source.chars))
         return;
 
     //Make sure the logo path is set correctly.
-    updateLogoPath(instance);
+    updateLogoPath();
 
-    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell(instance);
+    const FFTerminalShellResult* terminalShell = ffDetectTerminalShell();
 
     //Terminal emulators that support kitty graphics protocol.
     bool supportsKitty =
@@ -441,48 +441,48 @@ void ffLogoPrint(FFinstance* instance)
         ffStrbufIgnCaseCompS(&terminalShell->terminalProcessName, "wayst") == 0;
 
     //Try to load the logo as an image. If it succeeds, print it and return.
-    if(logoPrintImageIfExists(instance, supportsKitty ? FF_LOGO_TYPE_IMAGE_KITTY : FF_LOGO_TYPE_IMAGE_CHAFA, false))
+    if(logoPrintImageIfExists(supportsKitty ? FF_LOGO_TYPE_IMAGE_KITTY : FF_LOGO_TYPE_IMAGE_CHAFA, false))
         return;
 
     //Try to load the logo as a file. If it succeeds, print it and return.
-    if(logoPrintFileIfExists(instance, true, false))
+    if(logoPrintFileIfExists(true, false))
         return;
 
-    logoPrintDetected(instance);
+    logoPrintDetected();
 }
 
-void ffLogoPrintLine(FFinstance* instance)
+void ffLogoPrintLine(void)
 {
-    if(instance->state.logoWidth > 0)
-        printf("\033[%uC", instance->state.logoWidth);
+    if(instance.state.logoWidth > 0)
+        printf("\033[%uC", instance.state.logoWidth);
 
-    ++instance->state.keysHeight;
+    ++instance.state.keysHeight;
 }
 
-void ffLogoPrintRemaining(FFinstance* instance)
+void ffLogoPrintRemaining(void)
 {
-    while(instance->state.keysHeight <= instance->state.logoHeight)
+    while(instance.state.keysHeight <= instance.state.logoHeight)
     {
-        ffLogoPrintLine(instance);
+        ffLogoPrintLine();
         putchar('\n');
     }
 }
 
-void ffLogoBuiltinPrint(FFinstance* instance)
+void ffLogoBuiltinPrint(void)
 {
     GetLogoMethod* methods = ffLogoBuiltinGetAll();
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
 
     while(*methods != NULL)
     {
         const FFlogo* logo = (*methods)();
         printf("\033[%sm%s:\033[0m\n", logo->builtinColors[0], logo->names[0]);
-        logoPrintStruct(instance, logo);
-        ffLogoPrintRemaining(instance);
+        logoPrintStruct(logo);
+        ffLogoPrintRemaining();
 
         //reset everything
-        instance->state.logoHeight = 0;
-        instance->state.keysHeight = 0;
+        instance.state.logoHeight = 0;
+        instance.state.keysHeight = 0;
         for(uint8_t i = 0; i < FASTFETCH_LOGO_MAX_COLORS; i++)
             ffStrbufClear(&options->colors[i]);
 
@@ -491,7 +491,7 @@ void ffLogoBuiltinPrint(FFinstance* instance)
     }
 }
 
-void ffLogoBuiltinList()
+void ffLogoBuiltinList(void)
 {
     GetLogoMethod* methods = ffLogoBuiltinGetAll();
 
@@ -516,7 +516,7 @@ void ffLogoBuiltinList()
     }
 }
 
-void ffLogoBuiltinListAutocompletion()
+void ffLogoBuiltinListAutocompletion(void)
 {
     GetLogoMethod* methods = ffLogoBuiltinGetAll();
 
diff --git a/src/logo/logo.h b/src/logo/logo.h
index 0bc74ea0e..4c4d42c3f 100644
--- a/src/logo/logo.h
+++ b/src/logo/logo.h
@@ -17,19 +17,19 @@ typedef struct FFlogo
 typedef const FFlogo*(*GetLogoMethod)();
 
 //logo.c
-void ffLogoPrintChars(FFinstance* instance, const char* data, bool doColorReplacement);
+void ffLogoPrintChars(const char* data, bool doColorReplacement);
 
 //builtin.c
 const FFlogo* ffLogoBuiltinGetUnknown();
 GetLogoMethod* ffLogoBuiltinGetAll();
 
 //image/image.c
-bool ffLogoPrintImageIfExists(FFinstance* instance, FFLogoType type, bool printError);
+bool ffLogoPrintImageIfExists(FFLogoType type, bool printError);
 
 //option.c
 void ffInitLogoOptions(FFLogoOptions* options);
 bool ffParseLogoCommandOptions(FFLogoOptions* options, const char* key, const char* value);
 void ffDestroyLogoOptions(FFLogoOptions* options);
-const char* ffParseLogoJsonConfig(FFinstance* instance);
+const char* ffParseLogoJsonConfig();
 
 #endif
diff --git a/src/logo/option.c b/src/logo/option.c
index 7882ad669..5fe22176f 100644
--- a/src/logo/option.c
+++ b/src/logo/option.c
@@ -189,11 +189,11 @@ void ffDestroyLogoOptions(FFLogoOptions* options)
         ffStrbufDestroy(&options->colors[i]);
 }
 
-const char* ffParseLogoJsonConfig(FFinstance* instance)
+const char* ffParseLogoJsonConfig(void)
 {
-    FFLogoOptions* options = &instance->config.logo;
+    FFLogoOptions* options = &instance.config.logo;
 
-    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))
diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c
index d326a1584..297d30d50 100644
--- a/src/modules/battery/battery.c
+++ b/src/modules/battery/battery.c
@@ -7,14 +7,14 @@
 
 #define FF_BATTERY_NUM_FORMAT_ARGS 5
 
-static void printBattery(FFinstance* instance, FFBatteryOptions* options, BatteryResult* result, uint8_t index)
+static void printBattery(FFBatteryOptions* options, BatteryResult* result, uint8_t index)
 {
-    if(instance->config.battery.moduleArgs.outputFormat.length == 0)
+    if(instance.config.battery.moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_BATTERY_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         bool showStatus =
-            !(instance->config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT) &&
+            !(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT) &&
             result->status.length > 0 &&
             ffStrbufIgnCaseCompS(&result->status, "Unknown") != 0;
 
@@ -22,22 +22,22 @@ static void printBattery(FFinstance* instance, FFBatteryOptions* options, Batter
 
         if(result->capacity >= 0)
         {
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
                 if(result->capacity <= 20)
-                    ffAppendPercentBar(instance, &str, (uint8_t)result->capacity, 10, 10, 0);
+                    ffAppendPercentBar(&str, (uint8_t)result->capacity, 10, 10, 0);
                 else if(result->capacity <= 50)
-                    ffAppendPercentBar(instance, &str, (uint8_t)result->capacity, 10, 0, 10);
+                    ffAppendPercentBar(&str, (uint8_t)result->capacity, 10, 0, 10);
                 else
-                    ffAppendPercentBar(instance, &str, (uint8_t)result->capacity, 0, 10, 10);
+                    ffAppendPercentBar(&str, (uint8_t)result->capacity, 0, 10, 10);
             }
 
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
             {
                 if(str.length > 0)
                     ffStrbufAppendC(&str, ' ');
 
-                ffAppendPercentNum(instance, &str, (uint8_t) result->capacity, 51, 21, str.length > 0);
+                ffAppendPercentNum(&str, (uint8_t) result->capacity, 51, 21, str.length > 0);
             }
         }
 
@@ -61,7 +61,7 @@ static void printBattery(FFinstance* instance, FFBatteryOptions* options, Batter
     }
     else
     {
-        ffPrintFormat(instance, FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->technology},
@@ -72,23 +72,23 @@ static void printBattery(FFinstance* instance, FFBatteryOptions* options, Batter
     }
 }
 
-void ffPrintBattery(FFinstance* instance, FFBatteryOptions* options)
+void ffPrintBattery(FFBatteryOptions* options)
 {
     FFlist results;
     ffListInitA(&results, sizeof(BatteryResult), 0);
 
-    const char* error = ffDetectBattery(instance, options, &results);
+    const char* error = ffDetectBattery(options, &results);
 
     if (error)
     {
-        ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
     }
     else
     {
         for(uint8_t i = 0; i < (uint8_t) results.length; i++)
         {
             BatteryResult* result = ffListGet(&results, i);
-            printBattery(instance, options, result, i);
+            printBattery(options, result, i);
 
             ffStrbufDestroy(&result->manufacturer);
             ffStrbufDestroy(&result->modelName);
@@ -96,7 +96,7 @@ void ffPrintBattery(FFinstance* instance, FFBatteryOptions* options)
             ffStrbufDestroy(&result->status);
         }
         if(results.length == 0)
-            ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "No batteries found");
+            ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "No batteries found");
     }
 
     ffListDestroy(&results);
@@ -146,7 +146,7 @@ void ffDestroyBatteryOptions(FFBatteryOptions* options)
     #endif
 }
 
-void ffParseBatteryJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseBatteryJsonObject(yyjson_val* module)
 {
     FFBatteryOptions __attribute__((__cleanup__(ffDestroyBatteryOptions))) options;
     ffInitBatteryOptions(&options);
@@ -178,9 +178,9 @@ void ffParseBatteryJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintBattery(instance, &options);
+    ffPrintBattery(&options);
 }
diff --git a/src/modules/battery/battery.h b/src/modules/battery/battery.h
index d9f39acea..a57a3718c 100644
--- a/src/modules/battery/battery.h
+++ b/src/modules/battery/battery.h
@@ -4,9 +4,9 @@
 
 #define FF_BATTERY_MODULE_NAME "Battery"
 
-void ffPrintBattery(FFinstance* instance, FFBatteryOptions* options);
+void ffPrintBattery(FFBatteryOptions* options);
 
 void ffInitBatteryOptions(FFBatteryOptions* options);
 bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, const char* value);
 void ffDestroyBatteryOptions(FFBatteryOptions* options);
-void ffParseBatteryJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseBatteryJsonObject(yyjson_val* module);
diff --git a/src/modules/bios/bios.c b/src/modules/bios/bios.c
index f24b0ee98..53137c9b3 100644
--- a/src/modules/bios/bios.c
+++ b/src/modules/bios/bios.c
@@ -6,7 +6,7 @@
 
 #define FF_BIOS_NUM_FORMAT_ARGS 4
 
-void ffPrintBios(FFinstance* instance, FFBiosOptions* options)
+void ffPrintBios(FFBiosOptions* options)
 {
     FFBiosResult bios;
     ffStrbufInit(&bios.date);
@@ -18,19 +18,19 @@ void ffPrintBios(FFinstance* instance, FFBiosOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         goto exit;
     }
 
     if(bios.version.length == 0)
     {
-        ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "bios_version is not set.");
+        ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "bios_version is not set.");
         goto exit;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufWriteTo(&bios.version, stdout);
         if (bios.biosRelease.length)
             printf(" (%s)", bios.biosRelease.chars);
@@ -38,7 +38,7 @@ void ffPrintBios(FFinstance* instance, FFBiosOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, FF_BIOS_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, FF_BIOS_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &bios.date},
             {FF_FORMAT_ARG_TYPE_STRBUF, &bios.biosRelease},
             {FF_FORMAT_ARG_TYPE_STRBUF, &bios.vendor},
@@ -74,7 +74,7 @@ void ffDestroyBiosOptions(FFBiosOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBiosJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseBiosJsonObject(yyjson_val* module)
 {
     FFBiosOptions __attribute__((__cleanup__(ffDestroyBiosOptions))) options;
     ffInitBiosOptions(&options);
@@ -92,9 +92,9 @@ void ffParseBiosJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_BIOS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintBios(instance, &options);
+    ffPrintBios(&options);
 }
diff --git a/src/modules/bios/bios.h b/src/modules/bios/bios.h
index ca01b0902..a82606f03 100644
--- a/src/modules/bios/bios.h
+++ b/src/modules/bios/bios.h
@@ -4,8 +4,8 @@
 
 #define FF_BIOS_MODULE_NAME "Bios"
 
-void ffPrintBios(FFinstance* instance, FFBiosOptions* options);
+void ffPrintBios(FFBiosOptions* options);
 void ffInitBiosOptions(FFBiosOptions* options);
 bool ffParseBiosCommandOptions(FFBiosOptions* options, const char* key, const char* value);
 void ffDestroyBiosOptions(FFBiosOptions* options);
-void ffParseBiosJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseBiosJsonObject(yyjson_val* module);
diff --git a/src/modules/bluetooth/bluetooth.c b/src/modules/bluetooth/bluetooth.c
index 9b386f5ab..c41bf3da4 100644
--- a/src/modules/bluetooth/bluetooth.c
+++ b/src/modules/bluetooth/bluetooth.c
@@ -6,11 +6,11 @@
 
 #define FF_BLUETOOTH_NUM_FORMAT_ARGS 4
 
-static void printDevice(FFinstance* instance, FFBluetoothOptions* options, const FFBluetoothDevice* device, uint8_t index)
+static void printDevice(FFBluetoothOptions* options, const FFBluetoothDevice* device, uint8_t index)
 {
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufWriteTo(&device->name, stdout);
 
         if(device->battery > 0)
@@ -20,7 +20,7 @@ static void printDevice(FFinstance* instance, FFBluetoothOptions* options, const
     }
     else
     {
-        ffPrintFormat(instance, FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs, FF_BLUETOOTH_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs, FF_BLUETOOTH_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->address},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->type},
@@ -29,14 +29,14 @@ static void printDevice(FFinstance* instance, FFBluetoothOptions* options, const
     }
 }
 
-void ffPrintBluetooth(FFinstance* instance, FFBluetoothOptions* options)
+void ffPrintBluetooth(FFBluetoothOptions* options)
 {
     FF_LIST_AUTO_DESTROY devices = ffListCreate(sizeof (FFBluetoothDevice));
-    const char* error = ffDetectBluetooth(instance, &devices);
+    const char* error = ffDetectBluetooth(&devices);
 
     if(error)
     {
-        ffPrintError(instance, FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
@@ -52,14 +52,14 @@ void ffPrintBluetooth(FFinstance* instance, FFBluetoothOptions* options)
 
     if(filtered.length == 0)
     {
-        ffPrintError(instance, FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "No bluetooth devices found");
+        ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "No bluetooth devices found");
         return;
     }
 
     for(uint32_t i = 0; i < filtered.length; i++)
     {
         uint8_t index = (uint8_t) (filtered.length == 1 ? 0 : i + 1);
-        printDevice(instance, options, *(FFBluetoothDevice**)ffListGet(&filtered, i), index);
+        printDevice(options, *(FFBluetoothDevice**)ffListGet(&filtered, i), index);
     }
 
     FF_LIST_FOR_EACH(FFBluetoothDevice, device, devices)
@@ -94,7 +94,7 @@ void ffDestroyBluetoothOptions(FFBluetoothOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBluetoothJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseBluetoothJsonObject(yyjson_val* module)
 {
     FFBluetoothOptions __attribute__((__cleanup__(ffDestroyBluetoothOptions))) options;
     ffInitBluetoothOptions(&options);
@@ -118,9 +118,9 @@ void ffParseBluetoothJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_BLUETOOTH_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintBluetooth(instance, &options);
+    ffPrintBluetooth(&options);
 }
diff --git a/src/modules/bluetooth/bluetooth.h b/src/modules/bluetooth/bluetooth.h
index 1834330e5..1a54baf1d 100644
--- a/src/modules/bluetooth/bluetooth.h
+++ b/src/modules/bluetooth/bluetooth.h
@@ -4,8 +4,8 @@
 
 #define FF_BLUETOOTH_MODULE_NAME "Bluetooth"
 
-void ffPrintBluetooth(FFinstance* instance, FFBluetoothOptions* options);
+void ffPrintBluetooth(FFBluetoothOptions* options);
 void ffInitBluetoothOptions(FFBluetoothOptions* options);
 bool ffParseBluetoothCommandOptions(FFBluetoothOptions* options, const char* key, const char* value);
 void ffDestroyBluetoothOptions(FFBluetoothOptions* options);
-void ffParseBluetoothJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseBluetoothJsonObject(yyjson_val* module);
diff --git a/src/modules/board/board.c b/src/modules/board/board.c
index 68802c28e..5c92ef20d 100644
--- a/src/modules/board/board.c
+++ b/src/modules/board/board.c
@@ -6,7 +6,7 @@
 
 #define FF_BOARD_NUM_FORMAT_ARGS 3
 
-void ffPrintBoard(FFinstance* instance, FFBoardOptions* options)
+void ffPrintBoard(FFBoardOptions* options)
 {
     FFBoardResult result;
     ffStrbufInit(&result.name);
@@ -16,19 +16,19 @@ void ffPrintBoard(FFinstance* instance, FFBoardOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         goto exit;
     }
 
     if(result.name.length == 0)
     {
-        ffPrintError(instance, FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "board_name is not set.");
+        ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "board_name is not set.");
         goto exit;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_BOARD_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufWriteTo(&result.name, stdout);
         if (result.version.length)
             printf(" (%s)", result.version.chars);
@@ -36,7 +36,7 @@ void ffPrintBoard(FFinstance* instance, FFBoardOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, FF_BOARD_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, FF_BOARD_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.vendor},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.version},
@@ -70,7 +70,7 @@ void ffDestroyBoardOptions(FFBoardOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBoardJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseBoardJsonObject(yyjson_val* module)
 {
     FFBoardOptions __attribute__((__cleanup__(ffDestroyBoardOptions))) options;
     ffInitBoardOptions(&options);
@@ -88,9 +88,9 @@ void ffParseBoardJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_BOARD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_BOARD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintBoard(instance, &options);
+    ffPrintBoard(&options);
 }
diff --git a/src/modules/board/board.h b/src/modules/board/board.h
index e10c4f61b..112eabbf2 100644
--- a/src/modules/board/board.h
+++ b/src/modules/board/board.h
@@ -4,8 +4,8 @@
 
 #define FF_BOARD_MODULE_NAME "Board"
 
-void ffPrintBoard(FFinstance* instance, FFBoardOptions* options);
+void ffPrintBoard(FFBoardOptions* options);
 void ffInitBoardOptions(FFBoardOptions* options);
 bool ffParseBoardCommandOptions(FFBoardOptions* options, const char* key, const char* value);
 void ffDestroyBoardOptions(FFBoardOptions* options);
-void ffParseBoardJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseBoardJsonObject(yyjson_val* module);
diff --git a/src/modules/break/break.c b/src/modules/break/break.c
index 55b671c19..1dc3c8e0a 100644
--- a/src/modules/break/break.c
+++ b/src/modules/break/break.c
@@ -1,13 +1,13 @@
 #include "common/printing.h"
 #include "modules/break/break.h"
 
-void ffPrintBreak(FFinstance* instance)
+void ffPrintBreak(void)
 {
-    ffLogoPrintLine(instance);
+    ffLogoPrintLine();
     putchar('\n');
 }
 
-void ffParseBreakJsonObject(FFinstance* instance, FF_MAYBE_UNUSED yyjson_val* module)
+void ffParseBreakJsonObject(FF_MAYBE_UNUSED yyjson_val* module)
 {
-    return ffPrintBreak(instance);
+    return ffPrintBreak();
 }
diff --git a/src/modules/break/break.h b/src/modules/break/break.h
index 2c534d341..f87c81d3d 100644
--- a/src/modules/break/break.h
+++ b/src/modules/break/break.h
@@ -4,5 +4,5 @@
 
 #define FF_BREAK_MODULE_NAME "Break"
 
-void ffPrintBreak(FFinstance* instance);
-void ffParseBreakJsonObject(FFinstance* instance, yyjson_val* module);
+void ffPrintBreak();
+void ffParseBreakJsonObject(yyjson_val* module);
diff --git a/src/modules/brightness/brightness.c b/src/modules/brightness/brightness.c
index 32c0ca408..5798b6719 100644
--- a/src/modules/brightness/brightness.c
+++ b/src/modules/brightness/brightness.c
@@ -7,7 +7,7 @@
 
 #define FF_BRIGHTNESS_NUM_FORMAT_ARGS 2
 
-void ffPrintBrightness(FFinstance* instance, FFBrightnessOptions* options)
+void ffPrintBrightness(FFBrightnessOptions* options)
 {
     FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFBrightnessResult));
 
@@ -15,13 +15,13 @@ void ffPrintBrightness(FFinstance* instance, FFBrightnessOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(result.length == 0)
     {
-        ffPrintError(instance, FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "No result is detected.");
+        ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "No result is detected.");
         return;
     }
 
@@ -44,26 +44,26 @@ void ffPrintBrightness(FFinstance* instance, FFBrightnessOptions* options)
 
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, key.chars, 0, NULL, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor);
 
-            if (instance->config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
+            if (instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(instance, &str, (uint8_t) (item->value + 0.5), 0, 10, 10);
+                ffAppendPercentBar(&str, (uint8_t) (item->value + 0.5), 0, 10, 10);
             }
 
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
             {
                 if(str.length > 0)
                     ffStrbufAppendC(&str, ' ');
 
-                ffAppendPercentNum(instance, &str, (uint8_t) (item->value + 0.5), 10, 10, str.length > 0);
+                ffAppendPercentNum(&str, (uint8_t) (item->value + 0.5), 10, 10, str.length > 0);
             }
 
             ffStrbufPutTo(&str, stdout);
         }
         else
         {
-            ffPrintFormatString(instance, key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_BRIGHTNESS_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            ffPrintFormatString(key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_BRIGHTNESS_NUM_FORMAT_ARGS, (FFformatarg[]) {
                 {FF_FORMAT_ARG_TYPE_STRBUF, &item->value},
                 {FF_FORMAT_ARG_TYPE_FLOAT, &item->name}
             });
@@ -95,7 +95,7 @@ void ffDestroyBrightnessOptions(FFBrightnessOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBrightnessJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseBrightnessJsonObject(yyjson_val* module)
 {
     FFBrightnessOptions __attribute__((__cleanup__(ffDestroyBrightnessOptions))) options;
     ffInitBrightnessOptions(&options);
@@ -113,9 +113,9 @@ void ffParseBrightnessJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_BRIGHTNESS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintBrightness(instance, &options);
+    ffPrintBrightness(&options);
 }
diff --git a/src/modules/brightness/brightness.h b/src/modules/brightness/brightness.h
index b4c089424..f9724d65c 100644
--- a/src/modules/brightness/brightness.h
+++ b/src/modules/brightness/brightness.h
@@ -4,8 +4,8 @@
 
 #define FF_BRIGHTNESS_MODULE_NAME "Brightness"
 
-void ffPrintBrightness(FFinstance* instance, FFBrightnessOptions* options);
+void ffPrintBrightness(FFBrightnessOptions* options);
 void ffInitBrightnessOptions(FFBrightnessOptions* options);
 bool ffParseBrightnessCommandOptions(FFBrightnessOptions* options, const char* key, const char* value);
 void ffDestroyBrightnessOptions(FFBrightnessOptions* options);
-void ffParseBrightnessJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseBrightnessJsonObject(yyjson_val* module);
diff --git a/src/modules/chassis/chassis.c b/src/modules/chassis/chassis.c
index 15d6ba959..e229748c8 100644
--- a/src/modules/chassis/chassis.c
+++ b/src/modules/chassis/chassis.c
@@ -6,7 +6,7 @@
 
 #define FF_CHASSIS_NUM_FORMAT_ARGS 3
 
-void ffPrintChassis(FFinstance* instance, FFChassisOptions* options)
+void ffPrintChassis(FFChassisOptions* options)
 {
     FFChassisResult result;
     ffStrbufInit(&result.type);
@@ -17,19 +17,19 @@ void ffPrintChassis(FFinstance* instance, FFChassisOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         goto exit;
     }
 
     if(result.type.length == 0)
     {
-        ffPrintError(instance, FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "chassis_type is not set by O.E.M.");
+        ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "chassis_type is not set by O.E.M.");
         goto exit;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufWriteTo(&result.type, stdout);
         if (result.version.length)
             printf(" (%s)", result.version.chars);
@@ -37,7 +37,7 @@ void ffPrintChassis(FFinstance* instance, FFChassisOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_CHASSIS_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_CHASSIS_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.type},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.vendor},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.version},
@@ -71,7 +71,7 @@ void ffDestroyChassisOptions(FFChassisOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseChassisJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseChassisJsonObject(yyjson_val* module)
 {
     FFChassisOptions __attribute__((__cleanup__(ffDestroyChassisOptions))) options;
     ffInitChassisOptions(&options);
@@ -89,9 +89,9 @@ void ffParseChassisJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_CHASSIS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintChassis(instance, &options);
+    ffPrintChassis(&options);
 }
diff --git a/src/modules/chassis/chassis.h b/src/modules/chassis/chassis.h
index 1a85b2727..0526608da 100644
--- a/src/modules/chassis/chassis.h
+++ b/src/modules/chassis/chassis.h
@@ -4,8 +4,8 @@
 
 #define FF_CHASSIS_MODULE_NAME "Chassis"
 
-void ffPrintChassis(FFinstance* instance, FFChassisOptions* options);
+void ffPrintChassis(FFChassisOptions* options);
 void ffInitChassisOptions(FFChassisOptions* options);
 bool ffParseChassisCommandOptions(FFChassisOptions* options, const char* key, const char* value);
 void ffDestroyChassisOptions(FFChassisOptions* options);
-void ffParseChassisJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseChassisJsonObject(yyjson_val* module);
diff --git a/src/modules/colors/colors.c b/src/modules/colors/colors.c
index 1064f3283..da559b5a3 100644
--- a/src/modules/colors/colors.c
+++ b/src/modules/colors/colors.c
@@ -4,12 +4,12 @@
 #include "modules/colors/colors.h"
 #include "util/stringUtils.h"
 
-void ffPrintColors(FFinstance* instance, FFColorsOptions* options)
+void ffPrintColors(FFColorsOptions* options)
 {
-    if(instance->config.pipe)
+    if(instance.config.pipe)
         return;
 
-    ffLogoPrintLine(instance);
+    ffLogoPrintLine();
 
     if(options->paddingLeft > 0)
         ffPrintCharTimes(' ', options->paddingLeft);
@@ -23,7 +23,7 @@ void ffPrintColors(FFinstance* instance, FFColorsOptions* options)
 
         puts(FASTFETCH_TEXT_MODIFIER_RESET);
 
-        ffLogoPrintLine(instance);
+        ffLogoPrintLine();
 
         if(options->paddingLeft > 0)
             ffPrintCharTimes(' ', options->paddingLeft);
@@ -94,7 +94,7 @@ void ffDestroyColorsOptions(FF_MAYBE_UNUSED FFColorsOptions* options)
 {
 }
 
-void ffParseColorsJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseColorsJsonObject(yyjson_val* module)
 {
     FFColorsOptions __attribute__((__cleanup__(ffDestroyColorsOptions))) options;
     ffInitColorsOptions(&options);
@@ -122,7 +122,7 @@ void ffParseColorsJsonObject(FFinstance* instance, yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintErrorString(instance, FF_COLORS_MODULE_NAME, 0, NULL, NULL, "Invalid %s value: %s", key, error);
+                    ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, NULL, "Invalid %s value: %s", key, error);
                 else
                     options.symbol = (FFColorsSymbol) value;
                 continue;
@@ -134,9 +134,9 @@ void ffParseColorsJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintErrorString(instance, FF_COLORS_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
+            ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintColors(instance, &options);
+    ffPrintColors(&options);
 }
diff --git a/src/modules/colors/colors.h b/src/modules/colors/colors.h
index bcf2c2315..64ebe96c8 100644
--- a/src/modules/colors/colors.h
+++ b/src/modules/colors/colors.h
@@ -4,8 +4,8 @@
 
 #define FF_COLORS_MODULE_NAME "Colors"
 
-void ffPrintColors(FFinstance* instance, FFColorsOptions* options);
+void ffPrintColors(FFColorsOptions* options);
 void ffInitColorsOptions(FFColorsOptions* options);
 void ffDestroyColorsOptions(FFColorsOptions* options);
 bool ffParseColorsCommandOptions(FFColorsOptions* options, const char* key, const char* value);
-void ffParseColorsJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseColorsJsonObject(yyjson_val* module);
diff --git a/src/modules/command/command.c b/src/modules/command/command.c
index d1fe505b4..319aed606 100644
--- a/src/modules/command/command.c
+++ b/src/modules/command/command.c
@@ -4,7 +4,7 @@
 #include "modules/command/command.h"
 #include "util/stringUtils.h"
 
-void ffPrintCommand(FFinstance* instance, FFCommandOptions* options)
+void ffPrintCommand(FFCommandOptions* options)
 {
     FF_STRBUF_AUTO_DESTROY result = ffStrbufCreate();
     const char* error = ffProcessAppendStdOut(&result, (char* const[]){
@@ -20,17 +20,17 @@ void ffPrintCommand(FFinstance* instance, FFCommandOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(!result.length)
     {
-        ffPrintError(instance, FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "No result printed");
+        ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "No result printed");
         return;
     }
 
-    ffPrintLogoAndKey(instance, FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+    ffPrintLogoAndKey(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
     ffStrbufPutTo(&result, stdout);
 }
 
@@ -81,7 +81,7 @@ void ffDestroyCommandOptions(FFCommandOptions* options)
     ffStrbufDestroy(&options->text);
 }
 
-void ffParseCommandJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseCommandJsonObject(yyjson_val* module)
 {
     FFCommandOptions __attribute__((__cleanup__(ffDestroyCommandOptions))) options;
     ffInitCommandOptions(&options);
@@ -111,9 +111,9 @@ void ffParseCommandJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_COMMAND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintCommand(instance, &options);
+    ffPrintCommand(&options);
 }
diff --git a/src/modules/command/command.h b/src/modules/command/command.h
index 63ca643fb..eca179b35 100644
--- a/src/modules/command/command.h
+++ b/src/modules/command/command.h
@@ -4,8 +4,8 @@
 
 #define FF_COMMAND_MODULE_NAME "Command"
 
-void ffPrintCommand(FFinstance* instance, FFCommandOptions* options);
+void ffPrintCommand(FFCommandOptions* options);
 void ffInitCommandOptions(FFCommandOptions* options);
 bool ffParseCommandCommandOptions(FFCommandOptions* options, const char* key, const char* value);
 void ffDestroyCommandOptions(FFCommandOptions* options);
-void ffParseCommandJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseCommandJsonObject(yyjson_val* module);
diff --git a/src/modules/cpu/cpu.c b/src/modules/cpu/cpu.c
index 8c9496fee..f4b41be5c 100644
--- a/src/modules/cpu/cpu.c
+++ b/src/modules/cpu/cpu.c
@@ -6,7 +6,7 @@
 
 #define FF_CPU_NUM_FORMAT_ARGS 8
 
-void ffPrintCPU(FFinstance* instance, FFCPUOptions* options)
+void ffPrintCPU(FFCPUOptions* options)
 {
     FFCPUResult cpu;
     cpu.temperature = FF_CPU_TEMP_UNSET;
@@ -15,21 +15,21 @@ void ffPrintCPU(FFinstance* instance, FFCPUOptions* options)
     ffStrbufInit(&cpu.name);
     ffStrbufInit(&cpu.vendor);
 
-    const char* error = ffDetectCPU(instance, options, &cpu);
+    const char* error = ffDetectCPU(options, &cpu);
 
     if(error)
     {
-        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
     }
     else if(cpu.vendor.length == 0 && cpu.name.length == 0 && cpu.coresOnline <= 1)
     {
-        ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "No CPU detected");
+        ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "No CPU detected");
     }
     else
     {
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, FF_CPU_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(FF_CPU_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
             if(cpu.name.length > 0)
                 ffStrbufWriteTo(&cpu.name, stdout);
@@ -54,7 +54,7 @@ void ffPrintCPU(FFinstance* instance, FFCPUOptions* options)
         }
         else
         {
-            ffPrintFormat(instance, FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
+            ffPrintFormat(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
                 {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.name},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.vendor},
                 {FF_FORMAT_ARG_TYPE_UINT16, &cpu.coresPhysical},
@@ -99,7 +99,7 @@ void ffDestroyCPUOptions(FFCPUOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCPUJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseCPUJsonObject(yyjson_val* module)
 {
     FFCPUOptions __attribute__((__cleanup__(ffDestroyCPUOptions))) options;
     ffInitCPUOptions(&options);
@@ -123,9 +123,9 @@ void ffParseCPUJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_CPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_CPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintCPU(instance, &options);
+    ffPrintCPU(&options);
 }
diff --git a/src/modules/cpu/cpu.h b/src/modules/cpu/cpu.h
index 1a8f32922..731149d5b 100644
--- a/src/modules/cpu/cpu.h
+++ b/src/modules/cpu/cpu.h
@@ -4,8 +4,8 @@
 
 #define FF_CPU_MODULE_NAME "CPU"
 
-void ffPrintCPU(FFinstance* instance, FFCPUOptions* options);
+void ffPrintCPU(FFCPUOptions* options);
 void ffInitCPUOptions(FFCPUOptions* options);
 bool ffParseCPUCommandOptions(FFCPUOptions* options, const char* key, const char* value);
 void ffDestroyCPUOptions(FFCPUOptions* options);
-void ffParseCPUJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseCPUJsonObject(yyjson_val* module);
diff --git a/src/modules/cpuusage/cpuusage.c b/src/modules/cpuusage/cpuusage.c
index 0e2e04608..32f24a462 100644
--- a/src/modules/cpuusage/cpuusage.c
+++ b/src/modules/cpuusage/cpuusage.c
@@ -8,35 +8,35 @@
 #define FF_CPUUSAGE_DISPLAY_NAME "CPU Usage"
 #define FF_CPUUSAGE_NUM_FORMAT_ARGS 1
 
-void ffPrintCPUUsage(FFinstance* instance, FFCPUUsageOptions* options)
+void ffPrintCPUUsage(FFCPUUsageOptions* options)
 {
     double percentage = 0.0/0.0;
     const char* error = ffGetCpuUsageResult(&percentage);
 
     if(error)
     {
-        ffPrintError(instance, FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate();
-        if(instance->config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
-            ffAppendPercentBar(instance, &str, (uint8_t)percentage, 0, 5, 8);
-        if(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
+        if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
+            ffAppendPercentBar(&str, (uint8_t)percentage, 0, 5, 8);
+        if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
         {
             if(str.length > 0)
                 ffStrbufAppendC(&str, ' ');
-            ffAppendPercentNum(instance, &str, (uint8_t) percentage, 50, 80, str.length > 0);
+            ffAppendPercentNum(&str, (uint8_t) percentage, 50, 80, str.length > 0);
         }
         ffStrbufPutTo(&str, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, FF_CPUUSAGE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, FF_CPUUSAGE_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_DOUBLE, &percentage}
         });
     }
@@ -63,7 +63,7 @@ void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCPUUsageJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseCPUUsageJsonObject(yyjson_val* module)
 {
     FFCPUUsageOptions __attribute__((__cleanup__(ffDestroyCPUUsageOptions))) options;
     ffInitCPUUsageOptions(&options);
@@ -81,9 +81,9 @@ void ffParseCPUUsageJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_CPUUSAGE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintCPUUsage(instance, &options);
+    ffPrintCPUUsage(&options);
 }
diff --git a/src/modules/cpuusage/cpuusage.h b/src/modules/cpuusage/cpuusage.h
index bd12de8a6..e0275a5ea 100644
--- a/src/modules/cpuusage/cpuusage.h
+++ b/src/modules/cpuusage/cpuusage.h
@@ -6,8 +6,8 @@
 
 void ffPrepareCPUUsage();
 
-void ffPrintCPUUsage(FFinstance* instance, FFCPUUsageOptions* options);
+void ffPrintCPUUsage(FFCPUUsageOptions* options);
 void ffInitCPUUsageOptions(FFCPUUsageOptions* options);
 bool ffParseCPUUsageCommandOptions(FFCPUUsageOptions* options, const char* key, const char* value);
 void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options);
-void ffParseCPUUsageJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseCPUUsageJsonObject(yyjson_val* module);
diff --git a/src/modules/cursor/cursor.c b/src/modules/cursor/cursor.c
index b55934273..06a8d3d91 100644
--- a/src/modules/cursor/cursor.c
+++ b/src/modules/cursor/cursor.c
@@ -6,17 +6,17 @@
 
 #define FF_CURSOR_NUM_FORMAT_ARGS 2
 
-void ffPrintCursor(FFinstance* instance, FFCursorOptions* options)
+void ffPrintCursor(FFCursorOptions* options)
 {
     FFCursorResult result;
     ffStrbufInit(&result.error);
     ffStrbufInit(&result.theme);
     ffStrbufInit(&result.size);
 
-    ffDetectCursor(instance, &result);
+    ffDetectCursor(&result);
 
     if(result.error.length)
-        ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "%s", result.error.chars);
+        ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "%s", result.error.chars);
     else
     {
         ffStrbufRemoveIgnCaseEndS(&result.theme, "cursors");
@@ -28,7 +28,7 @@ void ffPrintCursor(FFinstance* instance, FFCursorOptions* options)
 
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
             ffStrbufWriteTo(&result.theme, stdout);
 
             if(result.size.length > 0)
@@ -38,7 +38,7 @@ void ffPrintCursor(FFinstance* instance, FFCursorOptions* options)
         }
         else
         {
-            ffPrintFormat(instance, FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_CURSOR_NUM_FORMAT_ARGS, (FFformatarg[]){
+            ffPrintFormat(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_CURSOR_NUM_FORMAT_ARGS, (FFformatarg[]){
                 {FF_FORMAT_ARG_TYPE_STRBUF, &result.theme},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &result.size}
             });
@@ -71,7 +71,7 @@ void ffDestroyCursorOptions(FFCursorOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCursorJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseCursorJsonObject(yyjson_val* module)
 {
     FFCursorOptions __attribute__((__cleanup__(ffDestroyCursorOptions))) options;
     ffInitCursorOptions(&options);
@@ -89,9 +89,9 @@ void ffParseCursorJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_CURSOR_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintCursor(instance, &options);
+    ffPrintCursor(&options);
 }
diff --git a/src/modules/cursor/cursor.h b/src/modules/cursor/cursor.h
index f36975aa7..5c23741a2 100644
--- a/src/modules/cursor/cursor.h
+++ b/src/modules/cursor/cursor.h
@@ -4,8 +4,8 @@
 
 #define FF_CURSOR_MODULE_NAME "Cursor"
 
-void ffPrintCursor(FFinstance* instance, FFCursorOptions* options);
+void ffPrintCursor(FFCursorOptions* options);
 void ffInitCursorOptions(FFCursorOptions* options);
 bool ffParseCursorCommandOptions(FFCursorOptions* options, const char* key, const char* value);
 void ffDestroyCursorOptions(FFCursorOptions* options);
-void ffParseCursorJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseCursorJsonObject(yyjson_val* module);
diff --git a/src/modules/custom/custom.c b/src/modules/custom/custom.c
index c461a5530..64ab00579 100644
--- a/src/modules/custom/custom.c
+++ b/src/modules/custom/custom.c
@@ -4,15 +4,15 @@
 #include "util/textModifier.h"
 #include "util/stringUtils.h"
 
-void ffPrintCustom(FFinstance* instance, FFCustomOptions* options)
+void ffPrintCustom(FFCustomOptions* options)
 {
     if (options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintError(instance, FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "output format must be set for custom module");
+        ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "output format must be set for custom module");
         return;
     }
 
-    ffPrintLogoAndKey(instance, options->moduleArgs.key.length == 0 ? NULL : FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+    ffPrintLogoAndKey(options->moduleArgs.key.length == 0 ? NULL : FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
     ffPrintUserString(options->moduleArgs.outputFormat.chars);
     puts(FASTFETCH_TEXT_MODIFIER_RESET);
 }
@@ -38,7 +38,7 @@ void ffDestroyCustomOptions(FFCustomOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCustomJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseCustomJsonObject(yyjson_val* module)
 {
     FFCustomOptions __attribute__((__cleanup__(ffDestroyCustomOptions))) options;
     ffInitCustomOptions(&options);
@@ -56,9 +56,9 @@ void ffParseCustomJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_CUSTOM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintCustom(instance, &options);
+    ffPrintCustom(&options);
 }
diff --git a/src/modules/custom/custom.h b/src/modules/custom/custom.h
index fec8099b3..6d1981d7c 100644
--- a/src/modules/custom/custom.h
+++ b/src/modules/custom/custom.h
@@ -4,8 +4,8 @@
 
 #define FF_CUSTOM_MODULE_NAME "Custom"
 
-void ffPrintCustom(FFinstance* instance, FFCustomOptions* options);
+void ffPrintCustom(FFCustomOptions* options);
 void ffInitCustomOptions(FFCustomOptions* options);
 bool ffParseCustomCommandOptions(FFCustomOptions* options, const char* key, const char* value);
 void ffDestroyCustomOptions(FFCustomOptions* options);
-void ffParseCustomJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseCustomJsonObject(yyjson_val* module);
diff --git a/src/modules/datetime/datetime.c b/src/modules/datetime/datetime.c
index 049102f70..12134c178 100644
--- a/src/modules/datetime/datetime.c
+++ b/src/modules/datetime/datetime.c
@@ -7,10 +7,10 @@
 #define FF_DATETIME_DISPLAY_NAME "Date & Time"
 #define FF_DATETIME_NUM_FORMAT_ARGS 20
 
-void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const FFModuleArgs* moduleArgs)
+void ffPrintDateTimeFormat(const char* moduleName, const FFModuleArgs* moduleArgs)
 {
-    const FFDateTimeResult* result = ffDetectDateTime(instance);
-    ffPrintFormat(instance, moduleName, 0, moduleArgs, FF_DATETIME_NUM_FORMAT_ARGS, (FFformatarg[]) {
+    const FFDateTimeResult* result = ffDetectDateTime();
+    ffPrintFormat(moduleName, 0, moduleArgs, FF_DATETIME_NUM_FORMAT_ARGS, (FFformatarg[]) {
         {FF_FORMAT_ARG_TYPE_UINT16, &result->year}, // 1
         {FF_FORMAT_ARG_TYPE_UINT8, &result->yearShort}, // 2
         {FF_FORMAT_ARG_TYPE_UINT8, &result->month}, // 3
@@ -34,16 +34,16 @@ void ffPrintDateTimeFormat(FFinstance* instance, const char* moduleName, const F
     });
 }
 
-void ffPrintDateTime(FFinstance* instance, FFDateTimeOptions* options)
+void ffPrintDateTime(FFDateTimeOptions* options)
 {
     if(options->moduleArgs.outputFormat.length > 0)
     {
-        ffPrintDateTimeFormat(instance, FF_DATETIME_DISPLAY_NAME, &options->moduleArgs);
+        ffPrintDateTimeFormat(FF_DATETIME_DISPLAY_NAME, &options->moduleArgs);
         return;
     }
 
-    const FFDateTimeResult* datetime = ffDetectDateTime(instance);
-    ffPrintLogoAndKey(instance, FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+    const FFDateTimeResult* datetime = ffDetectDateTime();
+    ffPrintLogoAndKey(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
     //yyyy-MM-dd HH:mm:ss
     printf("%u-%s-%02u %s:%s:%s\n", datetime->year, datetime->monthPretty.chars, datetime->dayInMonth, datetime->hourPretty.chars, datetime->minutePretty.chars, datetime->secondPretty.chars);
@@ -70,7 +70,7 @@ void ffDestroyDateTimeOptions(FFDateTimeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDateTimeJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseDateTimeJsonObject(yyjson_val* module)
 {
     FFDateTimeOptions __attribute__((__cleanup__(ffDestroyDateTimeOptions))) options;
     ffInitDateTimeOptions(&options);
@@ -88,9 +88,9 @@ void ffParseDateTimeJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_DATETIME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintDateTime(instance, &options);
+    ffPrintDateTime(&options);
 }
diff --git a/src/modules/datetime/datetime.h b/src/modules/datetime/datetime.h
index 01b67701b..269343711 100644
--- a/src/modules/datetime/datetime.h
+++ b/src/modules/datetime/datetime.h
@@ -4,8 +4,8 @@
 
 #define FF_DATETIME_MODULE_NAME "DateTime"
 
-void ffPrintDateTime(FFinstance* instance, FFDateTimeOptions* options);
+void ffPrintDateTime(FFDateTimeOptions* options);
 void ffInitDateTimeOptions(FFDateTimeOptions* options);
 bool ffParseDateTimeCommandOptions(FFDateTimeOptions* options, const char* key, const char* value);
 void ffDestroyDateTimeOptions(FFDateTimeOptions* options);
-void ffParseDateTimeJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseDateTimeJsonObject(yyjson_val* module);
diff --git a/src/modules/de/de.c b/src/modules/de/de.c
index 3ae6105fd..a32e6dc01 100644
--- a/src/modules/de/de.c
+++ b/src/modules/de/de.c
@@ -6,19 +6,19 @@
 
 #define FF_DE_NUM_FORMAT_ARGS 3
 
-void ffPrintDE(FFinstance* instance, FFDEOptions* options)
+void ffPrintDE(FFDEOptions* options)
 {
-    const FFDisplayServerResult* result = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* result = ffConnectDisplayServer();
 
     if(result->dePrettyName.length == 0)
     {
-        ffPrintError(instance, FF_DE_MODULE_NAME, 0, &options->moduleArgs, "No DE found");
+        ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, "No DE found");
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_DE_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_DE_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         ffStrbufWriteTo(&result->dePrettyName, stdout);
 
@@ -32,7 +32,7 @@ void ffPrintDE(FFinstance* instance, FFDEOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_DE_MODULE_NAME, 0, &options->moduleArgs, FF_DE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_DE_MODULE_NAME, 0, &options->moduleArgs, FF_DE_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->deProcessName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->dePrettyName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->deVersion}
@@ -61,7 +61,7 @@ void ffDestroyDEOptions(FFDEOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDEJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseDEJsonObject(yyjson_val* module)
 {
     FFDEOptions __attribute__((__cleanup__(ffDestroyDEOptions))) options;
     ffInitDEOptions(&options);
@@ -79,9 +79,9 @@ void ffParseDEJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_DE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_DE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintDE(instance, &options);
+    ffPrintDE(&options);
 }
diff --git a/src/modules/de/de.h b/src/modules/de/de.h
index 3d7d6f729..267665584 100644
--- a/src/modules/de/de.h
+++ b/src/modules/de/de.h
@@ -4,8 +4,8 @@
 
 #define FF_DE_MODULE_NAME "DE"
 
-void ffPrintDE(FFinstance* instance, FFDEOptions* options);
+void ffPrintDE(FFDEOptions* options);
 void ffInitDEOptions(FFDEOptions* options);
 bool ffParseDECommandOptions(FFDEOptions* options, const char* key, const char* value);
 void ffDestroyDEOptions(FFDEOptions* options);
-void ffParseDEJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseDEJsonObject(yyjson_val* module);
diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c
index f94555b81..ca3e91ce7 100644
--- a/src/modules/disk/disk.c
+++ b/src/modules/disk/disk.c
@@ -9,7 +9,7 @@
 #define FF_DISK_NUM_FORMAT_ARGS 10
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 
-static void printDisk(FFinstance* instance, FFDiskOptions* options, const FFDisk* disk)
+static void printDisk(FFDiskOptions* options, const FFDisk* disk)
 {
     FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate();
 
@@ -25,40 +25,40 @@ static void printDisk(FFinstance* instance, FFDiskOptions* options, const FFDisk
     }
 
     FF_STRBUF_AUTO_DESTROY usedPretty = ffStrbufCreate();
-    ffParseSize(disk->bytesUsed, instance->config.binaryPrefixType, &usedPretty);
+    ffParseSize(disk->bytesUsed, instance.config.binaryPrefixType, &usedPretty);
 
     FF_STRBUF_AUTO_DESTROY totalPretty = ffStrbufCreate();
-    ffParseSize(disk->bytesTotal, instance->config.binaryPrefixType, &totalPretty);
+    ffParseSize(disk->bytesTotal, instance.config.binaryPrefixType, &totalPretty);
 
     uint8_t bytesPercentage = disk->bytesTotal > 0 ? (uint8_t) (((long double) disk->bytesUsed / (long double) disk->bytesTotal) * 100.0) : 0;
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, key.chars, 0, NULL, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor);
 
         FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate();
 
         if(disk->bytesTotal > 0)
         {
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(instance, &str, bytesPercentage, 0, 5, 8);
+                ffAppendPercentBar(&str, bytesPercentage, 0, 5, 8);
                 ffStrbufAppendC(&str, ' ');
             }
 
-            if(!(instance->config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
+            if(!(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
                 ffStrbufAppendF(&str, "%s / %s ", usedPretty.chars, totalPretty.chars);
 
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
             {
-                ffAppendPercentNum(instance, &str, (uint8_t) bytesPercentage, 50, 80, str.length > 0);
+                ffAppendPercentNum(&str, (uint8_t) bytesPercentage, 50, 80, str.length > 0);
                 ffStrbufAppendC(&str, ' ');
             }
         }
         else
             ffStrbufAppendS(&str, "Unknown ");
 
-        if(!(instance->config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
+        if(!(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
         {
             if(disk->filesystem.length)
                 ffStrbufAppendF(&str, "- %s ", disk->filesystem.chars);
@@ -80,7 +80,7 @@ static void printDisk(FFinstance* instance, FFDiskOptions* options, const FFDisk
 
         bool isExternal = !!(disk->type & FF_DISK_TYPE_EXTERNAL_BIT);
         bool isHidden = !!(disk->type & FF_DISK_TYPE_HIDDEN_BIT);
-        ffPrintFormatString(instance, key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_DISK_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormatString(key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_DISK_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &usedPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &totalPretty},
             {FF_FORMAT_ARG_TYPE_UINT8, &bytesPercentage},
@@ -95,22 +95,22 @@ static void printDisk(FFinstance* instance, FFDiskOptions* options, const FFDisk
     }
 }
 
-static void printMountpoint(FFinstance* instance, FFDiskOptions* options, const FFlist* disks, const char* mountpoint)
+static void printMountpoint(FFDiskOptions* options, const FFlist* disks, const char* mountpoint)
 {
     for(uint32_t i = disks->length; i > 0; i--)
     {
         FFDisk* disk = ffListGet(disks, i - 1);
         if(strncmp(mountpoint, disk->mountpoint.chars, disk->mountpoint.length) == 0)
         {
-            printDisk(instance, options, disk);
+            printDisk(options, disk);
             return;
         }
     }
 
-    ffPrintError(instance, FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "No disk found for mountpoint: %s", mountpoint);
+    ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "No disk found for mountpoint: %s", mountpoint);
 }
 
-static void printMountpoints(FFinstance* instance, FFDiskOptions* options, const FFlist* disks)
+static void printMountpoints(FFDiskOptions* options, const FFlist* disks)
 {
     #ifdef _WIN32
     const char separator = ';';
@@ -127,38 +127,38 @@ static void printMountpoints(FFinstance* instance, FFDiskOptions* options, const
         uint32_t colonIndex = ffStrbufNextIndexC(&mountpoints, startIndex, separator);
         mountpoints.chars[colonIndex] = '\0';
 
-        printMountpoint(instance, options, disks, mountpoints.chars + startIndex);
+        printMountpoint(options, disks, mountpoints.chars + startIndex);
 
         startIndex = colonIndex + 1;
     }
 }
 
-static void printAutodetected(FFinstance* instance, FFDiskOptions* options, const FFlist* disks)
+static void printAutodetected(FFDiskOptions* options, const FFlist* disks)
 {
     FF_LIST_FOR_EACH(FFDisk, disk, *disks)
     {
         if(!(disk->type & options->showTypes))
             continue;
 
-        printDisk(instance, options, disk);
+        printDisk(options, disk);
     }
 }
 
-void ffPrintDisk(FFinstance* instance, FFDiskOptions* options)
+void ffPrintDisk(FFDiskOptions* options)
 {
     FF_LIST_AUTO_DESTROY disks = ffListCreate(sizeof (FFDisk));
     const char* error = ffDetectDisks(&disks);
 
     if(error)
     {
-        ffPrintError(instance, FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
     }
     else
     {
         if(options->folders.length == 0)
-            printAutodetected(instance, options, &disks);
+            printAutodetected(options, &disks);
         else
-            printMountpoints(instance, options, &disks);
+            printMountpoints(options, &disks);
     }
 
     FF_LIST_FOR_EACH(FFDisk, disk, disks)
@@ -245,7 +245,7 @@ void ffDestroyDiskOptions(FFDiskOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDiskJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseDiskJsonObject(yyjson_val* module)
 {
     FFDiskOptions __attribute__((__cleanup__(ffDestroyDiskOptions))) options;
     ffInitDiskOptions(&options);
@@ -305,9 +305,9 @@ void ffParseDiskJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_DISK_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_DISK_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintDisk(instance, &options);
+    ffPrintDisk(&options);
 }
diff --git a/src/modules/disk/disk.h b/src/modules/disk/disk.h
index 82886a257..aa508df14 100644
--- a/src/modules/disk/disk.h
+++ b/src/modules/disk/disk.h
@@ -4,8 +4,8 @@
 
 #define FF_DISK_MODULE_NAME "Disk"
 
-void ffPrintDisk(FFinstance* instance, FFDiskOptions* options);
+void ffPrintDisk(FFDiskOptions* options);
 void ffInitDiskOptions(FFDiskOptions* options);
 bool ffParseDiskCommandOptions(FFDiskOptions* options, const char* key, const char* value);
 void ffDestroyDiskOptions(FFDiskOptions* options);
-void ffParseDiskJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseDiskJsonObject(yyjson_val* module);
diff --git a/src/modules/display/display.c b/src/modules/display/display.c
index 3688fa069..abf233316 100644
--- a/src/modules/display/display.c
+++ b/src/modules/display/display.c
@@ -6,24 +6,24 @@
 
 #define FF_DISPLAY_NUM_FORMAT_ARGS 8
 
-void ffPrintDisplay(FFinstance* instance, FFDisplayOptions* options)
+void ffPrintDisplay(FFDisplayOptions* options)
 {
     #ifdef __ANDROID__
-        ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &instance->config.display.moduleArgs, "Display detection is not supported on Android");
+        ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &instance.config.display.moduleArgs, "Display detection is not supported on Android");
         return;
     #endif
 
-    const FFDisplayServerResult* dsResult = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* dsResult = ffConnectDisplayServer();
 
     if(dsResult->displays.length == 0)
     {
-        ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &instance->config.display.moduleArgs, "Couldn't detect display");
+        ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &instance.config.display.moduleArgs, "Couldn't detect display");
         return;
     }
 
     if (options->compactType != FF_DISPLAY_COMPACT_TYPE_NONE)
     {
-        ffPrintLogoAndKey(instance, FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         int index = 0;
         FF_LIST_FOR_EACH(FFDisplayResult, result, dsResult->displays)
@@ -72,7 +72,7 @@ void ffPrintDisplay(FFinstance* instance, FFDisplayOptions* options)
                     {FF_FORMAT_ARG_TYPE_STRING, displayType},
                 });
             }
-            ffPrintLogoAndKey(instance, key.chars, 0, NULL, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor);
 
             printf("%ix%i", result->width, result->height);
 
@@ -96,7 +96,7 @@ void ffPrintDisplay(FFinstance* instance, FFDisplayOptions* options)
         }
         else
         {
-            ffPrintFormat(instance, FF_DISPLAY_MODULE_NAME, moduleIndex, &options->moduleArgs, FF_DISPLAY_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            ffPrintFormat(FF_DISPLAY_MODULE_NAME, moduleIndex, &options->moduleArgs, FF_DISPLAY_NUM_FORMAT_ARGS, (FFformatarg[]) {
                 {FF_FORMAT_ARG_TYPE_UINT, &result->width},
                 {FF_FORMAT_ARG_TYPE_UINT, &result->height},
                 {FF_FORMAT_ARG_TYPE_DOUBLE, &result->refreshRate},
@@ -151,7 +151,7 @@ void ffDestroyDisplayOptions(FFDisplayOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDisplayJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseDisplayJsonObject(yyjson_val* module)
 {
     FFDisplayOptions __attribute__((__cleanup__(ffDestroyDisplayOptions))) options;
     ffInitDisplayOptions(&options);
@@ -179,7 +179,7 @@ void ffParseDisplayJsonObject(FFinstance* instance, yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
+                    ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
                 else
                     options.compactType = (FFDisplayCompactType) value;
                 continue;
@@ -191,9 +191,9 @@ void ffParseDisplayJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintDisplay(instance, &options);
+    ffPrintDisplay(&options);
 }
diff --git a/src/modules/display/display.h b/src/modules/display/display.h
index 62a4c210e..66196f063 100644
--- a/src/modules/display/display.h
+++ b/src/modules/display/display.h
@@ -4,8 +4,8 @@
 
 #define FF_DISPLAY_MODULE_NAME "Display"
 
-void ffPrintDisplay(FFinstance* instance, FFDisplayOptions* options);
+void ffPrintDisplay(FFDisplayOptions* options);
 void ffInitDisplayOptions(FFDisplayOptions* options);
 bool ffParseDisplayCommandOptions(FFDisplayOptions* options, const char* key, const char* value);
 void ffDestroyDisplayOptions(FFDisplayOptions* options);
-void ffParseDisplayJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseDisplayJsonObject(yyjson_val* module);
diff --git a/src/modules/font/font.c b/src/modules/font/font.c
index 0d58be3cc..9a8195cd0 100644
--- a/src/modules/font/font.c
+++ b/src/modules/font/font.c
@@ -6,29 +6,29 @@
 
 #define FF_FONT_NUM_FORMAT_ARGS (FF_DETECT_FONT_NUM_FONTS + 1)
 
-void ffPrintFont(FFinstance* instance, FFFontOptions* options)
+void ffPrintFont(FFFontOptions* options)
 {
     FFFontResult font;
     for(uint32_t i = 0; i < FF_DETECT_FONT_NUM_FONTS; ++i)
         ffStrbufInit(&font.fonts[i]);
     ffStrbufInit(&font.display);
 
-    const char* error = ffDetectFont(instance, &font);
+    const char* error = ffDetectFont(&font);
 
     if(error)
     {
-        ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
     }
     else
     {
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, FF_FONT_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(FF_FONT_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
             ffStrbufPutTo(&font.display, stdout);
         }
         else
         {
-            ffPrintFormat(instance, FF_FONT_MODULE_NAME, 0, &options->moduleArgs, FF_FONT_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            ffPrintFormat(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, FF_FONT_NUM_FORMAT_ARGS, (FFformatarg[]) {
                 {FF_FORMAT_ARG_TYPE_STRBUF, &font.fonts[0]},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &font.fonts[1]},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &font.fonts[2]},
@@ -64,7 +64,7 @@ void ffDestroyFontOptions(FFFontOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseFontJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseFontJsonObject(yyjson_val* module)
 {
     FFFontOptions __attribute__((__cleanup__(ffDestroyFontOptions))) options;
     ffInitFontOptions(&options);
@@ -82,9 +82,9 @@ void ffParseFontJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_FONT_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_FONT_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintFont(instance, &options);
+    ffPrintFont(&options);
 }
diff --git a/src/modules/font/font.h b/src/modules/font/font.h
index c26987d29..a4e46f65a 100644
--- a/src/modules/font/font.h
+++ b/src/modules/font/font.h
@@ -4,8 +4,8 @@
 
 #define FF_FONT_MODULE_NAME "Font"
 
-void ffPrintFont(FFinstance* instance, FFFontOptions* options);
+void ffPrintFont(FFFontOptions* options);
 void ffInitFontOptions(FFFontOptions* options);
 bool ffParseFontCommandOptions(FFFontOptions* options, const char* key, const char* value);
 void ffDestroyFontOptions(FFFontOptions* options);
-void ffParseFontJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseFontJsonObject(yyjson_val* module);
diff --git a/src/modules/gamepad/gamepad.c b/src/modules/gamepad/gamepad.c
index 9c228b29b..e5f28704c 100644
--- a/src/modules/gamepad/gamepad.c
+++ b/src/modules/gamepad/gamepad.c
@@ -6,44 +6,44 @@
 
 #define FF_GAMEPAD_NUM_FORMAT_ARGS 2
 
-static void printDevice(FFinstance* instance, FFGamepadOptions* options, const FFGamepadDevice* device, uint8_t index)
+static void printDevice(FFGamepadOptions* options, const FFGamepadDevice* device, uint8_t index)
 {
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&device->name, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs, FF_GAMEPAD_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs, FF_GAMEPAD_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->identifier},
         });
     }
 }
 
-void ffPrintGamepad(FFinstance* instance, FFGamepadOptions* options)
+void ffPrintGamepad(FFGamepadOptions* options)
 {
     FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFGamepadDevice));
 
-    const char* error = ffDetectGamepad(instance, &result);
+    const char* error = ffDetectGamepad(&result);
 
     if(error)
     {
-        ffPrintError(instance, FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(!result.length)
     {
-        ffPrintError(instance, FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "No devices detected");
+        ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "No devices detected");
         return;
     }
 
     uint8_t index = 0;
     FF_LIST_FOR_EACH(FFGamepadDevice, device, result)
     {
-        printDevice(instance, options, device, result.length > 1 ? ++index : 0);
+        printDevice(options, device, result.length > 1 ? ++index : 0);
         ffStrbufDestroy(&device->identifier);
         ffStrbufDestroy(&device->name);
     }
@@ -70,7 +70,7 @@ void ffDestroyGamepadOptions(FFGamepadOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseGamepadJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseGamepadJsonObject(yyjson_val* module)
 {
     FFGamepadOptions __attribute__((__cleanup__(ffDestroyGamepadOptions))) options;
     ffInitGamepadOptions(&options);
@@ -88,9 +88,9 @@ void ffParseGamepadJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_GAMEPAD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintGamepad(instance, &options);
+    ffPrintGamepad(&options);
 }
diff --git a/src/modules/gamepad/gamepad.h b/src/modules/gamepad/gamepad.h
index f08b01937..df81768d7 100644
--- a/src/modules/gamepad/gamepad.h
+++ b/src/modules/gamepad/gamepad.h
@@ -4,8 +4,8 @@
 
 #define FF_GAMEPAD_MODULE_NAME "Gamepad"
 
-void ffPrintGamepad(FFinstance* instance, FFGamepadOptions* options);
+void ffPrintGamepad(FFGamepadOptions* options);
 void ffInitGamepadOptions(FFGamepadOptions* options);
 bool ffParseGamepadCommandOptions(FFGamepadOptions* options, const char* key, const char* value);
 void ffDestroyGamepadOptions(FFGamepadOptions* options);
-void ffParseGamepadJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseGamepadJsonObject(yyjson_val* module);
diff --git a/src/modules/gpu/gpu.c b/src/modules/gpu/gpu.c
index 0fa1170ff..6c34aa82c 100644
--- a/src/modules/gpu/gpu.c
+++ b/src/modules/gpu/gpu.c
@@ -11,11 +11,11 @@
 
 #define FF_GPU_NUM_FORMAT_ARGS 6
 
-static void printGPUResult(FFinstance* instance, FFGPUOptions* options, uint8_t index, const FFGPUResult* gpu)
+static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResult* gpu)
 {
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_GPU_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_GPU_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         FF_STRBUF_AUTO_DESTROY output = ffStrbufCreateA(gpu->vendor.length + 1 + gpu->name.length);
 
@@ -39,14 +39,14 @@ static void printGPUResult(FFinstance* instance, FFGPUOptions* options, uint8_t
 
             if(gpu->dedicated.used != FF_GPU_VMEM_SIZE_UNSET)
             {
-                ffParseSize(gpu->dedicated.used, instance->config.binaryPrefixType, &output);
+                ffParseSize(gpu->dedicated.used, instance.config.binaryPrefixType, &output);
                 ffStrbufAppendS(&output, " / ");
             }
-            ffParseSize(gpu->dedicated.total, instance->config.binaryPrefixType, &output);
+            ffParseSize(gpu->dedicated.total, instance.config.binaryPrefixType, &output);
             if(gpu->dedicated.used != FF_GPU_VMEM_SIZE_UNSET)
             {
                 ffStrbufAppendS(&output, ", ");
-                ffAppendPercentNum(instance, &output, (uint8_t) (gpu->dedicated.used * 100 / gpu->dedicated.total), 50, 80, false);
+                ffAppendPercentNum(&output, (uint8_t) (gpu->dedicated.used * 100 / gpu->dedicated.total), 50, 80, false);
             }
             ffStrbufAppendC(&output, ')');
         }
@@ -63,7 +63,7 @@ static void printGPUResult(FFinstance* instance, FFGPUOptions* options, uint8_t
         else
             type = "Unknown";
 
-        ffPrintFormat(instance, FF_GPU_MODULE_NAME, index, &options->moduleArgs, FF_GPU_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_GPU_MODULE_NAME, index, &options->moduleArgs, FF_GPU_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->vendor},
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->driver},
@@ -74,13 +74,13 @@ static void printGPUResult(FFinstance* instance, FFGPUOptions* options, uint8_t
     }
 }
 
-void ffPrintGPU(FFinstance* instance, FFGPUOptions* options)
+void ffPrintGPU(FFGPUOptions* options)
 {
     FF_LIST_AUTO_DESTROY gpus = ffListCreate(sizeof (FFGPUResult));
-    const char* error = ffDetectGPU(instance, options, &gpus);
+    const char* error = ffDetectGPU(options, &gpus);
     if (error)
     {
-        ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
@@ -99,10 +99,10 @@ void ffPrintGPU(FFinstance* instance, FFGPUOptions* options)
     }
 
     for(uint32_t i = 0; i < selectedGPUs.length; i++)
-        printGPUResult(instance, options, selectedGPUs.length == 1 ? 0 : (uint8_t) (i + 1), * (const FFGPUResult**) ffListGet(&selectedGPUs, i));
+        printGPUResult(options, selectedGPUs.length == 1 ? 0 : (uint8_t) (i + 1), * (const FFGPUResult**) ffListGet(&selectedGPUs, i));
 
     if(selectedGPUs.length == 0)
-        ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "No GPUs found");
+        ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "No GPUs found");
 
     FF_LIST_FOR_EACH(FFGPUResult, gpu, gpus)
     {
@@ -159,7 +159,7 @@ void ffDestroyGPUOptions(FFGPUOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseGPUJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseGPUJsonObject(yyjson_val* module)
 {
     FFGPUOptions __attribute__((__cleanup__(ffDestroyGPUOptions))) options;
     ffInitGPUOptions(&options);
@@ -199,15 +199,15 @@ void ffParseGPUJsonObject(FFinstance* instance, yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
+                    ffPrintError(FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
                 else
                     options.hideType = (FFGPUType) value;
                 continue;
             }
 
-            ffPrintError(instance, FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintGPU(instance, &options);
+    ffPrintGPU(&options);
 }
diff --git a/src/modules/gpu/gpu.h b/src/modules/gpu/gpu.h
index ee8a61826..9462e5fa0 100644
--- a/src/modules/gpu/gpu.h
+++ b/src/modules/gpu/gpu.h
@@ -4,8 +4,8 @@
 
 #define FF_GPU_MODULE_NAME "GPU"
 
-void ffPrintGPU(FFinstance* instance, FFGPUOptions* options);
+void ffPrintGPU(FFGPUOptions* options);
 void ffInitGPUOptions(FFGPUOptions* options);
 bool ffParseGPUCommandOptions(FFGPUOptions* options, const char* key, const char* value);
 void ffDestroyGPUOptions(FFGPUOptions* options);
-void ffParseGPUJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseGPUJsonObject(yyjson_val* module);
diff --git a/src/modules/host/host.c b/src/modules/host/host.c
index a196c2cc7..53526f9ee 100644
--- a/src/modules/host/host.c
+++ b/src/modules/host/host.c
@@ -6,7 +6,7 @@
 
 #define FF_HOST_NUM_FORMAT_ARGS 5
 
-void ffPrintHost(FFinstance* instance, FFHostOptions* options)
+void ffPrintHost(FFHostOptions* options)
 {
     FFHostResult host;
     ffStrbufInit(&host.productFamily);
@@ -18,19 +18,19 @@ void ffPrintHost(FFinstance* instance, FFHostOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         goto exit;
     }
 
     if(host.productFamily.length == 0 && host.productName.length == 0)
     {
-        ffPrintError(instance, FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "neither product_family nor product_name is set by O.E.M.");
+        ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "neither product_family nor product_name is set by O.E.M.");
         goto exit;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_HOST_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_HOST_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         FF_STRBUF_AUTO_DESTROY output = ffStrbufCreate();
 
@@ -48,7 +48,7 @@ void ffPrintHost(FFinstance* instance, FFHostOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_HOST_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_HOST_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &host.productFamily},
             {FF_FORMAT_ARG_TYPE_STRBUF, &host.productName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &host.productVersion},
@@ -86,7 +86,7 @@ void ffDestroyHostOptions(FFHostOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseHostJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseHostJsonObject(yyjson_val* module)
 {
     FFHostOptions __attribute__((__cleanup__(ffDestroyHostOptions))) options;
     ffInitHostOptions(&options);
@@ -104,9 +104,9 @@ void ffParseHostJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_HOST_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_HOST_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintHost(instance, &options);
+    ffPrintHost(&options);
 }
diff --git a/src/modules/host/host.h b/src/modules/host/host.h
index 43d51f3d4..9c9368a27 100644
--- a/src/modules/host/host.h
+++ b/src/modules/host/host.h
@@ -4,8 +4,8 @@
 
 #define FF_HOST_MODULE_NAME "Host"
 
-void ffPrintHost(FFinstance* instance, FFHostOptions* options);
+void ffPrintHost(FFHostOptions* options);
 void ffInitHostOptions(FFHostOptions* options);
 bool ffParseHostCommandOptions(FFHostOptions* options, const char* key, const char* value);
 void ffDestroyHostOptions(FFHostOptions* options);
-void ffParseHostJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseHostJsonObject(yyjson_val* module);
diff --git a/src/modules/icons/icons.c b/src/modules/icons/icons.c
index cd331e89a..e1defe320 100644
--- a/src/modules/icons/icons.c
+++ b/src/modules/icons/icons.c
@@ -6,25 +6,25 @@
 
 #define FF_ICONS_NUM_FORMAT_ARGS 1
 
-void ffPrintIcons(FFinstance* instance, FFIconsOptions* options)
+void ffPrintIcons(FFIconsOptions* options)
 {
     FF_STRBUF_AUTO_DESTROY icons = ffStrbufCreate();
-    const char* error = ffDetectIcons(instance, &icons);
+    const char* error = ffDetectIcons(&icons);
 
     if(error)
     {
-        ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_ICONS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&icons, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, FF_ICONS_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, FF_ICONS_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &icons}
         });
     }
@@ -51,7 +51,7 @@ void ffDestroyIconsOptions(FFIconsOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseIconsJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseIconsJsonObject(yyjson_val* module)
 {
     FFIconsOptions __attribute__((__cleanup__(ffDestroyIconsOptions))) options;
     ffInitIconsOptions(&options);
@@ -69,9 +69,9 @@ void ffParseIconsJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_ICONS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_ICONS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintIcons(instance, &options);
+    ffPrintIcons(&options);
 }
diff --git a/src/modules/icons/icons.h b/src/modules/icons/icons.h
index ea49656f7..3d4bd7e0d 100644
--- a/src/modules/icons/icons.h
+++ b/src/modules/icons/icons.h
@@ -4,8 +4,8 @@
 
 #define FF_ICONS_MODULE_NAME "Icons"
 
-void ffPrintIcons(FFinstance* instance, FFIconsOptions* options);
+void ffPrintIcons(FFIconsOptions* options);
 void ffInitIconsOptions(FFIconsOptions* options);
 bool ffParseIconsCommandOptions(FFIconsOptions* options, const char* key, const char* value);
 void ffDestroyIconsOptions(FFIconsOptions* options);
-void ffParseIconsJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseIconsJsonObject(yyjson_val* module);
diff --git a/src/modules/kernel/kernel.c b/src/modules/kernel/kernel.c
index e62430fe4..8cef1ae06 100644
--- a/src/modules/kernel/kernel.c
+++ b/src/modules/kernel/kernel.c
@@ -5,27 +5,27 @@
 
 #define FF_KERNEL_NUM_FORMAT_ARGS 4
 
-void ffPrintKernel(FFinstance* instance, FFKernelOptions* options)
+void ffPrintKernel(FFKernelOptions* options)
 {
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
-        ffStrbufWriteTo(&instance->state.platform.systemRelease, stdout);
+        ffPrintLogoAndKey(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffStrbufWriteTo(&instance.state.platform.systemRelease, stdout);
 
         #ifdef _WIN32
-            if(instance->state.platform.systemVersion.length > 0)
-                printf(" (%s)", instance->state.platform.systemVersion.chars);
+            if(instance.state.platform.systemVersion.length > 0)
+                printf(" (%s)", instance.state.platform.systemVersion.chars);
         #endif
 
         putchar('\n');
     }
     else
     {
-        ffPrintFormat(instance, FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, FF_KERNEL_NUM_FORMAT_ARGS, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.platform.systemName},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.platform.systemRelease},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.platform.systemVersion},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.platform.systemArchitecture}
+        ffPrintFormat(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, FF_KERNEL_NUM_FORMAT_ARGS, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_STRBUF, &instance.state.platform.systemName},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &instance.state.platform.systemRelease},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &instance.state.platform.systemVersion},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &instance.state.platform.systemArchitecture}
         });
     }
 }
@@ -51,7 +51,7 @@ void ffDestroyKernelOptions(FFKernelOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseKernelJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseKernelJsonObject(yyjson_val* module)
 {
     FFKernelOptions __attribute__((__cleanup__(ffDestroyKernelOptions))) options;
     ffInitKernelOptions(&options);
@@ -69,9 +69,9 @@ void ffParseKernelJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_KERNEL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintKernel(instance, &options);
+    ffPrintKernel(&options);
 }
diff --git a/src/modules/kernel/kernel.h b/src/modules/kernel/kernel.h
index 4e21eb3dd..906a89c11 100644
--- a/src/modules/kernel/kernel.h
+++ b/src/modules/kernel/kernel.h
@@ -4,8 +4,8 @@
 
 #define FF_KERNEL_MODULE_NAME "Kernel"
 
-void ffPrintKernel(FFinstance* instance, FFKernelOptions* options);
+void ffPrintKernel(FFKernelOptions* options);
 void ffInitKernelOptions(FFKernelOptions* options);
 bool ffParseKernelCommandOptions(FFKernelOptions* options, const char* key, const char* value);
 void ffDestroyKernelOptions(FFKernelOptions* options);
-void ffParseKernelJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseKernelJsonObject(yyjson_val* module);
diff --git a/src/modules/lm/lm.c b/src/modules/lm/lm.c
index 5f52baf9d..34e28e6fa 100644
--- a/src/modules/lm/lm.c
+++ b/src/modules/lm/lm.c
@@ -6,7 +6,7 @@
 
 #define FF_LM_NUM_FORMAT_ARGS 2
 
-void ffPrintLM(FFinstance* instance, FFLMOptions* options)
+void ffPrintLM(FFLMOptions* options)
 {
     FFLMResult result;
     ffStrbufInit(&result.service);
@@ -15,19 +15,19 @@ void ffPrintLM(FFinstance* instance, FFLMOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_LM_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(result.service.length == 0)
     {
-        ffPrintError(instance, FF_LM_MODULE_NAME, 0, &options->moduleArgs, "No LM service found");
+        ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "No LM service found");
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_LM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_LM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufWriteTo(&result.service, stdout);
         if(result.type.length)
             printf(" (%s)", result.type.chars);
@@ -35,7 +35,7 @@ void ffPrintLM(FFinstance* instance, FFLMOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_LM_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_LM_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.service},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.type},
         });
@@ -65,7 +65,7 @@ void ffDestroyLMOptions(FFLMOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseLMJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseLMJsonObject(yyjson_val* module)
 {
     FFLMOptions __attribute__((__cleanup__(ffDestroyLMOptions))) options;
     ffInitLMOptions(&options);
@@ -83,9 +83,9 @@ void ffParseLMJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_LM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_LM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintLM(instance, &options);
+    ffPrintLM(&options);
 }
diff --git a/src/modules/lm/lm.h b/src/modules/lm/lm.h
index 862f474e0..788405bed 100644
--- a/src/modules/lm/lm.h
+++ b/src/modules/lm/lm.h
@@ -4,8 +4,8 @@
 
 #define FF_LM_MODULE_NAME "LM"
 
-void ffPrintLM(FFinstance* instance, FFLMOptions* options);
+void ffPrintLM(FFLMOptions* options);
 void ffInitLMOptions(FFLMOptions* options);
 bool ffParseLMCommandOptions(FFLMOptions* options, const char* key, const char* value);
 void ffDestroyLMOptions(FFLMOptions* options);
-void ffParseLMJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseLMJsonObject(yyjson_val* module);
diff --git a/src/modules/locale/locale.c b/src/modules/locale/locale.c
index 563fdd5f9..46b4377a4 100644
--- a/src/modules/locale/locale.c
+++ b/src/modules/locale/locale.c
@@ -6,25 +6,25 @@
 
 #define FF_LOCALE_NUM_FORMAT_ARGS 1
 
-void ffPrintLocale(FFinstance* instance, FFLocaleOptions* options)
+void ffPrintLocale(FFLocaleOptions* options)
 {
     FF_STRBUF_AUTO_DESTROY locale = ffStrbufCreate();
 
     ffDetectLocale(&locale);
     if(locale.length == 0)
     {
-        ffPrintError(instance, FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "No locale found");
+        ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "No locale found");
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&locale, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, FF_LOCALE_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &locale}
         });
     }
@@ -51,7 +51,7 @@ void ffDestroyLocaleOptions(FFLocaleOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseLocaleJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseLocaleJsonObject(yyjson_val* module)
 {
     FFLocaleOptions __attribute__((__cleanup__(ffDestroyLocaleOptions))) options;
     ffInitLocaleOptions(&options);
@@ -69,9 +69,9 @@ void ffParseLocaleJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_LOCALE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintLocale(instance, &options);
+    ffPrintLocale(&options);
 }
diff --git a/src/modules/locale/locale.h b/src/modules/locale/locale.h
index 93d3e820c..91e496878 100644
--- a/src/modules/locale/locale.h
+++ b/src/modules/locale/locale.h
@@ -4,8 +4,8 @@
 
 #define FF_LOCALE_MODULE_NAME "Locale"
 
-void ffPrintLocale(FFinstance* instance, FFLocaleOptions* options);
+void ffPrintLocale(FFLocaleOptions* options);
 void ffInitLocaleOptions(FFLocaleOptions* options);
 bool ffParseLocaleCommandOptions(FFLocaleOptions* options, const char* key, const char* value);
 void ffDestroyLocaleOptions(FFLocaleOptions* options);
-void ffParseLocaleJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseLocaleJsonObject(yyjson_val* module);
diff --git a/src/modules/localip/localip.c b/src/modules/localip/localip.c
index e4c95b7e0..a9c76da0d 100644
--- a/src/modules/localip/localip.c
+++ b/src/modules/localip/localip.c
@@ -54,7 +54,7 @@ static void printIp(FFLocalIpResult* ip)
     }
 }
 
-void ffPrintLocalIp(FFinstance* instance, FFLocalIpOptions* options)
+void ffPrintLocalIp(FFLocalIpOptions* options)
 {
     FF_LIST_AUTO_DESTROY results = ffListCreate(sizeof(FFLocalIpResult));
 
@@ -62,13 +62,13 @@ void ffPrintLocalIp(FFinstance* instance, FFLocalIpOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(results.length == 0)
     {
-        ffPrintError(instance, FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs, "Failed to detect any IPs");
+        ffPrintError(FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs, "Failed to detect any IPs");
         return;
     }
 
@@ -76,7 +76,7 @@ void ffPrintLocalIp(FFinstance* instance, FFLocalIpOptions* options)
 
     if (options->showType & FF_LOCALIP_TYPE_COMPACT_BIT)
     {
-        ffPrintLogoAndKey(instance, FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         FF_LIST_FOR_EACH(FFLocalIpResult, ip, results)
         {
@@ -94,13 +94,13 @@ void ffPrintLocalIp(FFinstance* instance, FFLocalIpOptions* options)
             formatKey(options, ip, &key);
             if(options->moduleArgs.outputFormat.length == 0)
             {
-                ffPrintLogoAndKey(instance, key.chars, 0, NULL, &options->moduleArgs.keyColor);
+                ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor);
                 printIp(ip);
                 putchar('\n');
             }
             else
             {
-                ffPrintFormatString(instance, key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_LOCALIP_NUM_FORMAT_ARGS, (FFformatarg[]){
+                ffPrintFormatString(key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_LOCALIP_NUM_FORMAT_ARGS, (FFformatarg[]){
                     {FF_FORMAT_ARG_TYPE_STRBUF, &ip->ipv4},
                     {FF_FORMAT_ARG_TYPE_STRBUF, &ip->ipv6},
                     {FF_FORMAT_ARG_TYPE_STRBUF, &ip->mac},
@@ -195,7 +195,7 @@ void ffDestroyLocalIpOptions(FFLocalIpOptions* options)
     ffStrbufDestroy(&options->namePrefix);
 }
 
-void ffParseLocalIpJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseLocalIpJsonObject(yyjson_val* module)
 {
     FFLocalIpOptions __attribute__((__cleanup__(ffDestroyLocalIpOptions))) options;
     ffInitLocalIpOptions(&options);
@@ -264,9 +264,9 @@ void ffParseLocalIpJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_LOCALIP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_LOCALIP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintLocalIp(instance, &options);
+    ffPrintLocalIp(&options);
 }
diff --git a/src/modules/localip/localip.h b/src/modules/localip/localip.h
index d758f4fab..8d1270c23 100644
--- a/src/modules/localip/localip.h
+++ b/src/modules/localip/localip.h
@@ -4,8 +4,8 @@
 
 #define FF_LOCALIP_MODULE_NAME "LocalIp"
 
-void ffPrintLocalIp(FFinstance* instance, FFLocalIpOptions* options);
+void ffPrintLocalIp(FFLocalIpOptions* options);
 void ffInitLocalIpOptions(FFLocalIpOptions* options);
 bool ffParseLocalIpCommandOptions(FFLocalIpOptions* options, const char* key, const char* value);
 void ffDestroyLocalIpOptions(FFLocalIpOptions* options);
-void ffParseLocalIpJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseLocalIpJsonObject(yyjson_val* module);
diff --git a/src/modules/media/media.c b/src/modules/media/media.c
index ccb9772db..e60b04698 100644
--- a/src/modules/media/media.c
+++ b/src/modules/media/media.c
@@ -43,13 +43,13 @@ static bool artistInSongTitle(const FFstrbuf* song, const FFstrbuf* artist)
     return false;
 }
 
-void ffPrintMedia(FFinstance* instance, FFMediaOptions* options)
+void ffPrintMedia(FFMediaOptions* options)
 {
-    const FFMediaResult* media = ffDetectMedia(instance);
+    const FFMediaResult* media = ffDetectMedia();
 
     if(media->error.length > 0)
     {
-        ffPrintError(instance, FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, "%s", media->error.chars);
+        ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, "%s", media->error.chars);
         return;
     }
 
@@ -80,7 +80,7 @@ void ffPrintMedia(FFinstance* instance, FFMediaOptions* options)
         if(artistInSongTitle(&songPretty, &artistPretty))
             ffStrbufClear(&artistPretty);
 
-        ffPrintLogoAndKey(instance, FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         if(artistPretty.length > 0)
         {
@@ -95,7 +95,7 @@ void ffPrintMedia(FFinstance* instance, FFMediaOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, FF_MEDIA_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, FF_MEDIA_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &songPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->song},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->artist},
@@ -126,7 +126,7 @@ void ffDestroyMediaOptions(FFMediaOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseMediaJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseMediaJsonObject(yyjson_val* module)
 {
     FFMediaOptions __attribute__((__cleanup__(ffDestroyMediaOptions))) options;
     ffInitMediaOptions(&options);
@@ -144,9 +144,9 @@ void ffParseMediaJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_MEDIA_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintMedia(instance, &options);
+    ffPrintMedia(&options);
 }
diff --git a/src/modules/media/media.h b/src/modules/media/media.h
index f35421504..52fb6ba50 100644
--- a/src/modules/media/media.h
+++ b/src/modules/media/media.h
@@ -4,8 +4,8 @@
 
 #define FF_MEDIA_MODULE_NAME "Media"
 
-void ffPrintMedia(FFinstance* instance, FFMediaOptions* options);
+void ffPrintMedia(FFMediaOptions* options);
 void ffInitMediaOptions(FFMediaOptions* options);
 bool ffParseMediaCommandOptions(FFMediaOptions* options, const char* key, const char* value);
 void ffDestroyMediaOptions(FFMediaOptions* options);
-void ffParseMediaJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseMediaJsonObject(yyjson_val* module);
diff --git a/src/modules/memory/memory.c b/src/modules/memory/memory.c
index 127987741..6663d9bc4 100644
--- a/src/modules/memory/memory.c
+++ b/src/modules/memory/memory.c
@@ -8,22 +8,22 @@
 
 #define FF_MEMORY_NUM_FORMAT_ARGS 3
 
-void ffPrintMemory(FFinstance* instance, FFMemoryOptions* options)
+void ffPrintMemory(FFMemoryOptions* options)
 {
     FFMemoryResult storage;
     const char* error = ffDetectMemory(&storage);
 
     if(error)
     {
-        ffPrintError(instance, FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     FF_STRBUF_AUTO_DESTROY usedPretty = ffStrbufCreate();
-    ffParseSize(storage.bytesUsed, instance->config.binaryPrefixType, &usedPretty);
+    ffParseSize(storage.bytesUsed, instance.config.binaryPrefixType, &usedPretty);
 
     FF_STRBUF_AUTO_DESTROY totalPretty = ffStrbufCreate();
-    ffParseSize(storage.bytesTotal, instance->config.binaryPrefixType, &totalPretty);
+    ffParseSize(storage.bytesTotal, instance.config.binaryPrefixType, &totalPretty);
 
     uint8_t percentage = storage.bytesTotal == 0
         ? 0
@@ -31,24 +31,24 @@ void ffPrintMemory(FFinstance* instance, FFMemoryOptions* options)
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         if (storage.bytesTotal == 0)
             puts("Disabled");
         else
         {
             FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate();
 
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(instance, &str, percentage, 0, 5, 8);
+                ffAppendPercentBar(&str, percentage, 0, 5, 8);
                 ffStrbufAppendC(&str, ' ');
             }
 
-            if(!(instance->config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
+            if(!(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
                 ffStrbufAppendF(&str, "%s / %s ", usedPretty.chars, totalPretty.chars);
 
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
-                ffAppendPercentNum(instance, &str, (uint8_t) percentage, 50, 80, str.length > 0);
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
+                ffAppendPercentNum(&str, (uint8_t) percentage, 50, 80, str.length > 0);
 
             ffStrbufTrimRight(&str, ' ');
             ffStrbufPutTo(&str, stdout);
@@ -56,7 +56,7 @@ void ffPrintMemory(FFinstance* instance, FFMemoryOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, FF_MEMORY_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, FF_MEMORY_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &usedPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &totalPretty},
             {FF_FORMAT_ARG_TYPE_UINT8, &percentage},
@@ -85,7 +85,7 @@ void ffDestroyMemoryOptions(FFMemoryOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseMemoryJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseMemoryJsonObject(yyjson_val* module)
 {
     FFMemoryOptions __attribute__((__cleanup__(ffDestroyMemoryOptions))) options;
     ffInitMemoryOptions(&options);
@@ -103,9 +103,9 @@ void ffParseMemoryJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_MEMORY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintMemory(instance, &options);
+    ffPrintMemory(&options);
 }
diff --git a/src/modules/memory/memory.h b/src/modules/memory/memory.h
index c5bf8e733..e63a45e28 100644
--- a/src/modules/memory/memory.h
+++ b/src/modules/memory/memory.h
@@ -4,8 +4,8 @@
 
 #define FF_MEMORY_MODULE_NAME "Memory"
 
-void ffPrintMemory(FFinstance* instance, FFMemoryOptions* options);
+void ffPrintMemory(FFMemoryOptions* options);
 void ffInitMemoryOptions(FFMemoryOptions* options);
 bool ffParseMemoryCommandOptions(FFMemoryOptions* options, const char* key, const char* value);
 void ffDestroyMemoryOptions(FFMemoryOptions* options);
-void ffParseMemoryJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseMemoryJsonObject(yyjson_val* module);
diff --git a/src/modules/opencl/opencl.c b/src/modules/opencl/opencl.c
index bf69739fa..3fd3ce1eb 100644
--- a/src/modules/opencl/opencl.c
+++ b/src/modules/opencl/opencl.c
@@ -6,27 +6,27 @@
 
 #define FF_OPENCL_NUM_FORMAT_ARGS 3
 
-void ffPrintOpenCL(FFinstance* instance, FFOpenCLOptions* options)
+void ffPrintOpenCL(FFOpenCLOptions* options)
 {
     FFOpenCLResult opencl;
     ffStrbufInit(&opencl.version);
     ffStrbufInit(&opencl.device);
     ffStrbufInit(&opencl.vendor);
 
-    const char* error = ffDetectOpenCL(instance, &opencl);
+    const char* error = ffDetectOpenCL(&opencl);
 
     if(error != NULL)
-        ffPrintError(instance, FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
     else
     {
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
             ffStrbufPutTo(&opencl.version, stdout);
         }
         else
         {
-            ffPrintFormat(instance, FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, FF_OPENCL_NUM_FORMAT_ARGS, (FFformatarg[]) {
+            ffPrintFormat(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, FF_OPENCL_NUM_FORMAT_ARGS, (FFformatarg[]) {
                 {FF_FORMAT_ARG_TYPE_STRBUF, &opencl.version},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &opencl.device},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &opencl.vendor},
@@ -60,7 +60,7 @@ void ffDestroyOpenCLOptions(FFOpenCLOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseOpenCLJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseOpenCLJsonObject(yyjson_val* module)
 {
     FFOpenCLOptions __attribute__((__cleanup__(ffDestroyOpenCLOptions))) options;
     ffInitOpenCLOptions(&options);
@@ -78,9 +78,9 @@ void ffParseOpenCLJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_OPENCL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintOpenCL(instance, &options);
+    ffPrintOpenCL(&options);
 }
diff --git a/src/modules/opencl/opencl.h b/src/modules/opencl/opencl.h
index 479e2e231..b01a2a480 100644
--- a/src/modules/opencl/opencl.h
+++ b/src/modules/opencl/opencl.h
@@ -4,8 +4,8 @@
 
 #define FF_OPENCL_MODULE_NAME "OpenCL"
 
-void ffPrintOpenCL(FFinstance* instance, FFOpenCLOptions* options);
+void ffPrintOpenCL(FFOpenCLOptions* options);
 void ffInitOpenCLOptions(FFOpenCLOptions* options);
 bool ffParseOpenCLCommandOptions(FFOpenCLOptions* options, const char* key, const char* value);
 void ffDestroyOpenCLOptions(FFOpenCLOptions* options);
-void ffParseOpenCLJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseOpenCLJsonObject(yyjson_val* module);
diff --git a/src/modules/opengl/opengl.c b/src/modules/opengl/opengl.c
index 730f1f72d..e5f5bc9fc 100644
--- a/src/modules/opengl/opengl.c
+++ b/src/modules/opengl/opengl.c
@@ -6,7 +6,7 @@
 
 #define FF_OPENGL_NUM_FORMAT_ARGS 4
 
-void ffPrintOpenGL(FFinstance* instance, FFOpenGLOptions* options)
+void ffPrintOpenGL(FFOpenGLOptions* options)
 {
     FFOpenGLResult result;
     ffStrbufInit(&result.version);
@@ -14,21 +14,21 @@ void ffPrintOpenGL(FFinstance* instance, FFOpenGLOptions* options)
     ffStrbufInit(&result.vendor);
     ffStrbufInit(&result.slv);
 
-    const char* error = ffDetectOpenGL(instance, &result);
+    const char* error = ffDetectOpenGL(&result);
     if(error)
     {
-        ffPrintError(instance, FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         puts(result.version.chars);
     }
     else
     {
-        ffPrintFormat(instance, FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, FF_OPENGL_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, FF_OPENGL_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.version},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.renderer},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result.vendor},
@@ -80,7 +80,7 @@ void ffDestroyOpenGLOptions(FFOpenGLOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseOpenGLJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseOpenGLJsonObject(yyjson_val* module)
 {
     FFOpenGLOptions __attribute__((__cleanup__(ffDestroyOpenGLOptions))) options;
     ffInitOpenGLOptions(&options);
@@ -110,16 +110,16 @@ void ffParseOpenGLJsonObject(FFinstance* instance, yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(instance, FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
+                    ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
                 else
                     options.library = (FFOpenGLLibrary) value;
                 continue;
             }
             #endif
 
-            ffPrintError(instance, FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintOpenGL(instance, &options);
+    ffPrintOpenGL(&options);
 }
diff --git a/src/modules/opengl/opengl.h b/src/modules/opengl/opengl.h
index a5b88b23d..5d4f1ab88 100644
--- a/src/modules/opengl/opengl.h
+++ b/src/modules/opengl/opengl.h
@@ -4,8 +4,8 @@
 
 #define FF_OPENGL_MODULE_NAME "OpenGL"
 
-void ffPrintOpenGL(FFinstance* instance, FFOpenGLOptions* options);
+void ffPrintOpenGL(FFOpenGLOptions* options);
 void ffInitOpenGLOptions(FFOpenGLOptions* options);
 bool ffParseOpenGLCommandOptions(FFOpenGLOptions* options, const char* key, const char* value);
 void ffDestroyOpenGLOptions(FFOpenGLOptions* options);
-void ffParseOpenGLJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseOpenGLJsonObject(yyjson_val* module);
diff --git a/src/modules/os/os.c b/src/modules/os/os.c
index 6964bed4e..119306742 100644
--- a/src/modules/os/os.c
+++ b/src/modules/os/os.c
@@ -9,7 +9,7 @@
 
 #define FF_OS_NUM_FORMAT_ARGS 12
 
-static void buildOutputDefault(const FFinstance* instance, const FFOSResult* os, FFstrbuf* result)
+static void buildOutputDefault(const FFOSResult* os, FFstrbuf* result)
 {
     //Create the basic output
     if(os->name.length > 0)
@@ -19,7 +19,7 @@ static void buildOutputDefault(const FFinstance* instance, const FFOSResult* os,
     else if(os->id.length > 0)
         ffStrbufAppend(result, &os->id);
     else
-        ffStrbufAppend(result, &instance->state.platform.systemName);
+        ffStrbufAppend(result, &instance.state.platform.systemName);
 
     #ifdef __APPLE__
     if(os->codename.length > 0)
@@ -64,14 +64,14 @@ static void buildOutputDefault(const FFinstance* instance, const FFOSResult* os,
     }
 
     //Append architecture if it is missing
-    if(ffStrbufFirstIndex(result, &instance->state.platform.systemArchitecture) == result->length)
+    if(ffStrbufFirstIndex(result, &instance.state.platform.systemArchitecture) == result->length)
     {
         ffStrbufAppendC(result, ' ');
-        ffStrbufAppend(result, &instance->state.platform.systemArchitecture);
+        ffStrbufAppend(result, &instance.state.platform.systemArchitecture);
     }
 }
 
-static void buildOutputNixOS(const FFinstance* instance, const FFOSResult* os, FFstrbuf* result)
+static void buildOutputNixOS(const FFOSResult* os, FFstrbuf* result)
 {
     ffStrbufAppendS(result, "NixOS");
 
@@ -89,20 +89,20 @@ static void buildOutputNixOS(const FFinstance* instance, const FFOSResult* os, F
         ffStrbufAppendC(result, ')');
     }
 
-    if(instance->state.platform.systemArchitecture.length > 0)
+    if(instance.state.platform.systemArchitecture.length > 0)
     {
         ffStrbufAppendC(result, ' ');
-        ffStrbufAppend(result, &instance->state.platform.systemArchitecture);
+        ffStrbufAppend(result, &instance.state.platform.systemArchitecture);
     }
 }
 
-void ffPrintOS(FFinstance* instance, FFOSOptions* options)
+void ffPrintOS(FFOSOptions* options)
 {
-    const FFOSResult* os = ffDetectOS(instance);
+    const FFOSResult* os = ffDetectOS();
 
     if(os->name.length == 0 && os->prettyName.length == 0 && os->id.length == 0)
     {
-        ffPrintError(instance, FF_OS_MODULE_NAME, 0, &options->moduleArgs, "Could not detect OS");
+        ffPrintError(FF_OS_MODULE_NAME, 0, &options->moduleArgs, "Could not detect OS");
         return;
     }
 
@@ -111,17 +111,17 @@ void ffPrintOS(FFinstance* instance, FFOSOptions* options)
         FF_STRBUF_AUTO_DESTROY result = ffStrbufCreate();
 
         if(ffStrbufIgnCaseCompS(&os->id, "nixos") == 0)
-            buildOutputNixOS(instance, os, &result);
+            buildOutputNixOS(os, &result);
         else
-            buildOutputDefault(instance, os, &result);
+            buildOutputDefault(os, &result);
 
-        ffPrintLogoAndKey(instance, FF_OS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_OS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&result, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_OS_MODULE_NAME, 0, &options->moduleArgs, FF_OS_NUM_FORMAT_ARGS, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.platform.systemName},
+        ffPrintFormat(FF_OS_MODULE_NAME, 0, &options->moduleArgs, FF_OS_NUM_FORMAT_ARGS, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_STRBUF, &instance.state.platform.systemName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &os->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &os->prettyName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &os->id},
@@ -132,7 +132,7 @@ void ffPrintOS(FFinstance* instance, FFOSOptions* options)
             {FF_FORMAT_ARG_TYPE_STRBUF, &os->versionID},
             {FF_FORMAT_ARG_TYPE_STRBUF, &os->codename},
             {FF_FORMAT_ARG_TYPE_STRBUF, &os->buildID},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &instance->state.platform.systemArchitecture}
+            {FF_FORMAT_ARG_TYPE_STRBUF, &instance.state.platform.systemArchitecture}
         });
     }
 }
@@ -158,7 +158,7 @@ void ffDestroyOSOptions(FFOSOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseOSJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseOSJsonObject(yyjson_val* module)
 {
     FFOSOptions __attribute__((__cleanup__(ffDestroyOSOptions))) options;
     ffInitOSOptions(&options);
@@ -176,9 +176,9 @@ void ffParseOSJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_OS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_OS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintOS(instance, &options);
+    ffPrintOS(&options);
 }
diff --git a/src/modules/os/os.h b/src/modules/os/os.h
index 55036fed1..36856d9b1 100644
--- a/src/modules/os/os.h
+++ b/src/modules/os/os.h
@@ -4,8 +4,8 @@
 
 #define FF_OS_MODULE_NAME "OS"
 
-void ffPrintOS(FFinstance* instance, FFOSOptions* options);
+void ffPrintOS(FFOSOptions* options);
 void ffInitOSOptions(FFOSOptions* options);
 bool ffParseOSCommandOptions(FFOSOptions* options, const char* key, const char* value);
 void ffDestroyOSOptions(FFOSOptions* options);
-void ffParseOSJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseOSJsonObject(yyjson_val* module);
diff --git a/src/modules/packages/packages.c b/src/modules/packages/packages.c
index a0269d504..1b3dc7568 100644
--- a/src/modules/packages/packages.c
+++ b/src/modules/packages/packages.c
@@ -6,22 +6,22 @@
 
 #define FF_PACKAGES_NUM_FORMAT_ARGS 21
 
-void ffPrintPackages(FFinstance* instance, FFPackagesOptions* options)
+void ffPrintPackages(FFPackagesOptions* options)
 {
     FFPackagesResult counts = {};
     ffStrbufInit(&counts.pacmanBranch);
 
-    const char* error = ffDetectPackages(instance, &counts);
+    const char* error = ffDetectPackages(&counts);
 
     if(error)
     {
-        ffPrintError(instance, FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         #define FF_PRINT_PACKAGE_NAME(var, name) \
             if(counts.var > 0) \
@@ -66,7 +66,7 @@ void ffPrintPackages(FFinstance* instance, FFPackagesOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, FF_PACKAGES_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, FF_PACKAGES_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_UINT, &counts.all},
             {FF_FORMAT_ARG_TYPE_UINT, &counts.pacman},
             {FF_FORMAT_ARG_TYPE_STRBUF, &counts.pacmanBranch},
@@ -115,7 +115,7 @@ void ffDestroyPackagesOptions(FFPackagesOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParsePackagesJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParsePackagesJsonObject(yyjson_val* module)
 {
     FFPackagesOptions __attribute__((__cleanup__(ffDestroyPackagesOptions))) options;
     ffInitPackagesOptions(&options);
@@ -133,9 +133,9 @@ void ffParsePackagesJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_PACKAGES_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_PACKAGES_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintPackages(instance, &options);
+    ffPrintPackages(&options);
 }
diff --git a/src/modules/packages/packages.h b/src/modules/packages/packages.h
index 8aec1a0fc..87516579a 100644
--- a/src/modules/packages/packages.h
+++ b/src/modules/packages/packages.h
@@ -4,8 +4,8 @@
 
 #define FF_PACKAGES_MODULE_NAME "Packages"
 
-void ffPrintPackages(FFinstance* instance, FFPackagesOptions* options);
+void ffPrintPackages(FFPackagesOptions* options);
 void ffInitPackagesOptions(FFPackagesOptions* options);
 bool ffParsePackagesCommandOptions(FFPackagesOptions* options, const char* key, const char* value);
 void ffDestroyPackagesOptions(FFPackagesOptions* options);
-void ffParsePackagesJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParsePackagesJsonObject(yyjson_val* module);
diff --git a/src/modules/player/player.c b/src/modules/player/player.c
index 56dfb0820..1503a9cad 100644
--- a/src/modules/player/player.c
+++ b/src/modules/player/player.c
@@ -9,13 +9,13 @@
 #define FF_PLAYER_DISPLAY_NAME "Media Player"
 #define FF_PLAYER_NUM_FORMAT_ARGS 4
 
-void ffPrintPlayer(FFinstance* instance, FFPlayerOptions* options)
+void ffPrintPlayer(FFPlayerOptions* options)
 {
-    const FFMediaResult* media = ffDetectMedia(instance);
+    const FFMediaResult* media = ffDetectMedia();
 
     if(media->error.length > 0)
     {
-        ffPrintError(instance, FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs, "%s", media->error.chars);
+        ffPrintError(FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs, "%s", media->error.chars);
         return;
     }
 
@@ -59,12 +59,12 @@ void ffPrintPlayer(FFinstance* instance, FFPlayerOptions* options)
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&playerPretty, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs, FF_PLAYER_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs, FF_PLAYER_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &playerPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->player},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->playerId},
@@ -94,7 +94,7 @@ void ffDestroyPlayerOptions(FFPlayerOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParsePlayerJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParsePlayerJsonObject(yyjson_val* module)
 {
     FFPlayerOptions __attribute__((__cleanup__(ffDestroyPlayerOptions))) options;
     ffInitPlayerOptions(&options);
@@ -112,9 +112,9 @@ void ffParsePlayerJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_PLAYER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_PLAYER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintPlayer(instance, &options);
+    ffPrintPlayer(&options);
 }
diff --git a/src/modules/player/player.h b/src/modules/player/player.h
index 1825d2f9e..6f09b425f 100644
--- a/src/modules/player/player.h
+++ b/src/modules/player/player.h
@@ -5,8 +5,8 @@
 
 #define FF_PLAYER_MODULE_NAME "Player"
 
-void ffPrintPlayer(FFinstance* instance, FFPlayerOptions* options);
+void ffPrintPlayer(FFPlayerOptions* options);
 void ffInitPlayerOptions(FFPlayerOptions* options);
 bool ffParsePlayerCommandOptions(FFPlayerOptions* options, const char* key, const char* value);
 void ffDestroyPlayerOptions(FFPlayerOptions* options);
-void ffParsePlayerJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParsePlayerJsonObject(yyjson_val* module);
diff --git a/src/modules/poweradapter/poweradapter.c b/src/modules/poweradapter/poweradapter.c
index 6fd67d8b6..629a096b1 100644
--- a/src/modules/poweradapter/poweradapter.c
+++ b/src/modules/poweradapter/poweradapter.c
@@ -7,20 +7,20 @@
 #define FF_POWERADAPTER_DISPLAY_NAME "Power Adapter"
 #define FF_POWERADAPTER_MODULE_ARGS 5
 
-void ffPrintPowerAdapter(FFinstance* instance, FFPowerAdapterOptions* options)
+void ffPrintPowerAdapter(FFPowerAdapterOptions* options)
 {
     FFlist results;
     ffListInit(&results, sizeof(PowerAdapterResult));
 
-    const char* error = ffDetectPowerAdapterImpl(instance, &results);
+    const char* error = ffDetectPowerAdapterImpl(&results);
 
     if (error)
     {
-        ffPrintError(instance, FF_POWERADAPTER_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_POWERADAPTER_DISPLAY_NAME, 0, &options->moduleArgs, "%s", error);
     }
     else if(results.length == 0)
     {
-        ffPrintError(instance, FF_POWERADAPTER_DISPLAY_NAME, 0, &options->moduleArgs, "No power adapters found");
+        ffPrintError(FF_POWERADAPTER_DISPLAY_NAME, 0, &options->moduleArgs, "No power adapters found");
     }
     else
     {
@@ -32,7 +32,7 @@ void ffPrintPowerAdapter(FFinstance* instance, FFPowerAdapterOptions* options)
             {
                 if(options->moduleArgs.outputFormat.length == 0)
                 {
-                    ffPrintLogoAndKey(instance, FF_POWERADAPTER_DISPLAY_NAME, i, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+                    ffPrintLogoAndKey(FF_POWERADAPTER_DISPLAY_NAME, i, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
                     if(result->name.length > 0)
                         puts(result->name.chars);
@@ -43,7 +43,7 @@ void ffPrintPowerAdapter(FFinstance* instance, FFPowerAdapterOptions* options)
                 }
                 else
                 {
-                    ffPrintFormat(instance, FF_POWERADAPTER_DISPLAY_NAME, i, &options->moduleArgs, FF_POWERADAPTER_MODULE_ARGS, (FFformatarg[]){
+                    ffPrintFormat(FF_POWERADAPTER_DISPLAY_NAME, i, &options->moduleArgs, FF_POWERADAPTER_MODULE_ARGS, (FFformatarg[]){
                         {FF_FORMAT_ARG_TYPE_INT, &result->watts},
                         {FF_FORMAT_ARG_TYPE_STRBUF, &result->name},
                         {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer},
@@ -84,7 +84,7 @@ void ffDestroyPowerAdapterOptions(FFPowerAdapterOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParsePowerAdapterJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParsePowerAdapterJsonObject(yyjson_val* module)
 {
     FFPowerAdapterOptions __attribute__((__cleanup__(ffDestroyPowerAdapterOptions))) options;
     ffInitPowerAdapterOptions(&options);
@@ -102,9 +102,9 @@ void ffParsePowerAdapterJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_POWERADAPTER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_POWERADAPTER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintPowerAdapter(instance, &options);
+    ffPrintPowerAdapter(&options);
 }
diff --git a/src/modules/poweradapter/poweradapter.h b/src/modules/poweradapter/poweradapter.h
index f8cca4c6c..93c6a7704 100644
--- a/src/modules/poweradapter/poweradapter.h
+++ b/src/modules/poweradapter/poweradapter.h
@@ -4,8 +4,8 @@
 
 #define FF_POWERADAPTER_MODULE_NAME "PowerAdapter"
 
-void ffPrintPowerAdapter(FFinstance* instance, FFPowerAdapterOptions* options);
+void ffPrintPowerAdapter(FFPowerAdapterOptions* options);
 void ffInitPowerAdapterOptions(FFPowerAdapterOptions* options);
 bool ffParsePowerAdapterCommandOptions(FFPowerAdapterOptions* options, const char* key, const char* value);
 void ffDestroyPowerAdapterOptions(FFPowerAdapterOptions* options);
-void ffParsePowerAdapterJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParsePowerAdapterJsonObject(yyjson_val* module);
diff --git a/src/modules/processes/processes.c b/src/modules/processes/processes.c
index 772994887..bc5cf63b9 100644
--- a/src/modules/processes/processes.c
+++ b/src/modules/processes/processes.c
@@ -6,26 +6,26 @@
 
 #define FF_PROCESSES_NUM_FORMAT_ARGS 1
 
-void ffPrintProcesses(FFinstance* instance, FFProcessesOptions* options)
+void ffPrintProcesses(FFProcessesOptions* options)
 {
     uint32_t numProcesses = 0;
     const char* error = ffDetectProcesses(&numProcesses);
 
     if(error)
     {
-        ffPrintError(instance, FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         printf("%u\n", numProcesses);
     }
     else
     {
-        ffPrintFormat(instance, FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, FF_PROCESSES_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, FF_PROCESSES_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_UINT, &numProcesses}
         });
     }
@@ -52,7 +52,7 @@ void ffDestroyProcessesOptions(FFProcessesOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseProcessesJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseProcessesJsonObject(yyjson_val* module)
 {
     FFProcessesOptions __attribute__((__cleanup__(ffDestroyProcessesOptions))) options;
     ffInitProcessesOptions(&options);
@@ -70,9 +70,9 @@ void ffParseProcessesJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_PROCESSES_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_PROCESSES_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintProcesses(instance, &options);
+    ffPrintProcesses(&options);
 }
diff --git a/src/modules/processes/processes.h b/src/modules/processes/processes.h
index 6aa952574..84696356d 100644
--- a/src/modules/processes/processes.h
+++ b/src/modules/processes/processes.h
@@ -4,8 +4,8 @@
 
 #define FF_PROCESSES_MODULE_NAME "Processes"
 
-void ffPrintProcesses(FFinstance* instance, FFProcessesOptions* options);
+void ffPrintProcesses(FFProcessesOptions* options);
 void ffInitProcessesOptions(FFProcessesOptions* options);
 bool ffParseProcessesCommandOptions(FFProcessesOptions* options, const char* key, const char* value);
 void ffDestroyProcessesOptions(FFProcessesOptions* options);
-void ffParseProcessesJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseProcessesJsonObject(yyjson_val* module);
diff --git a/src/modules/publicip/publicip.c b/src/modules/publicip/publicip.c
index 920c7c944..3b30e5b66 100644
--- a/src/modules/publicip/publicip.c
+++ b/src/modules/publicip/publicip.c
@@ -32,14 +32,14 @@ void ffPreparePublicIp(FFPublicIpOptions* options)
     }
 }
 
-void ffPrintPublicIp(FFinstance* instance, FFPublicIpOptions* options)
+void ffPrintPublicIp(FFPublicIpOptions* options)
 {
     if (status == -1)
         ffPreparePublicIp(options);
 
     if (status == 0)
     {
-        ffPrintError(instance, FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs, "Failed to connect to an IP detection server");
+        ffPrintError(FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs, "Failed to connect to an IP detection server");
         return;
     }
 
@@ -49,18 +49,18 @@ void ffPrintPublicIp(FFinstance* instance, FFPublicIpOptions* options)
 
     if (!success || result.length == 0)
     {
-        ffPrintError(instance, FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs, "Failed to receive the server response");
+        ffPrintError(FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs, "Failed to receive the server response");
         return;
     }
 
     if (options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&result, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs, FF_PUBLICIP_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs, FF_PUBLICIP_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &result}
         });
     }
@@ -104,7 +104,7 @@ void ffDestroyPublicIpOptions(FFPublicIpOptions* options)
     ffStrbufDestroy(&options->url);
 }
 
-void ffParsePublicIpJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParsePublicIpJsonObject(yyjson_val* module)
 {
     FFPublicIpOptions __attribute__((__cleanup__(ffDestroyPublicIpOptions))) options;
     ffInitPublicIpOptions(&options);
@@ -134,9 +134,9 @@ void ffParsePublicIpJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_PUBLICIP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_PUBLICIP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintPublicIp(instance, &options);
+    ffPrintPublicIp(&options);
 }
diff --git a/src/modules/publicip/publicip.h b/src/modules/publicip/publicip.h
index 618d054ff..8328023f5 100644
--- a/src/modules/publicip/publicip.h
+++ b/src/modules/publicip/publicip.h
@@ -6,8 +6,8 @@
 
 void ffPreparePublicIp(FFPublicIpOptions* options);
 
-void ffPrintPublicIp(FFinstance* instance, FFPublicIpOptions* options);
+void ffPrintPublicIp(FFPublicIpOptions* options);
 void ffInitPublicIpOptions(FFPublicIpOptions* options);
 bool ffParsePublicIpCommandOptions(FFPublicIpOptions* options, const char* key, const char* value);
 void ffDestroyPublicIpOptions(FFPublicIpOptions* options);
-void ffParsePublicIpJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParsePublicIpJsonObject(yyjson_val* module);
diff --git a/src/modules/separator/separator.c b/src/modules/separator/separator.c
index 1ae369f70..7a28f7bbe 100644
--- a/src/modules/separator/separator.c
+++ b/src/modules/separator/separator.c
@@ -3,19 +3,19 @@
 #include "modules/separator/separator.h"
 #include "util/stringUtils.h"
 
-void ffPrintSeparator(FFinstance* instance, FFSeparatorOptions* options)
+void ffPrintSeparator(FFSeparatorOptions* options)
 {
-    uint32_t titleLength = instance->state.titleLength;
+    uint32_t titleLength = instance.state.titleLength;
     if (titleLength == 0)
     {
         // Title was not printed, should we support this case?
-        titleLength = instance->state.platform.userName.length + 1 + (instance->config.title.fdqn ?
-            instance->state.platform.domainName.length :
-            instance->state.platform.hostName.length
+        titleLength = instance.state.platform.userName.length + 1 + (instance.config.title.fdqn ?
+            instance.state.platform.domainName.length :
+            instance.state.platform.hostName.length
         );
     }
 
-    ffLogoPrintLine(instance);
+    ffLogoPrintLine();
 
     if(options->string.length == 0)
     {
@@ -59,7 +59,7 @@ void ffDestroySeparatorOptions(FFSeparatorOptions* options)
     ffStrbufDestroy(&options->string);
 }
 
-void ffParseSeparatorJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseSeparatorJsonObject(yyjson_val* module)
 {
     FFSeparatorOptions __attribute__((__cleanup__(ffDestroySeparatorOptions))) options;
     ffInitSeparatorOptions(&options);
@@ -80,9 +80,9 @@ void ffParseSeparatorJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintErrorString(instance, FF_SEPARATOR_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
+            ffPrintErrorString(FF_SEPARATOR_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintSeparator(instance, &options);
+    ffPrintSeparator(&options);
 }
diff --git a/src/modules/separator/separator.h b/src/modules/separator/separator.h
index 6da53e559..3e97ac464 100644
--- a/src/modules/separator/separator.h
+++ b/src/modules/separator/separator.h
@@ -4,8 +4,8 @@
 
 #define FF_SEPARATOR_MODULE_NAME "Separator"
 
-void ffPrintSeparator(FFinstance* instance, FFSeparatorOptions* options);
+void ffPrintSeparator(FFSeparatorOptions* options);
 void ffInitSeparatorOptions(FFSeparatorOptions* options);
 bool ffParseSeparatorCommandOptions(FFSeparatorOptions* options, const char* key, const char* value);
 void ffDestroySeparatorOptions(FFSeparatorOptions* options);
-void ffParseSeparatorJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseSeparatorJsonObject(yyjson_val* module);
diff --git a/src/modules/shell/shell.c b/src/modules/shell/shell.c
index ac76f14a5..efaca7441 100644
--- a/src/modules/shell/shell.c
+++ b/src/modules/shell/shell.c
@@ -6,19 +6,19 @@
 
 #define FF_SHELL_NUM_FORMAT_ARGS 7
 
-void ffPrintShell(FFinstance* instance, FFShellOptions* options)
+void ffPrintShell(FFShellOptions* options)
 {
-    const FFTerminalShellResult* result = ffDetectTerminalShell(instance);
+    const FFTerminalShellResult* result = ffDetectTerminalShell();
 
     if(result->shellProcessName.length == 0)
     {
-        ffPrintError(instance, FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, "Couldn't detect shell");
+        ffPrintError(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, "Couldn't detect shell");
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_SHELL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufWriteTo(&result->shellPrettyName, stdout);
 
         if(result->shellVersion.length > 0)
@@ -31,7 +31,7 @@ void ffPrintShell(FFinstance* instance, FFShellOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, FF_SHELL_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, FF_SHELL_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->shellProcessName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->shellExe},
             {FF_FORMAT_ARG_TYPE_STRING, result->shellExeName},
@@ -64,7 +64,7 @@ void ffDestroyShellOptions(FFShellOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseShellJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseShellJsonObject(yyjson_val* module)
 {
     FFShellOptions __attribute__((__cleanup__(ffDestroyShellOptions))) options;
     ffInitShellOptions(&options);
@@ -82,9 +82,9 @@ void ffParseShellJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_SHELL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_SHELL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintShell(instance, &options);
+    ffPrintShell(&options);
 }
diff --git a/src/modules/shell/shell.h b/src/modules/shell/shell.h
index 0225b6291..b2579cd49 100644
--- a/src/modules/shell/shell.h
+++ b/src/modules/shell/shell.h
@@ -4,8 +4,8 @@
 
 #define FF_SHELL_MODULE_NAME "Shell"
 
-void ffPrintShell(FFinstance* instance, FFShellOptions* options);
+void ffPrintShell(FFShellOptions* options);
 void ffInitShellOptions(FFShellOptions* options);
 bool ffParseShellCommandOptions(FFShellOptions* options, const char* key, const char* value);
 void ffDestroyShellOptions(FFShellOptions* options);
-void ffParseShellJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseShellJsonObject(yyjson_val* module);
diff --git a/src/modules/sound/sound.c b/src/modules/sound/sound.c
index 786d4ab78..2955c8f5b 100644
--- a/src/modules/sound/sound.c
+++ b/src/modules/sound/sound.c
@@ -6,11 +6,11 @@
 
 #define FF_SOUND_NUM_FORMAT_ARGS 4
 
-static void printDevice(FFinstance* instance, FFSoundOptions* options, const FFSoundDevice* device, uint8_t index)
+static void printDevice(FFSoundOptions* options, const FFSoundDevice* device, uint8_t index)
 {
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_SOUND_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_SOUND_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufWriteTo(&device->name, stdout);
 
         if(device->volume != FF_SOUND_VOLUME_UNKNOWN)
@@ -28,7 +28,7 @@ static void printDevice(FFinstance* instance, FFSoundOptions* options, const FFS
     }
     else
     {
-        ffPrintFormat(instance, FF_SOUND_MODULE_NAME, index, &options->moduleArgs, FF_SOUND_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_SOUND_MODULE_NAME, index, &options->moduleArgs, FF_SOUND_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_BOOL, &device->main},
             {FF_FORMAT_ARG_TYPE_STRBUF, &device->name},
             {FF_FORMAT_ARG_TYPE_UINT8, &device->volume},
@@ -37,15 +37,15 @@ static void printDevice(FFinstance* instance, FFSoundOptions* options, const FFS
     }
 }
 
-void ffPrintSound(FFinstance* instance, FFSoundOptions* options)
+void ffPrintSound(FFSoundOptions* options)
 {
     FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFSoundDevice));
 
-    const char* error = ffDetectSound(instance, &result);
+    const char* error = ffDetectSound(&result);
 
     if(error)
     {
-        ffPrintError(instance, FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
@@ -65,14 +65,14 @@ void ffPrintSound(FFinstance* instance, FFSoundOptions* options)
 
     if(filtered.length == 0)
     {
-        ffPrintError(instance, FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "No active sound devices found");
+        ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "No active sound devices found");
         return;
     }
 
     uint8_t index = 1;
     FF_LIST_FOR_EACH(FFSoundDevice*, device, filtered)
     {
-        printDevice(instance, options, *device, filtered.length == 1 ? 0 : index++);
+        printDevice(options, *device, filtered.length == 1 ? 0 : index++);
     }
 
     FF_LIST_FOR_EACH(FFSoundDevice, device, result)
@@ -117,7 +117,7 @@ void ffDestroySoundOptions(FFSoundOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseSoundJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseSoundJsonObject(yyjson_val* module)
 {
     FFSoundOptions __attribute__((__cleanup__(ffDestroySoundOptions))) options;
     ffInitSoundOptions(&options);
@@ -145,15 +145,15 @@ void ffParseSoundJsonObject(FFinstance* instance, yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(instance, FF_SOUND_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
+                    ffPrintError(FF_SOUND_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
                 else
                     options.soundType = (FFSoundType) value;
                 continue;
             }
 
-            ffPrintError(instance, FF_SOUND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_SOUND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintSound(instance, &options);
+    ffPrintSound(&options);
 }
diff --git a/src/modules/sound/sound.h b/src/modules/sound/sound.h
index 0ebfe328f..4b02f4d24 100644
--- a/src/modules/sound/sound.h
+++ b/src/modules/sound/sound.h
@@ -4,8 +4,8 @@
 
 #define FF_SOUND_MODULE_NAME "Sound"
 
-void ffPrintSound(FFinstance* instance, FFSoundOptions* options);
+void ffPrintSound(FFSoundOptions* options);
 void ffInitSoundOptions(FFSoundOptions* options);
 bool ffParseSoundCommandOptions(FFSoundOptions* options, const char* key, const char* value);
 void ffDestroySoundOptions(FFSoundOptions* options);
-void ffParseSoundJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseSoundJsonObject(yyjson_val* module);
diff --git a/src/modules/swap/swap.c b/src/modules/swap/swap.c
index bf7ebb1fa..99ce0455e 100644
--- a/src/modules/swap/swap.c
+++ b/src/modules/swap/swap.c
@@ -8,22 +8,22 @@
 
 #define FF_SWAP_NUM_FORMAT_ARGS 3
 
-void ffPrintSwap(FFinstance* instance, FFSwapOptions* options)
+void ffPrintSwap(FFSwapOptions* options)
 {
     FFSwapResult storage;
     const char* error = ffDetectSwap(&storage);
 
     if(error)
     {
-        ffPrintError(instance, FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     FF_STRBUF_AUTO_DESTROY usedPretty = ffStrbufCreate();
-    ffParseSize(storage.bytesUsed, instance->config.binaryPrefixType, &usedPretty);
+    ffParseSize(storage.bytesUsed, instance.config.binaryPrefixType, &usedPretty);
 
     FF_STRBUF_AUTO_DESTROY totalPretty = ffStrbufCreate();
-    ffParseSize(storage.bytesTotal, instance->config.binaryPrefixType, &totalPretty);
+    ffParseSize(storage.bytesTotal, instance.config.binaryPrefixType, &totalPretty);
 
     uint8_t percentage = storage.bytesTotal == 0
         ? 0
@@ -31,24 +31,24 @@ void ffPrintSwap(FFinstance* instance, FFSwapOptions* options)
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_SWAP_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         if (storage.bytesTotal == 0)
             puts("Disabled");
         else
         {
             FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate();
 
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT)
             {
-                ffAppendPercentBar(instance, &str, percentage, 0, 5, 8);
+                ffAppendPercentBar(&str, percentage, 0, 5, 8);
                 ffStrbufAppendC(&str, ' ');
             }
 
-            if(!(instance->config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
+            if(!(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT))
                 ffStrbufAppendF(&str, "%s / %s ", usedPretty.chars, totalPretty.chars);
 
-            if(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
-                ffAppendPercentNum(instance, &str, (uint8_t) percentage, 50, 80, str.length > 0);
+            if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT)
+                ffAppendPercentNum(&str, (uint8_t) percentage, 50, 80, str.length > 0);
 
             ffStrbufTrimRight(&str, ' ');
             ffStrbufPutTo(&str, stdout);
@@ -56,7 +56,7 @@ void ffPrintSwap(FFinstance* instance, FFSwapOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, FF_SWAP_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, FF_SWAP_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &usedPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &totalPretty},
             {FF_FORMAT_ARG_TYPE_UINT8, &percentage},
@@ -85,7 +85,7 @@ void ffDestroySwapOptions(FFSwapOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseSwapJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseSwapJsonObject(yyjson_val* module)
 {
     FFSwapOptions __attribute__((__cleanup__(ffDestroySwapOptions))) options;
     ffInitSwapOptions(&options);
@@ -103,9 +103,9 @@ void ffParseSwapJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_SWAP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_SWAP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintSwap(instance, &options);
+    ffPrintSwap(&options);
 }
diff --git a/src/modules/swap/swap.h b/src/modules/swap/swap.h
index 6945f854c..3cd4f5b14 100644
--- a/src/modules/swap/swap.h
+++ b/src/modules/swap/swap.h
@@ -4,8 +4,8 @@
 
 #define FF_SWAP_MODULE_NAME "Swap"
 
-void ffPrintSwap(FFinstance* instance, FFSwapOptions* options);
+void ffPrintSwap(FFSwapOptions* options);
 void ffInitSwapOptions(FFSwapOptions* options);
 bool ffParseSwapCommandOptions(FFSwapOptions* options, const char* key, const char* value);
 void ffDestroySwapOptions(FFSwapOptions* options);
-void ffParseSwapJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseSwapJsonObject(yyjson_val* module);
diff --git a/src/modules/terminal/terminal.c b/src/modules/terminal/terminal.c
index 63de55909..315ede3bc 100644
--- a/src/modules/terminal/terminal.c
+++ b/src/modules/terminal/terminal.c
@@ -8,19 +8,19 @@
 
 #define FF_TERMINAL_NUM_FORMAT_ARGS 10
 
-void ffPrintTerminal(FFinstance* instance, FFTerminalOptions* options)
+void ffPrintTerminal(FFTerminalOptions* options)
 {
-    const FFTerminalShellResult* result = ffDetectTerminalShell(instance);
+    const FFTerminalShellResult* result = ffDetectTerminalShell();
 
     if(result->terminalProcessName.length == 0)
     {
-        ffPrintError(instance, FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, "Couldn't detect terminal");
+        ffPrintError(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, "Couldn't detect terminal");
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         if(result->terminalVersion.length)
             printf("%s %s\n", result->terminalPrettyName.chars, result->terminalVersion.chars);
@@ -29,7 +29,7 @@ void ffPrintTerminal(FFinstance* instance, FFTerminalOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, FF_TERMINAL_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, FF_TERMINAL_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->terminalProcessName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->terminalExe},
             {FF_FORMAT_ARG_TYPE_STRING, result->terminalExeName},
@@ -65,7 +65,7 @@ void ffDestroyTerminalOptions(FFTerminalOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseTerminalJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseTerminalJsonObject(yyjson_val* module)
 {
     FFTerminalOptions __attribute__((__cleanup__(ffDestroyTerminalOptions))) options;
     ffInitTerminalOptions(&options);
@@ -83,9 +83,9 @@ void ffParseTerminalJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_TERMINAL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_TERMINAL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintTerminal(instance, &options);
+    ffPrintTerminal(&options);
 }
diff --git a/src/modules/terminal/terminal.h b/src/modules/terminal/terminal.h
index 5f2045e78..45372754d 100644
--- a/src/modules/terminal/terminal.h
+++ b/src/modules/terminal/terminal.h
@@ -4,8 +4,8 @@
 
 #define FF_TERMINAL_MODULE_NAME "Terminal"
 
-void ffPrintTerminal(FFinstance* instance, FFTerminalOptions* options);
+void ffPrintTerminal(FFTerminalOptions* options);
 void ffInitTerminalOptions(FFTerminalOptions* options);
 bool ffParseTerminalCommandOptions(FFTerminalOptions* options, const char* key, const char* value);
 void ffDestroyTerminalOptions(FFTerminalOptions* options);
-void ffParseTerminalJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseTerminalJsonObject(yyjson_val* module);
diff --git a/src/modules/terminalfont/terminalfont.c b/src/modules/terminalfont/terminalfont.c
index db2177487..6e03ed45c 100644
--- a/src/modules/terminalfont/terminalfont.c
+++ b/src/modules/terminalfont/terminalfont.c
@@ -7,26 +7,26 @@
 #define FF_TERMINALFONT_DISPLAY_NAME "Terminal Font"
 #define FF_TERMINALFONT_NUM_FORMAT_ARGS 4
 
-void ffPrintTerminalFont(FFinstance* instance, FFTerminalFontOptions* options)
+void ffPrintTerminalFont(FFTerminalFontOptions* options)
 {
     FFTerminalFontResult terminalFont;
     ffFontInit(&terminalFont.font);
     ffStrbufInit(&terminalFont.error);
 
-    if(!ffDetectTerminalFont(instance, &terminalFont))
+    if(!ffDetectTerminalFont(&terminalFont))
     {
-        ffPrintError(instance, FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs, "%s", terminalFont.error.chars);
+        ffPrintError(FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs, "%s", terminalFont.error.chars);
     }
     else
     {
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
             ffStrbufPutTo(&terminalFont.font.pretty, stdout);
         }
         else
         {
-            ffPrintFormat(instance, FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs, FF_TERMINALFONT_NUM_FORMAT_ARGS, (FFformatarg[]){
+            ffPrintFormat(FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs, FF_TERMINALFONT_NUM_FORMAT_ARGS, (FFformatarg[]){
                 {FF_FORMAT_ARG_TYPE_STRBUF, &terminalFont.font.pretty},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &terminalFont.font.name},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &terminalFont.font.size},
@@ -60,7 +60,7 @@ void ffDestroyTerminalFontOptions(FFTerminalFontOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseTerminalFontJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseTerminalFontJsonObject(yyjson_val* module)
 {
     FFTerminalFontOptions __attribute__((__cleanup__(ffDestroyTerminalFontOptions))) options;
     ffInitTerminalFontOptions(&options);
@@ -78,9 +78,9 @@ void ffParseTerminalFontJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_TERMINALFONT_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_TERMINALFONT_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintTerminalFont(instance, &options);
+    ffPrintTerminalFont(&options);
 }
diff --git a/src/modules/terminalfont/terminalfont.h b/src/modules/terminalfont/terminalfont.h
index 25f974261..a538cd0d7 100644
--- a/src/modules/terminalfont/terminalfont.h
+++ b/src/modules/terminalfont/terminalfont.h
@@ -4,8 +4,8 @@
 
 #define FF_TERMINALFONT_MODULE_NAME "TerminalFont"
 
-void ffPrintTerminalFont(FFinstance* instance, FFTerminalFontOptions* options);
+void ffPrintTerminalFont(FFTerminalFontOptions* options);
 void ffInitTerminalFontOptions(FFTerminalFontOptions* options);
 bool ffParseTerminalFontCommandOptions(FFTerminalFontOptions* options, const char* key, const char* value);
 void ffDestroyTerminalFontOptions(FFTerminalFontOptions* options);
-void ffParseTerminalFontJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseTerminalFontJsonObject(yyjson_val* module);
diff --git a/src/modules/theme/theme.c b/src/modules/theme/theme.c
index 67edd69ba..741e47c72 100644
--- a/src/modules/theme/theme.c
+++ b/src/modules/theme/theme.c
@@ -6,25 +6,25 @@
 
 #define FF_THEME_NUM_FORMAT_ARGS 1
 
-void ffPrintTheme(FFinstance* instance, FFThemeOptions* options)
+void ffPrintTheme(FFThemeOptions* options)
 {
     FF_STRBUF_AUTO_DESTROY theme = ffStrbufCreate();
-    const char* error = ffDetectTheme(instance, &theme);
+    const char* error = ffDetectTheme(&theme);
 
     if(error)
     {
-        ffPrintError(instance, FF_THEME_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_THEME_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_THEME_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_THEME_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&theme, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_THEME_MODULE_NAME, 0, &options->moduleArgs, FF_THEME_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_THEME_MODULE_NAME, 0, &options->moduleArgs, FF_THEME_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &theme}
         });
     }
@@ -51,7 +51,7 @@ void ffDestroyThemeOptions(FFThemeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseThemeJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseThemeJsonObject(yyjson_val* module)
 {
     FFThemeOptions __attribute__((__cleanup__(ffDestroyThemeOptions))) options;
     ffInitThemeOptions(&options);
@@ -69,9 +69,9 @@ void ffParseThemeJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_THEME_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_THEME_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintTheme(instance, &options);
+    ffPrintTheme(&options);
 }
diff --git a/src/modules/theme/theme.h b/src/modules/theme/theme.h
index ae332f49e..37a006dd4 100644
--- a/src/modules/theme/theme.h
+++ b/src/modules/theme/theme.h
@@ -4,8 +4,8 @@
 
 #define FF_THEME_MODULE_NAME "Theme"
 
-void ffPrintTheme(FFinstance* instance, FFThemeOptions* options);
+void ffPrintTheme(FFThemeOptions* options);
 void ffInitThemeOptions(FFThemeOptions* options);
 bool ffParseThemeCommandOptions(FFThemeOptions* options, const char* key, const char* value);
 void ffDestroyThemeOptions(FFThemeOptions* options);
-void ffParseThemeJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseThemeJsonObject(yyjson_val* module);
diff --git a/src/modules/title/title.c b/src/modules/title/title.c
index 205d526ef..6faacaf67 100644
--- a/src/modules/title/title.c
+++ b/src/modules/title/title.c
@@ -4,32 +4,32 @@
 #include "util/textModifier.h"
 #include "util/stringUtils.h"
 
-static inline void printTitlePart(FFinstance* instance, const FFstrbuf* content)
+static inline void printTitlePart(const FFstrbuf* content)
 {
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
     {
         fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-        ffPrintColor(&instance->config.colorTitle);
+        ffPrintColor(&instance.config.colorTitle);
     }
 
     ffStrbufWriteTo(content, stdout);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 }
 
-void ffPrintTitle(FFinstance* instance, FFTitleOptions* options)
+void ffPrintTitle(FFTitleOptions* options)
 {
-    ffLogoPrintLine(instance);
+    ffLogoPrintLine();
 
-    printTitlePart(instance, &instance->state.platform.userName);
+    printTitlePart(&instance.state.platform.userName);
     putchar('@');
     FFstrbuf* host = options->fdqn ?
-        &instance->state.platform.domainName :
-        &instance->state.platform.hostName;
-    printTitlePart(instance, host);
+        &instance.state.platform.domainName :
+        &instance.state.platform.hostName;
+    printTitlePart(host);
 
-    instance->state.titleLength = instance->state.platform.userName.length + host->length + 1;
+    instance.state.titleLength = instance.state.platform.userName.length + host->length + 1;
 
     putchar('\n');
 }
@@ -59,7 +59,7 @@ void ffDestroyTitleOptions(FFTitleOptions* options)
     FF_UNUSED(options);
 }
 
-void ffParseTitleJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseTitleJsonObject(yyjson_val* module)
 {
     FFTitleOptions __attribute__((__cleanup__(ffDestroyTitleOptions))) options;
     ffInitTitleOptions(&options);
@@ -80,9 +80,9 @@ void ffParseTitleJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintErrorString(instance, FF_TITLE_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
+            ffPrintErrorString(FF_TITLE_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintTitle(instance, &options);
+    ffPrintTitle(&options);
 }
diff --git a/src/modules/title/title.h b/src/modules/title/title.h
index 1b1c9460b..7bd407243 100644
--- a/src/modules/title/title.h
+++ b/src/modules/title/title.h
@@ -4,8 +4,8 @@
 
 #define FF_TITLE_MODULE_NAME "Title"
 
-void ffPrintTitle(FFinstance* instance, FFTitleOptions* options);
+void ffPrintTitle(FFTitleOptions* options);
 void ffInitTitleOptions(FFTitleOptions* options);
 bool ffParseTitleCommandOptions(FFTitleOptions* options, const char* key, const char* value);
 void ffDestroyTitleOptions(FFTitleOptions* options);
-void ffParseTitleJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseTitleJsonObject(yyjson_val* module);
diff --git a/src/modules/uptime/uptime.c b/src/modules/uptime/uptime.c
index 6c7aaf892..f6a4bd424 100644
--- a/src/modules/uptime/uptime.c
+++ b/src/modules/uptime/uptime.c
@@ -6,7 +6,7 @@
 
 #define FF_UPTIME_NUM_FORMAT_ARGS 4
 
-void ffPrintUptime(FFinstance* instance, FFUptimeOptions* options)
+void ffPrintUptime(FFUptimeOptions* options)
 {
     uint64_t uptime;
 
@@ -14,7 +14,7 @@ void ffPrintUptime(FFinstance* instance, FFUptimeOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
@@ -25,7 +25,7 @@ void ffPrintUptime(FFinstance* instance, FFUptimeOptions* options)
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         if(days == 0 && hours == 0 && minutes == 0)
         {
@@ -70,7 +70,7 @@ void ffPrintUptime(FFinstance* instance, FFUptimeOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, FF_UPTIME_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, FF_UPTIME_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_UINT, &days},
             {FF_FORMAT_ARG_TYPE_UINT, &hours},
             {FF_FORMAT_ARG_TYPE_UINT, &minutes},
@@ -100,7 +100,7 @@ void ffDestroyUptimeOptions(FFUptimeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseUptimeJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseUptimeJsonObject(yyjson_val* module)
 {
     FFUptimeOptions __attribute__((__cleanup__(ffDestroyUptimeOptions))) options;
     ffInitUptimeOptions(&options);
@@ -118,9 +118,9 @@ void ffParseUptimeJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_UPTIME_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_UPTIME_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintUptime(instance, &options);
+    ffPrintUptime(&options);
 }
diff --git a/src/modules/uptime/uptime.h b/src/modules/uptime/uptime.h
index e19da5157..4708dbd39 100644
--- a/src/modules/uptime/uptime.h
+++ b/src/modules/uptime/uptime.h
@@ -4,8 +4,8 @@
 
 #define FF_UPTIME_MODULE_NAME "Uptime"
 
-void ffPrintUptime(FFinstance* instance, FFUptimeOptions* options);
+void ffPrintUptime(FFUptimeOptions* options);
 void ffInitUptimeOptions(FFUptimeOptions* options);
 bool ffParseUptimeCommandOptions(FFUptimeOptions* options, const char* key, const char* value);
 void ffDestroyUptimeOptions(FFUptimeOptions* options);
-void ffParseUptimeJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseUptimeJsonObject(yyjson_val* module);
diff --git a/src/modules/users/users.c b/src/modules/users/users.c
index 6f81469d3..ed18e7b14 100644
--- a/src/modules/users/users.c
+++ b/src/modules/users/users.c
@@ -6,7 +6,7 @@
 
 #define FF_USERS_NUM_FORMAT_ARGS 1
 
-void ffPrintUsers(FFinstance* instance, FFUsersOptions* options)
+void ffPrintUsers(FFUsersOptions* options)
 {
     FF_LIST_AUTO_DESTROY users = ffListCreate(sizeof(FFstrbuf));
 
@@ -16,7 +16,7 @@ void ffPrintUsers(FFinstance* instance, FFUsersOptions* options)
 
     if(error.length > 0)
     {
-        ffPrintError(instance, FF_USERS_MODULE_NAME, 0, &options->moduleArgs, "%*s", error.length, error.chars);
+        ffPrintError(FF_USERS_MODULE_NAME, 0, &options->moduleArgs, "%*s", error.length, error.chars);
         return;
     }
 
@@ -32,12 +32,12 @@ void ffPrintUsers(FFinstance* instance, FFUsersOptions* options)
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_USERS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_USERS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         puts(result.chars);
     }
     else
     {
-        ffPrintFormat(instance, FF_USERS_MODULE_NAME, 0, &options->moduleArgs, FF_USERS_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_USERS_MODULE_NAME, 0, &options->moduleArgs, FF_USERS_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result},
         });
     }
@@ -64,7 +64,7 @@ void ffDestroyUsersOptions(FFUsersOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseUsersJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseUsersJsonObject(yyjson_val* module)
 {
     FFUsersOptions __attribute__((__cleanup__(ffDestroyUsersOptions))) options;
     ffInitUsersOptions(&options);
@@ -82,9 +82,9 @@ void ffParseUsersJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_USERS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_USERS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintUsers(instance, &options);
+    ffPrintUsers(&options);
 }
diff --git a/src/modules/users/users.h b/src/modules/users/users.h
index fa96d0dc4..64aab51b7 100644
--- a/src/modules/users/users.h
+++ b/src/modules/users/users.h
@@ -4,8 +4,8 @@
 
 #define FF_USERS_MODULE_NAME "Users"
 
-void ffPrintUsers(FFinstance* instance, FFUsersOptions* options);
+void ffPrintUsers(FFUsersOptions* options);
 void ffInitUsersOptions(FFUsersOptions* options);
 bool ffParseUsersCommandOptions(FFUsersOptions* options, const char* key, const char* value);
 void ffDestroyUsersOptions(FFUsersOptions* options);
-void ffParseUsersJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseUsersJsonObject(yyjson_val* module);
diff --git a/src/modules/vulkan/vulkan.c b/src/modules/vulkan/vulkan.c
index da8897918..b4e51dfb9 100644
--- a/src/modules/vulkan/vulkan.c
+++ b/src/modules/vulkan/vulkan.c
@@ -6,19 +6,19 @@
 
 #define FF_VULKAN_NUM_FORMAT_ARGS 3
 
-void ffPrintVulkan(FFinstance* instance, FFVulkanOptions* options)
+void ffPrintVulkan(FFVulkanOptions* options)
 {
-    const FFVulkanResult* vulkan = ffDetectVulkan(instance);
+    const FFVulkanResult* vulkan = ffDetectVulkan();
 
     if(vulkan->error)
     {
-        ffPrintError(instance, FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, "%s", vulkan->error);
+        ffPrintError(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, "%s", vulkan->error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         if(vulkan->apiVersion.length > 0)
         {
@@ -35,7 +35,7 @@ void ffPrintVulkan(FFinstance* instance, FFVulkanOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, FF_VULKAN_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, FF_VULKAN_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &vulkan->driver},
             {FF_FORMAT_ARG_TYPE_STRBUF, &vulkan->apiVersion},
             {FF_FORMAT_ARG_TYPE_STRBUF, &vulkan->conformanceVersion}
@@ -64,7 +64,7 @@ void ffDestroyVulkanOptions(FFVulkanOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseVulkanJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseVulkanJsonObject(yyjson_val* module)
 {
     FFVulkanOptions __attribute__((__cleanup__(ffDestroyVulkanOptions))) options;
     ffInitVulkanOptions(&options);
@@ -82,9 +82,9 @@ void ffParseVulkanJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_VULKAN_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_VULKAN_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintVulkan(instance, &options);
+    ffPrintVulkan(&options);
 }
diff --git a/src/modules/vulkan/vulkan.h b/src/modules/vulkan/vulkan.h
index 68a3b8385..5b92ff850 100644
--- a/src/modules/vulkan/vulkan.h
+++ b/src/modules/vulkan/vulkan.h
@@ -4,8 +4,8 @@
 
 #define FF_VULKAN_MODULE_NAME "Vulkan"
 
-void ffPrintVulkan(FFinstance* instance, FFVulkanOptions* options);
+void ffPrintVulkan(FFVulkanOptions* options);
 void ffInitVulkanOptions(FFVulkanOptions* options);
 bool ffParseVulkanCommandOptions(FFVulkanOptions* options, const char* key, const char* value);
 void ffDestroyVulkanOptions(FFVulkanOptions* options);
-void ffParseVulkanJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseVulkanJsonObject(yyjson_val* module);
diff --git a/src/modules/wallpaper/wallpaper.c b/src/modules/wallpaper/wallpaper.c
index 3325fd6a5..54785f6ca 100644
--- a/src/modules/wallpaper/wallpaper.c
+++ b/src/modules/wallpaper/wallpaper.c
@@ -6,10 +6,10 @@
 
 #define FF_WALLPAPER_NUM_FORMAT_ARGS 2
 
-void ffPrintWallpaper(FFinstance* instance, FFWallpaperOptions* options)
+void ffPrintWallpaper(FFWallpaperOptions* options)
 {
     FF_STRBUF_AUTO_DESTROY fullpath = ffStrbufCreate();
-    const char* error = ffDetectWallpaper(instance, &fullpath);
+    const char* error = ffDetectWallpaper(&fullpath);
 
     const uint32_t index = ffStrbufLastIndexC(&fullpath,
         #ifndef _WIN32
@@ -24,18 +24,18 @@ void ffPrintWallpaper(FFinstance* instance, FFWallpaperOptions* options)
 
     if(error)
     {
-        ffPrintError(instance, FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         puts(filename);
     }
     else
     {
-        ffPrintFormat(instance, FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, FF_WALLPAPER_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, FF_WALLPAPER_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRING, filename},
             {FF_FORMAT_ARG_TYPE_STRBUF, &fullpath},
         });
@@ -63,7 +63,7 @@ void ffDestroyWallpaperOptions(FFWallpaperOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWallpaperJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseWallpaperJsonObject(yyjson_val* module)
 {
     FFWallpaperOptions __attribute__((__cleanup__(ffDestroyWallpaperOptions))) options;
     ffInitWallpaperOptions(&options);
@@ -81,9 +81,9 @@ void ffParseWallpaperJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_WALLPAPER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_WALLPAPER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintWallpaper(instance, &options);
+    ffPrintWallpaper(&options);
 }
diff --git a/src/modules/wallpaper/wallpaper.h b/src/modules/wallpaper/wallpaper.h
index bd2dbbbca..b274f037d 100644
--- a/src/modules/wallpaper/wallpaper.h
+++ b/src/modules/wallpaper/wallpaper.h
@@ -4,8 +4,8 @@
 
 #define FF_WALLPAPER_MODULE_NAME "Wallpaper"
 
-void ffPrintWallpaper(FFinstance* instance, FFWallpaperOptions* options);
+void ffPrintWallpaper(FFWallpaperOptions* options);
 void ffInitWallpaperOptions(FFWallpaperOptions* options);
 bool ffParseWallpaperCommandOptions(FFWallpaperOptions* options, const char* key, const char* value);
 void ffDestroyWallpaperOptions(FFWallpaperOptions* options);
-void ffParseWallpaperJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseWallpaperJsonObject(yyjson_val* module);
diff --git a/src/modules/weather/weather.c b/src/modules/weather/weather.c
index d32095904..84f34ee82 100644
--- a/src/modules/weather/weather.c
+++ b/src/modules/weather/weather.c
@@ -16,14 +16,14 @@ void ffPrepareWeather(FFWeatherOptions* options)
     status = ffNetworkingSendHttpRequest(&state, "wttr.in", path.chars, "User-Agent: curl/0.0.0\r\n");
 }
 
-void ffPrintWeather(FFinstance* instance, FFWeatherOptions* options)
+void ffPrintWeather(FFWeatherOptions* options)
 {
     if(status == -1)
         ffPrepareWeather(options);
 
     if(status == 0)
     {
-        ffPrintError(instance, FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, "Failed to connect to 'wttr.in'");
+        ffPrintError(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, "Failed to connect to 'wttr.in'");
         return;
     }
 
@@ -33,18 +33,18 @@ void ffPrintWeather(FFinstance* instance, FFWeatherOptions* options)
 
     if(!success || result.length == 0)
     {
-        ffPrintError(instance, FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, "Failed to receive the server response");
+        ffPrintError(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, "Failed to receive the server response");
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
         ffStrbufPutTo(&result, stdout);
     }
     else
     {
-        ffPrintFormat(instance, FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, FF_WEATHER_NUM_FORMAT_ARGS, (FFformatarg[]) {
+        ffPrintFormat(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, FF_WEATHER_NUM_FORMAT_ARGS, (FFformatarg[]) {
             {FF_FORMAT_ARG_TYPE_STRBUF, &result}
         });
     }
@@ -88,7 +88,7 @@ void ffDestroyWeatherOptions(FFWeatherOptions* options)
     ffStrbufDestroy(&options->outputFormat);
 }
 
-void ffParseWeatherJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseWeatherJsonObject(yyjson_val* module)
 {
     FFWeatherOptions __attribute__((__cleanup__(ffDestroyWeatherOptions))) options;
     ffInitWeatherOptions(&options);
@@ -118,9 +118,9 @@ void ffParseWeatherJsonObject(FFinstance* instance, yyjson_val* module)
                 continue;
             }
 
-            ffPrintError(instance, FF_WEATHER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_WEATHER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintWeather(instance, &options);
+    ffPrintWeather(&options);
 }
diff --git a/src/modules/weather/weather.h b/src/modules/weather/weather.h
index 70c34b61f..640201176 100644
--- a/src/modules/weather/weather.h
+++ b/src/modules/weather/weather.h
@@ -6,8 +6,8 @@
 
 void ffPrepareWeather(FFWeatherOptions* options);
 
-void ffPrintWeather(FFinstance* instance, FFWeatherOptions* options);
+void ffPrintWeather(FFWeatherOptions* options);
 void ffInitWeatherOptions(FFWeatherOptions* options);
 bool ffParseWeatherCommandOptions(FFWeatherOptions* options, const char* key, const char* value);
 void ffDestroyWeatherOptions(FFWeatherOptions* options);
-void ffParseWeatherJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseWeatherJsonObject(yyjson_val* module);
diff --git a/src/modules/wifi/wifi.c b/src/modules/wifi/wifi.c
index 79e56db11..cda777141 100644
--- a/src/modules/wifi/wifi.c
+++ b/src/modules/wifi/wifi.c
@@ -6,19 +6,19 @@
 
 #define FF_WIFI_NUM_FORMAT_ARGS 10
 
-void ffPrintWifi(FFinstance* instance, FFWifiOptions* options)
+void ffPrintWifi(FFWifiOptions* options)
 {
     FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFWifiResult));
 
-    const char* error = ffDetectWifi(instance, &result);
+    const char* error = ffDetectWifi(&result);
     if(error)
     {
-        ffPrintError(instance, FF_WIFI_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
+        ffPrintError(FF_WIFI_MODULE_NAME, 0, &options->moduleArgs, "%s", error);
         return;
     }
     if(!result.length)
     {
-        ffPrintError(instance, FF_WIFI_MODULE_NAME, 0, &options->moduleArgs, "No Wifi interfaces found");
+        ffPrintError(FF_WIFI_MODULE_NAME, 0, &options->moduleArgs, "No Wifi interfaces found");
         return;
     }
 
@@ -29,7 +29,7 @@ void ffPrintWifi(FFinstance* instance, FFWifiOptions* options)
 
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, FF_WIFI_MODULE_NAME, moduleIndex, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(FF_WIFI_MODULE_NAME, moduleIndex, &options->moduleArgs.key, &options->moduleArgs.keyColor);
             if(item->conn.ssid.length)
             {
                 ffStrbufWriteTo(&item->conn.ssid, stdout);
@@ -46,7 +46,7 @@ void ffPrintWifi(FFinstance* instance, FFWifiOptions* options)
         }
         else
         {
-            ffPrintFormat(instance, FF_WIFI_MODULE_NAME, moduleIndex, &options->moduleArgs, FF_WIFI_NUM_FORMAT_ARGS, (FFformatarg[]){
+            ffPrintFormat(FF_WIFI_MODULE_NAME, moduleIndex, &options->moduleArgs, FF_WIFI_NUM_FORMAT_ARGS, (FFformatarg[]){
                 {FF_FORMAT_ARG_TYPE_STRBUF, &item->inf.description},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &item->inf.status},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &item->conn.status},
@@ -91,7 +91,7 @@ void ffDestroyWifiOptions(FFWifiOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWifiJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseWifiJsonObject(yyjson_val* module)
 {
     FFWifiOptions __attribute__((__cleanup__(ffDestroyWifiOptions))) options;
     ffInitWifiOptions(&options);
@@ -109,9 +109,9 @@ void ffParseWifiJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_WIFI_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_WIFI_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintWifi(instance, &options);
+    ffPrintWifi(&options);
 }
diff --git a/src/modules/wifi/wifi.h b/src/modules/wifi/wifi.h
index 99070d07b..b8291fdfc 100644
--- a/src/modules/wifi/wifi.h
+++ b/src/modules/wifi/wifi.h
@@ -4,8 +4,8 @@
 
 #define FF_WIFI_MODULE_NAME "Wifi"
 
-void ffPrintWifi(FFinstance* instance, FFWifiOptions* options);
+void ffPrintWifi(FFWifiOptions* options);
 void ffInitWifiOptions(FFWifiOptions* options);
 bool ffParseWifiCommandOptions(FFWifiOptions* options, const char* key, const char* value);
 void ffDestroyWifiOptions(FFWifiOptions* options);
-void ffParseWifiJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseWifiJsonObject(yyjson_val* module);
diff --git a/src/modules/wm/wm.c b/src/modules/wm/wm.c
index 72a8536df..6f60107ff 100644
--- a/src/modules/wm/wm.c
+++ b/src/modules/wm/wm.c
@@ -6,19 +6,19 @@
 
 #define FF_WM_NUM_FORMAT_ARGS 3
 
-void ffPrintWM(FFinstance* instance, FFWMOptions* options)
+void ffPrintWM(FFWMOptions* options)
 {
-    const FFDisplayServerResult* result = ffConnectDisplayServer(instance);
+    const FFDisplayServerResult* result = ffConnectDisplayServer();
 
     if(result->wmPrettyName.length == 0)
     {
-        ffPrintError(instance, FF_WM_MODULE_NAME, 0, &options->moduleArgs, "No WM found");
+        ffPrintError(FF_WM_MODULE_NAME, 0, &options->moduleArgs, "No WM found");
         return;
     }
 
     if(options->moduleArgs.outputFormat.length == 0)
     {
-        ffPrintLogoAndKey(instance, FF_WM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+        ffPrintLogoAndKey(FF_WM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
 
         ffStrbufWriteTo(&result->wmPrettyName, stdout);
 
@@ -33,7 +33,7 @@ void ffPrintWM(FFinstance* instance, FFWMOptions* options)
     }
     else
     {
-        ffPrintFormat(instance, FF_WM_MODULE_NAME, 0, &options->moduleArgs, FF_WM_NUM_FORMAT_ARGS, (FFformatarg[]){
+        ffPrintFormat(FF_WM_MODULE_NAME, 0, &options->moduleArgs, FF_WM_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->wmProcessName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->wmPrettyName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->wmProtocolName}
@@ -62,7 +62,7 @@ void ffDestroyWMOptions(FFWMOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWMJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseWMJsonObject(yyjson_val* module)
 {
     FFWMOptions __attribute__((__cleanup__(ffDestroyWMOptions))) options;
     ffInitWMOptions(&options);
@@ -80,9 +80,9 @@ void ffParseWMJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_WM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_WM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintWM(instance, &options);
+    ffPrintWM(&options);
 }
diff --git a/src/modules/wm/wm.h b/src/modules/wm/wm.h
index 2f18b1c16..243d6a647 100644
--- a/src/modules/wm/wm.h
+++ b/src/modules/wm/wm.h
@@ -4,8 +4,8 @@
 
 #define FF_WM_MODULE_NAME "WM"
 
-void ffPrintWM(FFinstance* instance, FFWMOptions* options);
+void ffPrintWM(FFWMOptions* options);
 void ffInitWMOptions(FFWMOptions* options);
 bool ffParseWMCommandOptions(FFWMOptions* options, const char* key, const char* value);
 void ffDestroyWMOptions(FFWMOptions* options);
-void ffParseWMJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseWMJsonObject(yyjson_val* module);
diff --git a/src/modules/wmtheme/wmtheme.c b/src/modules/wmtheme/wmtheme.c
index 45d7ead7f..da66e8ad8 100644
--- a/src/modules/wmtheme/wmtheme.c
+++ b/src/modules/wmtheme/wmtheme.c
@@ -7,26 +7,26 @@
 #define FF_WMTHEME_DISPLAY_NAME "WM Theme"
 #define FF_WMTHEME_NUM_FORMAT_ARGS 1
 
-void ffPrintWMTheme(FFinstance* instance, FFWMThemeOptions* options)
+void ffPrintWMTheme(FFWMThemeOptions* options)
 {
     FF_STRBUF_AUTO_DESTROY themeOrError = ffStrbufCreate();
-    if(ffDetectWmTheme(instance, &themeOrError))
+    if(ffDetectWmTheme(&themeOrError))
     {
         if(options->moduleArgs.outputFormat.length == 0)
         {
-            ffPrintLogoAndKey(instance, FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
+            ffPrintLogoAndKey(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor);
             puts(themeOrError.chars);
         }
         else
         {
-            ffPrintFormat(instance, FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, FF_WMTHEME_NUM_FORMAT_ARGS, (FFformatarg[]){
+            ffPrintFormat(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, FF_WMTHEME_NUM_FORMAT_ARGS, (FFformatarg[]){
                 {FF_FORMAT_ARG_TYPE_STRBUF, &themeOrError}
             });
         }
     }
     else
     {
-        ffPrintError(instance, FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, "%*s", themeOrError.length, themeOrError.chars);
+        ffPrintError(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, "%*s", themeOrError.length, themeOrError.chars);
     }
 }
 
@@ -51,7 +51,7 @@ void ffDestroyWMThemeOptions(FFWMThemeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWMThemeJsonObject(FFinstance* instance, yyjson_val* module)
+void ffParseWMThemeJsonObject(yyjson_val* module)
 {
     FFWMThemeOptions __attribute__((__cleanup__(ffDestroyWMThemeOptions))) options;
     ffInitWMThemeOptions(&options);
@@ -69,9 +69,9 @@ void ffParseWMThemeJsonObject(FFinstance* instance, yyjson_val* module)
             if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
                 continue;
 
-            ffPrintError(instance, FF_WMTHEME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_WMTHEME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
         }
     }
 
-    ffPrintWMTheme(instance, &options);
+    ffPrintWMTheme(&options);
 }
diff --git a/src/modules/wmtheme/wmtheme.h b/src/modules/wmtheme/wmtheme.h
index 5bb11cb3f..021408945 100644
--- a/src/modules/wmtheme/wmtheme.h
+++ b/src/modules/wmtheme/wmtheme.h
@@ -4,8 +4,8 @@
 
 #define FF_WMTHEME_MODULE_NAME "WMTheme"
 
-void ffPrintWMTheme(FFinstance* instance, FFWMThemeOptions* options);
+void ffPrintWMTheme(FFWMThemeOptions* options);
 void ffInitWMThemeOptions(FFWMThemeOptions* options);
 bool ffParseWMThemeCommandOptions(FFWMThemeOptions* options, const char* key, const char* value);
 void ffDestroyWMThemeOptions(FFWMThemeOptions* options);
-void ffParseWMThemeJsonObject(FFinstance* instance, yyjson_val* module);
+void ffParseWMThemeJsonObject(yyjson_val* module);
diff --git a/src/util/windows/com.cpp b/src/util/windows/com.cpp
index c11cccf95..43c4a5a49 100644
--- a/src/util/windows/com.cpp
+++ b/src/util/windows/com.cpp
@@ -6,7 +6,7 @@
 
 //https://learn.microsoft.com/en-us/windows/win32/wmisdk/example--getting-wmi-data-from-the-local-computer
 //https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/computer-system-hardware-classes
-static void CoUninitializeWrap()
+static void CoUninitializeWrap(void)
 {
     CoUninitialize();
 }
diff --git a/src/util/windows/wmi.cpp b/src/util/windows/wmi.cpp
index f1e2e10a1..9b8103fbe 100644
--- a/src/util/windows/wmi.cpp
+++ b/src/util/windows/wmi.cpp
@@ -15,9 +15,9 @@ namespace
     struct bstr_t
     {
         explicit bstr_t(const wchar_t* str) noexcept: _bstr(SysAllocString(str)) {}
-        ~bstr_t() noexcept { SysFreeString(_bstr); }
-        explicit operator const wchar_t*() const noexcept { return _bstr; }
-        operator BSTR() const noexcept { return _bstr; }
+        ~bstr_t(void) noexcept { SysFreeString(_bstr); }
+        explicit operator const wchar_t*(void) const noexcept { return _bstr; }
+        operator BSTR(void) const noexcept { return _bstr; }
 
         private:
             BSTR _bstr;