diff --git a/CHANGELOG.md b/CHANGELOG.md
index 137724688..13c92129a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ Features:
 
 Bugfixes:
 * Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux)
+* Fix some module options were not inited
 
 # 2.0.0-beta
 
diff --git a/doc/json_schema.json b/doc/json_schema.json
index 0ecf5920a..46991ab18 100644
--- a/doc/json_schema.json
+++ b/doc/json_schema.json
@@ -373,7 +373,7 @@
                         },
                         "width": {
                             "type": "integer",
-                            "title": "Set the width of the bar",
+                            "title": "Set the width of the bar, in number of characters",
                             "minimum": 1,
                             "default": 10
                         }
diff --git a/src/common/init.c b/src/common/init.c
index 3510818b3..afd58bcc7 100644
--- a/src/common/init.c
+++ b/src/common/init.c
@@ -76,57 +76,60 @@ static void defaultConfig(void)
     instance.config.barBorder = true;
     instance.config.percentType = 1;
 
-    ffInitTitleOptions(&instance.config.title);
-    ffInitOSOptions(&instance.config.os);
-    ffInitHostOptions(&instance.config.host);
+    ffInitBatteryOptions(&instance.config.battery);
     ffInitBiosOptions(&instance.config.bios);
+    ffInitBluetoothOptions(&instance.config.bluetooth);
     ffInitBoardOptions(&instance.config.board);
+    ffInitBreakOptions(&instance.config.break_);
     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);
+    ffInitChassisOptions(&instance.config.chassis);
+    ffInitColorsOptions(&instance.config.colors);
+    ffInitCommandOptions(&instance.config.command);
+    ffInitCursorOptions(&instance.config.cursor);
+    ffInitCustomOptions(&instance.config.custom);
+    ffInitDEOptions(&instance.config.de);
+    ffInitDateTimeOptions(&instance.config.dateTime);
     ffInitDiskOptions(&instance.config.disk);
-    ffInitBatteryOptions(&instance.config.battery);
-    ffInitPowerAdapterOptions(&instance.config.powerAdapter);
+    ffInitDisplayOptions(&instance.config.display);
+    ffInitFontOptions(&instance.config.font);
+    ffInitGPUOptions(&instance.config.gpu);
+    ffInitGamepadOptions(&instance.config.gamepad);
+    ffInitHostOptions(&instance.config.host);
+    ffInitIconsOptions(&instance.config.icons);
+    ffInitKernelOptions(&instance.config.kernel);
     ffInitLMOptions(&instance.config.lm);
-    ffInitLocaleOptions(&instance.config.locale);
     ffInitLocalIpOptions(&instance.config.localIP);
+    ffInitLocaleOptions(&instance.config.locale);
+    ffInitMediaOptions(&instance.config.media);
+    ffInitMemoryOptions(&instance.config.memory);
+    ffInitMonitorOptions(&instance.config.monitor);
+    ffInitOSOptions(&instance.config.os);
+    ffInitOpenCLOptions(&instance.config.openCL);
+    ffInitOpenGLOptions(&instance.config.openGL);
+    ffInitPackagesOptions(&instance.config.packages);
+    ffInitPlayerOptions(&instance.config.player);
+    ffInitPowerAdapterOptions(&instance.config.powerAdapter);
+    ffInitProcessesOptions(&instance.config.processes);
     ffInitPublicIpOptions(&instance.config.publicIP);
+    ffInitSeparatorOptions(&instance.config.separator);
+    ffInitShellOptions(&instance.config.shell);
+    ffInitSoundOptions(&instance.config.sound);
+    ffInitSwapOptions(&instance.config.swap);
+    ffInitTerminalFontOptions(&instance.config.terminalFont);
+    ffInitTerminalOptions(&instance.config.terminal);
+    ffInitTerminalSizeOptions(&instance.config.terminalSize);
+    ffInitThemeOptions(&instance.config.theme);
+    ffInitTitleOptions(&instance.config.title);
+    ffInitUptimeOptions(&instance.config.uptime);
+    ffInitUsersOptions(&instance.config.users);
+    ffInitVulkanOptions(&instance.config.vulkan);
+    ffInitWMOptions(&instance.config.wm);
+    ffInitWMThemeOptions(&instance.config.wmTheme);
+    ffInitWallpaperOptions(&instance.config.wallpaper);
     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);
@@ -285,57 +288,60 @@ static void destroyConfig(void)
     ffStrbufDestroy(&instance.config.osFile);
     #endif
 
-    ffDestroyTitleOptions(&instance.config.title);
-    ffDestroyOSOptions(&instance.config.os);
-    ffDestroyHostOptions(&instance.config.host);
+    ffDestroyBatteryOptions(&instance.config.battery);
     ffDestroyBiosOptions(&instance.config.bios);
+    ffDestroyBluetoothOptions(&instance.config.bluetooth);
     ffDestroyBoardOptions(&instance.config.board);
+    ffDestroyBreakOptions(&instance.config.break_);
     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);
+    ffDestroyChassisOptions(&instance.config.chassis);
+    ffDestroyColorsOptions(&instance.config.colors);
+    ffDestroyCommandOptions(&instance.config.command);
+    ffDestroyCursorOptions(&instance.config.cursor);
+    ffDestroyCustomOptions(&instance.config.custom);
+    ffDestroyDEOptions(&instance.config.de);
+    ffDestroyDateTimeOptions(&instance.config.dateTime);
     ffDestroyDiskOptions(&instance.config.disk);
-    ffDestroyBatteryOptions(&instance.config.battery);
-    ffDestroyPowerAdapterOptions(&instance.config.powerAdapter);
+    ffDestroyDisplayOptions(&instance.config.display);
+    ffDestroyFontOptions(&instance.config.font);
+    ffDestroyGPUOptions(&instance.config.gpu);
+    ffDestroyGamepadOptions(&instance.config.gamepad);
+    ffDestroyHostOptions(&instance.config.host);
+    ffDestroyIconsOptions(&instance.config.icons);
+    ffDestroyKernelOptions(&instance.config.kernel);
     ffDestroyLMOptions(&instance.config.lm);
-    ffDestroyLocaleOptions(&instance.config.locale);
     ffDestroyLocalIpOptions(&instance.config.localIP);
+    ffDestroyLocaleOptions(&instance.config.locale);
+    ffDestroyMediaOptions(&instance.config.media);
+    ffDestroyMemoryOptions(&instance.config.memory);
+    ffDestroyMonitorOptions(&instance.config.monitor);
+    ffDestroyOSOptions(&instance.config.os);
+    ffDestroyOpenCLOptions(&instance.config.openCL);
+    ffDestroyOpenGLOptions(&instance.config.openGL);
+    ffDestroyPackagesOptions(&instance.config.packages);
+    ffDestroyPlayerOptions(&instance.config.player);
+    ffDestroyPowerAdapterOptions(&instance.config.powerAdapter);
+    ffDestroyProcessesOptions(&instance.config.processes);
     ffDestroyPublicIpOptions(&instance.config.publicIP);
+    ffDestroySeparatorOptions(&instance.config.separator);
+    ffDestroyShellOptions(&instance.config.shell);
+    ffDestroySoundOptions(&instance.config.sound);
+    ffDestroySwapOptions(&instance.config.swap);
+    ffDestroyTerminalFontOptions(&instance.config.terminalFont);
+    ffDestroyTerminalOptions(&instance.config.terminal);
+    ffDestroyTerminalSizeOptions(&instance.config.terminalSize);
+    ffDestroyThemeOptions(&instance.config.theme);
+    ffDestroyTitleOptions(&instance.config.title);
+    ffDestroyUptimeOptions(&instance.config.uptime);
+    ffDestroyUsersOptions(&instance.config.users);
+    ffDestroyVulkanOptions(&instance.config.vulkan);
+    ffDestroyWMOptions(&instance.config.wm);
+    ffDestroyWMThemeOptions(&instance.config.wmTheme);
     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);
diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c
index e504eafda..8e1ecdaaf 100644
--- a/src/common/jsonconfig.c
+++ b/src/common/jsonconfig.c
@@ -70,11 +70,13 @@ 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(const char* type, yyjson_val* module, const char* moduleName, void (*const f)(yyjson_val *module))
+static inline bool tryModule(const char* type, yyjson_val* module, void* options)
 {
-    if (ffStrEqualsIgnCase(type, moduleName))
+    FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options;
+    if (ffStrEqualsIgnCase(type, baseInfo->name))
     {
-        f(module);
+        if (module) baseInfo->parseJsonObject(options, module);
+        baseInfo->printModule(options);
         return true;
     }
     return false;
@@ -82,144 +84,145 @@ static inline bool tryModule(const char* type, yyjson_val* module, const char* m
 
 static bool parseModuleJsonObject(const char* type, yyjson_val* module)
 {
+    FFconfig* cfg = &instance.config;
     switch (toupper(type[0]))
     {
         case 'B': {
             return
-                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) ||
+                tryModule(type, module, &cfg->battery) ||
+                tryModule(type, module, &cfg->bios) ||
+                tryModule(type, module, &cfg->bluetooth) ||
+                tryModule(type, module, &cfg->board) ||
+                tryModule(type, module, &cfg->break_) ||
+                tryModule(type, module, &cfg->brightness) ||
                 false;
         }
 
         case 'C': {
             return
-                tryModule(type, module, FF_CHASSIS_MODULE_NAME, ffParseChassisJsonObject) ||
-                tryModule(type, module, FF_COMMAND_MODULE_NAME, ffParseCommandJsonObject) ||
-                tryModule(type, module, FF_COLORS_MODULE_NAME, ffParseColorsJsonObject) ||
-                tryModule(type, module, FF_CPU_MODULE_NAME, ffParseCPUJsonObject) ||
-                tryModule(type, module, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageJsonObject) ||
-                tryModule(type, module, FF_CURSOR_MODULE_NAME, ffParseCursorJsonObject) ||
-                tryModule(type, module, FF_CUSTOM_MODULE_NAME, ffParseCustomJsonObject) ||
+                tryModule(type, module, &cfg->chassis) ||
+                tryModule(type, module, &cfg->command) ||
+                tryModule(type, module, &cfg->colors) ||
+                tryModule(type, module, &cfg->cpu) ||
+                tryModule(type, module, &cfg->cpuUsage) ||
+                tryModule(type, module, &cfg->cursor) ||
+                tryModule(type, module, &cfg->custom) ||
                 false;
         }
 
         case 'D': {
             return
-                tryModule(type, module, FF_DATETIME_MODULE_NAME, ffParseDateTimeJsonObject) ||
-                tryModule(type, module, FF_DE_MODULE_NAME, ffParseDEJsonObject) ||
-                tryModule(type, module, FF_DISPLAY_MODULE_NAME, ffParseDisplayJsonObject) ||
-                tryModule(type, module, FF_DISK_MODULE_NAME, ffParseDiskJsonObject) ||
+                tryModule(type, module, &cfg->dateTime) ||
+                tryModule(type, module, &cfg->de) ||
+                tryModule(type, module, &cfg->display) ||
+                tryModule(type, module, &cfg->disk) ||
                 false;
         }
 
         case 'F': {
             return
-                tryModule(type, module, FF_FONT_MODULE_NAME, ffParseFontJsonObject) ||
+                tryModule(type, module, &cfg->font) ||
                 false;
         }
 
         case 'G': {
             return
-                tryModule(type, module, FF_GAMEPAD_MODULE_NAME, ffParseGamepadJsonObject) ||
-                tryModule(type, module, FF_GPU_MODULE_NAME, ffParseGPUJsonObject) ||
+                tryModule(type, module, &cfg->gamepad) ||
+                tryModule(type, module, &cfg->gpu) ||
                 false;
         }
 
         case 'H': {
             return
-                tryModule(type, module, FF_HOST_MODULE_NAME, ffParseHostJsonObject) ||
+                tryModule(type, module, &cfg->host) ||
                 false;
         }
 
         case 'I': {
             return
-                tryModule(type, module, FF_ICONS_MODULE_NAME, ffParseIconsJsonObject) ||
+                tryModule(type, module, &cfg->icons) ||
                 false;
         }
 
         case 'K': {
             return
-                tryModule(type, module, FF_KERNEL_MODULE_NAME, ffParseKernelJsonObject) ||
+                tryModule(type, module, &cfg->kernel) ||
                 false;
         }
 
         case 'L': {
             return
-                tryModule(type, module, FF_LM_MODULE_NAME, ffParseLMJsonObject) ||
-                tryModule(type, module, FF_LOCALE_MODULE_NAME, ffParseLocaleJsonObject) ||
-                tryModule(type, module, FF_LOCALIP_MODULE_NAME, ffParseLocalIpJsonObject) ||
+                tryModule(type, module, &cfg->lm) ||
+                tryModule(type, module, &cfg->locale) ||
+                tryModule(type, module, &cfg->localIP) ||
                 false;
         }
 
         case 'M': {
             return
-                tryModule(type, module, FF_MEDIA_MODULE_NAME, ffParseMediaJsonObject) ||
-                tryModule(type, module, FF_MEMORY_MODULE_NAME, ffParseMemoryJsonObject) ||
-                tryModule(type, module, FF_MONITOR_MODULE_NAME, ffParseMonitorJsonObject) ||
+                tryModule(type, module, &cfg->media) ||
+                tryModule(type, module, &cfg->memory) ||
+                tryModule(type, module, &cfg->monitor) ||
                 false;
         }
 
         case 'O': {
             return
-                tryModule(type, module, FF_OPENCL_MODULE_NAME, ffParseOpenCLJsonObject) ||
-                tryModule(type, module, FF_OPENGL_MODULE_NAME, ffParseOpenGLJsonObject) ||
-                tryModule(type, module, FF_OS_MODULE_NAME, ffParseOSJsonObject) ||
+                tryModule(type, module, &cfg->openCL) ||
+                tryModule(type, module, &cfg->openGL) ||
+                tryModule(type, module, &cfg->os) ||
                 false;
         }
 
         case 'P': {
             return
-                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) ||
+                tryModule(type, module, &cfg->packages) ||
+                tryModule(type, module, &cfg->player) ||
+                tryModule(type, module, &cfg->powerAdapter) ||
+                tryModule(type, module, &cfg->processes) ||
+                tryModule(type, module, &cfg->publicIP) ||
                 false;
         }
 
         case 'S': {
             return
-                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) ||
+                tryModule(type, module, &cfg->separator) ||
+                tryModule(type, module, &cfg->shell) ||
+                tryModule(type, module, &cfg->sound) ||
+                tryModule(type, module, &cfg->swap) ||
                 false;
         }
 
         case 'T': {
             return
-                tryModule(type, module, FF_TERMINAL_MODULE_NAME, ffParseTerminalJsonObject) ||
-                tryModule(type, module, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontJsonObject) ||
-                tryModule(type, module, FF_TERMINALSIZE_MODULE_NAME, ffParseTerminalSizeJsonObject) ||
-                tryModule(type, module, FF_TITLE_MODULE_NAME, ffParseTitleJsonObject) ||
-                tryModule(type, module, FF_THEME_MODULE_NAME, ffParseThemeJsonObject) ||
+                tryModule(type, module, &cfg->terminal) ||
+                tryModule(type, module, &cfg->terminalFont) ||
+                tryModule(type, module, &cfg->terminalSize) ||
+                tryModule(type, module, &cfg->title) ||
+                tryModule(type, module, &cfg->theme) ||
                 false;
         }
 
         case 'U': {
             return
-                tryModule(type, module, FF_UPTIME_MODULE_NAME, ffParseUptimeJsonObject) ||
-                tryModule(type, module, FF_USERS_MODULE_NAME, ffParseUsersJsonObject) ||
+                tryModule(type, module, &cfg->uptime) ||
+                tryModule(type, module, &cfg->users) ||
                 false;
         }
 
         case 'V': {
             return
-                tryModule(type, module, FF_VULKAN_MODULE_NAME, ffParseVulkanJsonObject) ||
+                tryModule(type, module, &cfg->vulkan) ||
                 false;
         }
 
         case 'W': {
             return
-                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) ||
+                tryModule(type, module, &cfg->wallpaper) ||
+                tryModule(type, module, &cfg->weather) ||
+                tryModule(type, module, &cfg->wm) ||
+                tryModule(type, module, &cfg->wifi) ||
+                tryModule(type, module, &cfg->wmTheme) ||
                 false;
         }
 
diff --git a/src/common/option.h b/src/common/option.h
index 2ff3f0828..724ca7c5a 100644
--- a/src/common/option.h
+++ b/src/common/option.h
@@ -1,6 +1,30 @@
 #pragma once
 
 #include "util/FFstrbuf.h"
+#include "3rdparty/yyjson/yyjson.h"
+
+// Must be the first field of FFModuleOptions
+typedef struct FFModuleBaseInfo
+{
+    const char* name;
+    void (*parseCommandOptions)(void* options, const char* key, const char* value);
+    void (*parseJsonObject)(void* options, yyjson_val *module);
+    void (*printModule)(void* options);
+} FFModuleBaseInfo;
+
+static inline void ffOptionInitModuleBaseInfo(
+    FFModuleBaseInfo* baseInfo,
+    const char* name,
+    void* parseCommandOptions, // void (*const parseCommandOptions)(void* options, const char* key, const char* value)
+    void* parseJsonObject, // void (*const parseJsonObject)(void* options, yyjson_val *module)
+    void* printModule // void (*const printModule)(void* options)
+)
+{
+    baseInfo->name = name;
+    baseInfo->parseCommandOptions = parseCommandOptions;
+    baseInfo->parseJsonObject = parseJsonObject;
+    baseInfo->printModule = printModule;
+}
 
 typedef struct FFModuleArgs
 {
diff --git a/src/fastfetch.c b/src/fastfetch.c
index 1625126bd..4f338f116 100644
--- a/src/fastfetch.c
+++ b/src/fastfetch.c
@@ -1062,59 +1062,60 @@ static void parseOption(FFdata* data, const char* key, const char* 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(ffParseBatteryCommandOptions(&instance.config.battery, key, value)) {}
     else if(ffParseBiosCommandOptions(&instance.config.bios, key, value)) {}
+    else if(ffParseBluetoothCommandOptions(&instance.config.bluetooth, 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(ffParseBreakCommandOptions(&instance.config.break_, key, value)) {}
     else if(ffParseBrightnessCommandOptions(&instance.config.brightness, key, value)) {}
-    else if(ffParseMonitorCommandOptions(&instance.config.nativeResolution, 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(ffParseTitleCommandOptions(&instance.config.title, 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(ffParseCPUCommandOptions(&instance.config.cpu, key, value)) {}
+    else if(ffParseCPUUsageCommandOptions(&instance.config.cpuUsage, key, value)) {}
+    else if(ffParseChassisCommandOptions(&instance.config.chassis, key, value)) {}
+    else if(ffParseColorsCommandOptions(&instance.config.colors, key, value)) {}
+    else if(ffParseCommandCommandOptions(&instance.config.command, key, value)) {}
     else if(ffParseCursorCommandOptions(&instance.config.cursor, key, value)) {}
+    else if(ffParseCustomCommandOptions(&instance.config.custom, key, value)) {}
+    else if(ffParseDECommandOptions(&instance.config.de, key, value)) {}
+    else if(ffParseDateTimeCommandOptions(&instance.config.dateTime, key, value)) {}
+    else if(ffParseDiskCommandOptions(&instance.config.disk, key, value)) {}
+    else if(ffParseDisplayCommandOptions(&instance.config.display, key, value)) {}
+    else if(ffParseFontCommandOptions(&instance.config.font, key, value)) {}
+    else if(ffParseGPUCommandOptions(&instance.config.gpu, key, value)) {}
+    else if(ffParseGamepadCommandOptions(&instance.config.gamepad, key, value)) {}
+    else if(ffParseHostCommandOptions(&instance.config.host, key, value)) {}
+    else if(ffParseIconsCommandOptions(&instance.config.icons, key, value)) {}
+    else if(ffParseKernelCommandOptions(&instance.config.kernel, key, value)) {}
+    else if(ffParseLocalIpCommandOptions(&instance.config.localIP, key, value)) {}
+    else if(ffParseLocaleCommandOptions(&instance.config.locale, key, value)) {}
+    else if(ffParseMediaCommandOptions(&instance.config.media, key, value)) {}
+    else if(ffParseMemoryCommandOptions(&instance.config.memory, key, value)) {}
+    else if(ffParseMonitorCommandOptions(&instance.config.monitor, key, value)) {}
+    else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
+    else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {}
+    else if(ffParseOpenCLCommandOptions(&instance.config.openCL, key, value)) {}
+    else if(ffParseOpenGLCommandOptions(&instance.config.openGL, key, value)) {}
+    else if(ffParsePackagesCommandOptions(&instance.config.packages, key, value)) {}
+    else if(ffParsePlayerCommandOptions(&instance.config.player, key, value)) {}
+    else if(ffParsePowerAdapterCommandOptions(&instance.config.powerAdapter, key, value)) {}
+    else if(ffParseProcessesCommandOptions(&instance.config.processes, key, value)) {}
+    else if(ffParsePublicIpCommandOptions(&instance.config.publicIP, key, value)) {}
+    else if(ffParseSeparatorCommandOptions(&instance.config.separator, key, value)) {}
+    else if(ffParseShellCommandOptions(&instance.config.shell, key, value)) {}
+    else if(ffParseSoundCommandOptions(&instance.config.sound, key, value)) {}
+    else if(ffParseSwapCommandOptions(&instance.config.swap, key, value)) {}
     else if(ffParseTerminalCommandOptions(&instance.config.terminal, key, value)) {}
     else if(ffParseTerminalFontCommandOptions(&instance.config.terminalFont, key, value)) {}
     else if(ffParseTerminalSizeCommandOptions(&instance.config.terminalSize, 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(ffParseThemeCommandOptions(&instance.config.theme, key, value)) {}
+    else if(ffParseTitleCommandOptions(&instance.config.title, key, value)) {}
+    else if(ffParseUptimeCommandOptions(&instance.config.uptime, 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(ffParseVulkanCommandOptions(&instance.config.vulkan, key, value)) {}
+    else if(ffParseWMCommandOptions(&instance.config.wm, key, value)) {}
+    else if(ffParseWMThemeCommandOptions(&instance.config.wmTheme, key, value)) {}
+    else if(ffParseWallpaperCommandOptions(&instance.config.wallpaper, key, value)) {}
+    else if(ffParseWeatherCommandOptions(&instance.config.weather, key, value)) {}
+    else if(ffParseWifiCommandOptions(&instance.config.wifi, key, value)) {}
 
     ///////////////////
     //Library options//
@@ -1235,6 +1236,166 @@ static void parseArguments(FFdata* data, int argc, const char** argv)
     }
 }
 
+static inline bool tryModule(const char* type, void* options)
+{
+    FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options;
+    if (ffStrEqualsIgnCase(type, baseInfo->name))
+    {
+        baseInfo->printModule(options);
+        return true;
+    }
+    return false;
+}
+
+static bool parseModuleCommand(const char* type)
+{
+    FFconfig* cfg = &instance.config;
+    switch (toupper(type[0]))
+    {
+        case 'B': {
+            return
+                tryModule(type, &cfg->battery) ||
+                tryModule(type, &cfg->bios) ||
+                tryModule(type, &cfg->bluetooth) ||
+                tryModule(type, &cfg->board) ||
+                tryModule(type, &cfg->break_) ||
+                tryModule(type, &cfg->brightness) ||
+                false;
+        }
+
+        case 'C': {
+            return
+                tryModule(type, &cfg->chassis) ||
+                tryModule(type, &cfg->command) ||
+                tryModule(type, &cfg->colors) ||
+                tryModule(type, &cfg->cpu) ||
+                tryModule(type, &cfg->cpuUsage) ||
+                tryModule(type, &cfg->cursor) ||
+                tryModule(type, &cfg->custom) ||
+                false;
+        }
+
+        case 'D': {
+            return
+                tryModule(type, &cfg->dateTime) ||
+                tryModule(type, &cfg->de) ||
+                tryModule(type, &cfg->display) ||
+                tryModule(type, &cfg->disk) ||
+                false;
+        }
+
+        case 'F': {
+            return
+                tryModule(type, &cfg->font) ||
+                false;
+        }
+
+        case 'G': {
+            return
+                tryModule(type, &cfg->gamepad) ||
+                tryModule(type, &cfg->gpu) ||
+                false;
+        }
+
+        case 'H': {
+            return
+                tryModule(type, &cfg->host) ||
+                false;
+        }
+
+        case 'I': {
+            return
+                tryModule(type, &cfg->icons) ||
+                false;
+        }
+
+        case 'K': {
+            return
+                tryModule(type, &cfg->kernel) ||
+                false;
+        }
+
+        case 'L': {
+            return
+                tryModule(type, &cfg->lm) ||
+                tryModule(type, &cfg->locale) ||
+                tryModule(type, &cfg->localIP) ||
+                false;
+        }
+
+        case 'M': {
+            return
+                tryModule(type, &cfg->media) ||
+                tryModule(type, &cfg->memory) ||
+                tryModule(type, &cfg->monitor) ||
+                false;
+        }
+
+        case 'O': {
+            return
+                tryModule(type, &cfg->openCL) ||
+                tryModule(type, &cfg->openGL) ||
+                tryModule(type, &cfg->os) ||
+                false;
+        }
+
+        case 'P': {
+            return
+                tryModule(type, &cfg->packages) ||
+                tryModule(type, &cfg->player) ||
+                tryModule(type, &cfg->powerAdapter) ||
+                tryModule(type, &cfg->processes) ||
+                tryModule(type, &cfg->publicIP) ||
+                false;
+        }
+
+        case 'S': {
+            return
+                tryModule(type, &cfg->separator) ||
+                tryModule(type, &cfg->shell) ||
+                tryModule(type, &cfg->sound) ||
+                tryModule(type, &cfg->swap) ||
+                false;
+        }
+
+        case 'T': {
+            return
+                tryModule(type, &cfg->terminal) ||
+                tryModule(type, &cfg->terminalFont) ||
+                tryModule(type, &cfg->terminalSize) ||
+                tryModule(type, &cfg->title) ||
+                tryModule(type, &cfg->theme) ||
+                false;
+        }
+
+        case 'U': {
+            return
+                tryModule(type, &cfg->uptime) ||
+                tryModule(type, &cfg->users) ||
+                false;
+        }
+
+        case 'V': {
+            return
+                tryModule(type, &cfg->vulkan) ||
+                false;
+        }
+
+        case 'W': {
+            return
+                tryModule(type, &cfg->wallpaper) ||
+                tryModule(type, &cfg->weather) ||
+                tryModule(type, &cfg->wm) ||
+                tryModule(type, &cfg->wifi) ||
+                tryModule(type, &cfg->wmTheme) ||
+                false;
+        }
+
+        default:
+            return false;
+    }
+}
+
 static void parseStructureCommand(const char* line, FFlist* customValues)
 {
     // handle `--set` and `--set-keyless`
@@ -1252,152 +1413,8 @@ static void parseStructureCommand(const char* line, FFlist* customValues)
         }
     }
 
-    switch (toupper(line[0]))
-    {
-        case 'B':
-            if(ffStrEqualsIgnCase(line, FF_BATTERY_MODULE_NAME))
-                return ffPrintBattery(&instance.config.battery);
-            if(ffStrEqualsIgnCase(line, FF_BIOS_MODULE_NAME))
-                return ffPrintBios(&instance.config.bios);
-            if(ffStrEqualsIgnCase(line, FF_BLUETOOTH_MODULE_NAME))
-                return ffPrintBluetooth(&instance.config.bluetooth);
-            if(ffStrEqualsIgnCase(line, FF_BOARD_MODULE_NAME))
-                return ffPrintBoard(&instance.config.board);
-            if(ffStrEqualsIgnCase(line, FF_BREAK_MODULE_NAME))
-                return ffPrintBreak();
-            if(ffStrEqualsIgnCase(line, FF_BRIGHTNESS_MODULE_NAME))
-                return ffPrintBrightness(&instance.config.brightness);
-            break;
-        case 'C':
-            if(ffStrEqualsIgnCase(line, FF_CHASSIS_MODULE_NAME))
-                return ffPrintChassis(&instance.config.chassis);
-            if(ffStrEqualsIgnCase(line, FF_COMMAND_MODULE_NAME))
-                return ffPrintCommand(&instance.config.command);
-            if(ffStrEqualsIgnCase(line, FF_CPU_MODULE_NAME))
-                return ffPrintCPU(&instance.config.cpu);
-            if(ffStrEqualsIgnCase(line, FF_CPUUSAGE_MODULE_NAME))
-                return ffPrintCPUUsage(&instance.config.cpuUsage);
-            if(ffStrEqualsIgnCase(line, FF_COLORS_MODULE_NAME))
-                return ffPrintColors(&instance.config.colors);
-            if(ffStrEqualsIgnCase(line, FF_CURSOR_MODULE_NAME))
-                return ffPrintCursor(&instance.config.cursor);
-            if(ffStrEqualsIgnCase(line, FF_CUSTOM_MODULE_NAME))
-                return ffPrintCustom(&instance.config.custom);
-            break;
-        case 'D':
-            if(ffStrEqualsIgnCase(line, FF_DATETIME_MODULE_NAME))
-                return ffPrintDateTime(&instance.config.dateTime);
-            if(ffStrEqualsIgnCase(line, FF_DE_MODULE_NAME))
-                return ffPrintDE(&instance.config.de);
-            if(ffStrEqualsIgnCase(line, FF_DISPLAY_MODULE_NAME))
-                return ffPrintDisplay(&instance.config.display);
-            if(ffStrEqualsIgnCase(line, FF_DISK_MODULE_NAME))
-                return ffPrintDisk(&instance.config.disk);
-            break;
-        case 'F':
-            if(ffStrEqualsIgnCase(line, FF_FONT_MODULE_NAME))
-                return ffPrintFont(&instance.config.font);
-            break;
-        case 'G':
-            if(ffStrEqualsIgnCase(line, FF_GAMEPAD_MODULE_NAME))
-                return ffPrintGamepad(&instance.config.gamepad);
-            if(ffStrEqualsIgnCase(line, FF_GPU_MODULE_NAME))
-                return ffPrintGPU(&instance.config.gpu);
-            break;
-        case 'H':
-            if(ffStrEqualsIgnCase(line, FF_HOST_MODULE_NAME))
-                return ffPrintHost(&instance.config.host);
-            break;
-        case 'I':
-            if(ffStrEqualsIgnCase(line, FF_ICONS_MODULE_NAME))
-                return ffPrintIcons(&instance.config.icons);
-            break;
-        case 'K':
-            if(ffStrEqualsIgnCase(line, FF_KERNEL_MODULE_NAME))
-                return ffPrintKernel(&instance.config.kernel);
-            break;
-        case 'L':
-            if(ffStrEqualsIgnCase(line, FF_LM_MODULE_NAME))
-                return ffPrintLM(&instance.config.lm);
-            if(ffStrEqualsIgnCase(line, FF_LOCALE_MODULE_NAME))
-                return ffPrintLocale(&instance.config.locale);
-            if(ffStrEqualsIgnCase(line, FF_LOCALIP_MODULE_NAME))
-                return ffPrintLocalIp(&instance.config.localIP);
-            break;
-        case 'M':
-            if(ffStrEqualsIgnCase(line, FF_MEDIA_MODULE_NAME))
-                return ffPrintMedia(&instance.config.media);
-            if(ffStrEqualsIgnCase(line, FF_MEMORY_MODULE_NAME))
-                return ffPrintMemory(&instance.config.memory);
-            if(ffStrEqualsIgnCase(line, FF_MONITOR_MODULE_NAME))
-                return ffPrintMonitor(&instance.config.nativeResolution);
-            break;
-        case 'O':
-            if(ffStrEqualsIgnCase(line, FF_OPENCL_MODULE_NAME))
-                return ffPrintOpenCL(&instance.config.openCL);
-            if(ffStrEqualsIgnCase(line, FF_OPENGL_MODULE_NAME))
-                return ffPrintOpenGL(&instance.config.openGL);
-            if(ffStrEqualsIgnCase(line, FF_OS_MODULE_NAME))
-                return ffPrintOS(&instance.config.os);
-            break;
-        case 'P':
-            if(ffStrEqualsIgnCase(line, FF_PACKAGES_MODULE_NAME))
-                return ffPrintPackages(&instance.config.packages);
-            if(ffStrEqualsIgnCase(line, FF_PLAYER_MODULE_NAME))
-                return ffPrintPlayer(&instance.config.player);
-            if(ffStrEqualsIgnCase(line, FF_POWERADAPTER_MODULE_NAME))
-                return ffPrintPowerAdapter(&instance.config.powerAdapter);
-            if(ffStrEqualsIgnCase(line, FF_PROCESSES_MODULE_NAME))
-                return ffPrintProcesses(&instance.config.processes);
-            if(ffStrEqualsIgnCase(line, FF_PUBLICIP_MODULE_NAME))
-                return ffPrintPublicIp(&instance.config.publicIP);
-            break;
-        case 'S':
-            if(ffStrEqualsIgnCase(line, FF_SEPARATOR_MODULE_NAME))
-                return ffPrintSeparator(&instance.config.separator);
-            if(ffStrEqualsIgnCase(line, FF_SHELL_MODULE_NAME))
-                return ffPrintShell(&instance.config.shell);
-            if(ffStrEqualsIgnCase(line, FF_SOUND_MODULE_NAME))
-                return ffPrintSound(&instance.config.sound);
-            if(ffStrEqualsIgnCase(line, FF_SWAP_MODULE_NAME))
-                return ffPrintSwap(&instance.config.swap);
-            break;
-        case 'T':
-            if(ffStrEqualsIgnCase(line, FF_TERMINAL_MODULE_NAME))
-                return ffPrintTerminal(&instance.config.terminal);
-            if(ffStrEqualsIgnCase(line, FF_TERMINALFONT_MODULE_NAME))
-                return ffPrintTerminalFont(&instance.config.terminalFont);
-            if(ffStrEqualsIgnCase(line, FF_TERMINALSIZE_MODULE_NAME))
-                return ffPrintTerminalSize(&instance.config.terminalSize);
-            if(ffStrEqualsIgnCase(line, FF_TITLE_MODULE_NAME))
-                return ffPrintTitle(&instance.config.title);
-            if(ffStrEqualsIgnCase(line, FF_THEME_MODULE_NAME))
-                return ffPrintTheme(&instance.config.theme);
-            break;
-        case 'U':
-            if(ffStrEqualsIgnCase(line, FF_UPTIME_MODULE_NAME))
-                return ffPrintUptime(&instance.config.uptime);
-            if(ffStrEqualsIgnCase(line, FF_USERS_MODULE_NAME))
-                return ffPrintUsers(&instance.config.users);
-            break;
-        case 'V':
-            if(ffStrEqualsIgnCase(line, FF_VULKAN_MODULE_NAME))
-                return ffPrintVulkan(&instance.config.vulkan);
-            break;
-        case 'W':
-            if(ffStrEqualsIgnCase(line, FF_WALLPAPER_MODULE_NAME))
-                return ffPrintWallpaper(&instance.config.wallpaper);
-            if(ffStrEqualsIgnCase(line, FF_WEATHER_MODULE_NAME))
-                return ffPrintWeather(&instance.config.weather);
-            if(ffStrEqualsIgnCase(line, FF_WIFI_MODULE_NAME))
-                return ffPrintWifi(&instance.config.wifi);
-            if(ffStrEqualsIgnCase(line, FF_WM_MODULE_NAME))
-                return ffPrintWM(&instance.config.wm);
-            if(ffStrEqualsIgnCase(line, FF_WMTHEME_MODULE_NAME))
-                return ffPrintWMTheme(&instance.config.wmTheme);
-            break;
-    }
-    ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
+    if(!parseModuleCommand(line))
+        ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
 }
 
 int main(int argc, const char** argv)
diff --git a/src/fastfetch.h b/src/fastfetch.h
index 3a493eea5..0cfa89287 100644
--- a/src/fastfetch.h
+++ b/src/fastfetch.h
@@ -117,7 +117,7 @@ typedef struct FFconfig
     FFWeatherOptions weather;
     FFPlayerOptions player;
     FFMediaOptions media;
-    FFMonitorOptions nativeResolution;
+    FFMonitorOptions monitor;
     FFDateTimeOptions dateTime;
     FFVulkanOptions vulkan;
     FFOpenGLOptions openGL;
@@ -127,6 +127,7 @@ typedef struct FFconfig
     FFSeparatorOptions separator;
     FFSoundOptions sound;
     FFGamepadOptions gamepad;
+    FFBreakOptions break_;
     FFColorsOptions colors;
 
     FFstrbuf libPCI;
diff --git a/src/flashfetch.c b/src/flashfetch.c
index 3417548f5..355238ac4 100644
--- a/src/flashfetch.c
+++ b/src/flashfetch.c
@@ -62,7 +62,7 @@ int main(void)
     //ffPrintBluetooth(&instance.config.bluetooth);
     //ffPrintSound(&instance.config.sound);
     //ffPrintGamepad(&instance.config.gamepad);
-    ffPrintBreak();
+    ffPrintBreak(&instance.config.break_);
     ffPrintColors(&instance.config.colors);
 
     ffFinish();
diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c
index 2dac37d05..9a10d4973 100644
--- a/src/modules/battery/battery.c
+++ b/src/modules/battery/battery.c
@@ -105,7 +105,7 @@ void ffPrintBattery(FFBatteryOptions* options)
 
 void ffInitBatteryOptions(FFBatteryOptions* options)
 {
-    options->moduleName = FF_BATTERY_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BATTERY_MODULE_NAME, ffParseBatteryCommandOptions, ffParseBatteryJsonObject, ffPrintBattery);
     ffOptionInitModuleArg(&options->moduleArgs);
     options->temp = false;
 
@@ -147,11 +147,8 @@ void ffDestroyBatteryOptions(FFBatteryOptions* options)
     #endif
 }
 
-void ffParseBatteryJsonObject(yyjson_val* module)
+void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module)
 {
-    FFBatteryOptions __attribute__((__cleanup__(ffDestroyBatteryOptions))) options;
-    ffInitBatteryOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -162,7 +159,7 @@ void ffParseBatteryJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             #ifdef __linux__
@@ -175,13 +172,11 @@ void ffParseBatteryJsonObject(yyjson_val* module)
 
             if (ffStrEqualsIgnCase(key, "temp"))
             {
-                options.temp = yyjson_get_bool(val);
+                options->temp = yyjson_get_bool(val);
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/battery/battery.h b/src/modules/battery/battery.h
index a57a3718c..26312bca7 100644
--- a/src/modules/battery/battery.h
+++ b/src/modules/battery/battery.h
@@ -9,4 +9,4 @@ void ffPrintBattery(FFBatteryOptions* options);
 void ffInitBatteryOptions(FFBatteryOptions* options);
 bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, const char* value);
 void ffDestroyBatteryOptions(FFBatteryOptions* options);
-void ffParseBatteryJsonObject(yyjson_val* module);
+void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module);
diff --git a/src/modules/battery/option.h b/src/modules/battery/option.h
index 73632b9c6..51bbb0c01 100644
--- a/src/modules/battery/option.h
+++ b/src/modules/battery/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFBatteryOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     bool temp;
diff --git a/src/modules/bios/bios.c b/src/modules/bios/bios.c
index 7aba0aef7..d1c9bb6f0 100644
--- a/src/modules/bios/bios.c
+++ b/src/modules/bios/bios.c
@@ -55,7 +55,7 @@ exit:
 
 void ffInitBiosOptions(FFBiosOptions* options)
 {
-    options->moduleName = FF_BIOS_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BIOS_MODULE_NAME, ffParseBiosCommandOptions, ffParseBiosJsonObject, ffPrintBios);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -74,11 +74,8 @@ void ffDestroyBiosOptions(FFBiosOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBiosJsonObject(yyjson_val* module)
+void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module)
 {
-    FFBiosOptions __attribute__((__cleanup__(ffDestroyBiosOptions))) options;
-    ffInitBiosOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -89,12 +86,10 @@ void ffParseBiosJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/bios/bios.h b/src/modules/bios/bios.h
index a82606f03..aaaf15d65 100644
--- a/src/modules/bios/bios.h
+++ b/src/modules/bios/bios.h
@@ -8,4 +8,4 @@ void ffPrintBios(FFBiosOptions* options);
 void ffInitBiosOptions(FFBiosOptions* options);
 bool ffParseBiosCommandOptions(FFBiosOptions* options, const char* key, const char* value);
 void ffDestroyBiosOptions(FFBiosOptions* options);
-void ffParseBiosJsonObject(yyjson_val* module);
+void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module);
diff --git a/src/modules/bios/option.h b/src/modules/bios/option.h
index 6c0f67420..483e7b664 100644
--- a/src/modules/bios/option.h
+++ b/src/modules/bios/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFBiosOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFBiosOptions;
diff --git a/src/modules/bluetooth/bluetooth.c b/src/modules/bluetooth/bluetooth.c
index 06bf1ce22..eed9d609b 100644
--- a/src/modules/bluetooth/bluetooth.c
+++ b/src/modules/bluetooth/bluetooth.c
@@ -75,7 +75,7 @@ void ffPrintBluetooth(FFBluetoothOptions* options)
 
 void ffInitBluetoothOptions(FFBluetoothOptions* options)
 {
-    options->moduleName = FF_BLUETOOTH_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothCommandOptions, ffParseBluetoothJsonObject, ffPrintBluetooth);
     ffOptionInitModuleArg(&options->moduleArgs);
     options->showDisconnected = false;
 }
@@ -101,11 +101,8 @@ void ffDestroyBluetoothOptions(FFBluetoothOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBluetoothJsonObject(yyjson_val* module)
+void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module)
 {
-    FFBluetoothOptions __attribute__((__cleanup__(ffDestroyBluetoothOptions))) options;
-    ffInitBluetoothOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -116,18 +113,16 @@ void ffParseBluetoothJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "showDisconnected"))
             {
-                options.showDisconnected = yyjson_get_bool(val);
+                options->showDisconnected = yyjson_get_bool(val);
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/bluetooth/bluetooth.h b/src/modules/bluetooth/bluetooth.h
index 1a54baf1d..411bb3965 100644
--- a/src/modules/bluetooth/bluetooth.h
+++ b/src/modules/bluetooth/bluetooth.h
@@ -8,4 +8,4 @@ void ffPrintBluetooth(FFBluetoothOptions* options);
 void ffInitBluetoothOptions(FFBluetoothOptions* options);
 bool ffParseBluetoothCommandOptions(FFBluetoothOptions* options, const char* key, const char* value);
 void ffDestroyBluetoothOptions(FFBluetoothOptions* options);
-void ffParseBluetoothJsonObject(yyjson_val* module);
+void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module);
diff --git a/src/modules/bluetooth/option.h b/src/modules/bluetooth/option.h
index b347dc466..bbe9e1c54 100644
--- a/src/modules/bluetooth/option.h
+++ b/src/modules/bluetooth/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFBluetoothOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     bool showDisconnected;
diff --git a/src/modules/board/board.c b/src/modules/board/board.c
index 6ad125896..6ce7a847a 100644
--- a/src/modules/board/board.c
+++ b/src/modules/board/board.c
@@ -51,7 +51,7 @@ exit:
 
 void ffInitBoardOptions(FFBoardOptions* options)
 {
-    options->moduleName = FF_BOARD_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BOARD_MODULE_NAME, ffParseBoardCommandOptions, ffParseBoardJsonObject, ffPrintBoard);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -70,11 +70,8 @@ void ffDestroyBoardOptions(FFBoardOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBoardJsonObject(yyjson_val* module)
+void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module)
 {
-    FFBoardOptions __attribute__((__cleanup__(ffDestroyBoardOptions))) options;
-    ffInitBoardOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseBoardJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/board/board.h b/src/modules/board/board.h
index 112eabbf2..f5531368e 100644
--- a/src/modules/board/board.h
+++ b/src/modules/board/board.h
@@ -8,4 +8,4 @@ void ffPrintBoard(FFBoardOptions* options);
 void ffInitBoardOptions(FFBoardOptions* options);
 bool ffParseBoardCommandOptions(FFBoardOptions* options, const char* key, const char* value);
 void ffDestroyBoardOptions(FFBoardOptions* options);
-void ffParseBoardJsonObject(yyjson_val* module);
+void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module);
diff --git a/src/modules/board/option.h b/src/modules/board/option.h
index 582854d23..1640ff3d3 100644
--- a/src/modules/board/option.h
+++ b/src/modules/board/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFBoardOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFBoardOptions;
diff --git a/src/modules/break/break.c b/src/modules/break/break.c
index 1dc3c8e0a..87821ee00 100644
--- a/src/modules/break/break.c
+++ b/src/modules/break/break.c
@@ -1,13 +1,28 @@
 #include "common/printing.h"
 #include "modules/break/break.h"
 
-void ffPrintBreak(void)
+void ffPrintBreak(FF_MAYBE_UNUSED FFBreakOptions* options)
 {
     ffLogoPrintLine();
     putchar('\n');
 }
 
-void ffParseBreakJsonObject(FF_MAYBE_UNUSED yyjson_val* module)
+void ffInitBreakOptions(FF_MAYBE_UNUSED FFBreakOptions* options)
 {
-    return ffPrintBreak();
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BREAK_MODULE_NAME, ffParseBreakCommandOptions, ffParseBreakJsonObject, ffPrintBreak);
+}
+
+bool ffParseBreakCommandOptions(FF_MAYBE_UNUSED FFBreakOptions* options, FF_MAYBE_UNUSED const char* key, FF_MAYBE_UNUSED const char* value)
+{
+    return false;
+}
+
+void ffDestroyBreakOptions(FF_MAYBE_UNUSED FFBreakOptions* options)
+{
+}
+
+void ffParseBreakJsonObject(FF_MAYBE_UNUSED FFBreakOptions* options, FF_MAYBE_UNUSED yyjson_val* module)
+{
+    ffPrintBreak(options);
+    return;
 }
diff --git a/src/modules/break/break.h b/src/modules/break/break.h
index f87c81d3d..155548cf6 100644
--- a/src/modules/break/break.h
+++ b/src/modules/break/break.h
@@ -4,5 +4,8 @@
 
 #define FF_BREAK_MODULE_NAME "Break"
 
-void ffPrintBreak();
-void ffParseBreakJsonObject(yyjson_val* module);
+void ffPrintBreak(FFBreakOptions* options);
+void ffInitBreakOptions(FFBreakOptions* options);
+bool ffParseBreakCommandOptions(FFBreakOptions* options, const char* key, const char* value);
+void ffDestroyBreakOptions(FFBreakOptions* options);
+void ffParseBreakJsonObject(FFBreakOptions* options, yyjson_val* module);
diff --git a/src/modules/break/option.h b/src/modules/break/option.h
new file mode 100644
index 000000000..4d2870c26
--- /dev/null
+++ b/src/modules/break/option.h
@@ -0,0 +1,10 @@
+#pragma once
+
+// This file will be included in "fastfetch.h", do NOT put unnecessary things here
+
+#include "common/option.h"
+
+typedef struct FFBreakOptions
+{
+    FFModuleBaseInfo moduleInfo;
+} FFBreakOptions;
diff --git a/src/modules/brightness/brightness.c b/src/modules/brightness/brightness.c
index 3e6a564c3..4a29ae751 100644
--- a/src/modules/brightness/brightness.c
+++ b/src/modules/brightness/brightness.c
@@ -80,7 +80,7 @@ void ffPrintBrightness(FFBrightnessOptions* options)
 
 void ffInitBrightnessOptions(FFBrightnessOptions* options)
 {
-    options->moduleName = FF_BRIGHTNESS_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessCommandOptions, ffParseBrightnessJsonObject, ffPrintBrightness);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -99,11 +99,8 @@ void ffDestroyBrightnessOptions(FFBrightnessOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseBrightnessJsonObject(yyjson_val* module)
+void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* module)
 {
-    FFBrightnessOptions __attribute__((__cleanup__(ffDestroyBrightnessOptions))) options;
-    ffInitBrightnessOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -114,12 +111,10 @@ void ffParseBrightnessJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/brightness/brightness.h b/src/modules/brightness/brightness.h
index f9724d65c..1272e5d0f 100644
--- a/src/modules/brightness/brightness.h
+++ b/src/modules/brightness/brightness.h
@@ -8,4 +8,4 @@ void ffPrintBrightness(FFBrightnessOptions* options);
 void ffInitBrightnessOptions(FFBrightnessOptions* options);
 bool ffParseBrightnessCommandOptions(FFBrightnessOptions* options, const char* key, const char* value);
 void ffDestroyBrightnessOptions(FFBrightnessOptions* options);
-void ffParseBrightnessJsonObject(yyjson_val* module);
+void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* module);
diff --git a/src/modules/brightness/option.h b/src/modules/brightness/option.h
index 803ea4792..aa67ac190 100644
--- a/src/modules/brightness/option.h
+++ b/src/modules/brightness/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFBrightnessOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFBrightnessOptions;
diff --git a/src/modules/chassis/chassis.c b/src/modules/chassis/chassis.c
index 53ee101ad..baf5a9ec4 100644
--- a/src/modules/chassis/chassis.c
+++ b/src/modules/chassis/chassis.c
@@ -52,7 +52,7 @@ exit:
 
 void ffInitChassisOptions(FFChassisOptions* options)
 {
-    options->moduleName = FF_CHASSIS_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CHASSIS_MODULE_NAME, ffParseChassisCommandOptions, ffParseChassisJsonObject, ffPrintChassis);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -71,11 +71,8 @@ void ffDestroyChassisOptions(FFChassisOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseChassisJsonObject(yyjson_val* module)
+void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module)
 {
-    FFChassisOptions __attribute__((__cleanup__(ffDestroyChassisOptions))) options;
-    ffInitChassisOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -86,12 +83,10 @@ void ffParseChassisJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/chassis/chassis.h b/src/modules/chassis/chassis.h
index 0526608da..5fe4bb62f 100644
--- a/src/modules/chassis/chassis.h
+++ b/src/modules/chassis/chassis.h
@@ -8,4 +8,4 @@ void ffPrintChassis(FFChassisOptions* options);
 void ffInitChassisOptions(FFChassisOptions* options);
 bool ffParseChassisCommandOptions(FFChassisOptions* options, const char* key, const char* value);
 void ffDestroyChassisOptions(FFChassisOptions* options);
-void ffParseChassisJsonObject(yyjson_val* module);
+void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module);
diff --git a/src/modules/chassis/option.h b/src/modules/chassis/option.h
index 939fd165d..de6338cd5 100644
--- a/src/modules/chassis/option.h
+++ b/src/modules/chassis/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFChassisOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFChassisOptions;
diff --git a/src/modules/colors/colors.c b/src/modules/colors/colors.c
index 0cceb28e8..e1ec1a90c 100644
--- a/src/modules/colors/colors.c
+++ b/src/modules/colors/colors.c
@@ -57,7 +57,7 @@ void ffPrintColors(FFColorsOptions* options)
 
 void ffInitColorsOptions(FFColorsOptions* options)
 {
-    options->moduleName = FF_COLORS_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_COLORS_MODULE_NAME, ffParseColorsCommandOptions, ffParseColorsJsonObject, ffPrintColors);
     options->symbol = FF_COLORS_SYMBOL_BLOCK;
     options->paddingLeft = 0;
 }
@@ -94,11 +94,8 @@ void ffDestroyColorsOptions(FF_MAYBE_UNUSED FFColorsOptions* options)
 {
 }
 
-void ffParseColorsJsonObject(yyjson_val* module)
+void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module)
 {
-    FFColorsOptions __attribute__((__cleanup__(ffDestroyColorsOptions))) options;
-    ffInitColorsOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -124,19 +121,17 @@ void ffParseColorsJsonObject(yyjson_val* module)
                 if (error)
                     ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error);
                 else
-                    options.symbol = (FFColorsSymbol) value;
+                    options->symbol = (FFColorsSymbol) value;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "paddingLeft"))
             {
-                options.paddingLeft = (uint32_t) yyjson_get_uint(val);
+                options->paddingLeft = (uint32_t) yyjson_get_uint(val);
                 continue;
             }
 
             ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key);
         }
     }
-
-    ffPrintColors(&options);
 }
diff --git a/src/modules/colors/colors.h b/src/modules/colors/colors.h
index 64ebe96c8..674bcd817 100644
--- a/src/modules/colors/colors.h
+++ b/src/modules/colors/colors.h
@@ -8,4 +8,4 @@ void ffPrintColors(FFColorsOptions* options);
 void ffInitColorsOptions(FFColorsOptions* options);
 void ffDestroyColorsOptions(FFColorsOptions* options);
 bool ffParseColorsCommandOptions(FFColorsOptions* options, const char* key, const char* value);
-void ffParseColorsJsonObject(yyjson_val* module);
+void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module);
diff --git a/src/modules/colors/option.h b/src/modules/colors/option.h
index afcb23fb6..a17029bd8 100644
--- a/src/modules/colors/option.h
+++ b/src/modules/colors/option.h
@@ -16,7 +16,7 @@ typedef enum FFColorsSymbol
 
 typedef struct FFColorsOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFColorsSymbol symbol;
     uint32_t paddingLeft;
 } FFColorsOptions;
diff --git a/src/modules/command/command.c b/src/modules/command/command.c
index c4390fc0d..de25c5004 100644
--- a/src/modules/command/command.c
+++ b/src/modules/command/command.c
@@ -36,7 +36,7 @@ void ffPrintCommand(FFCommandOptions* options)
 
 void ffInitCommandOptions(FFCommandOptions* options)
 {
-    options->moduleName = FF_COMMAND_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_COMMAND_MODULE_NAME, ffParseCommandCommandOptions, ffParseCommandJsonObject, ffPrintCommand);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     ffStrbufInitStatic(&options->shell,
@@ -79,11 +79,8 @@ void ffDestroyCommandOptions(FFCommandOptions* options)
     ffStrbufDestroy(&options->text);
 }
 
-void ffParseCommandJsonObject(yyjson_val* module)
+void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module)
 {
-    FFCommandOptions __attribute__((__cleanup__(ffDestroyCommandOptions))) options;
-    ffInitCommandOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -94,24 +91,22 @@ void ffParseCommandJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "shell"))
             {
-                ffStrbufSetS(&options.shell, yyjson_get_str(val));
+                ffStrbufSetS(&options->shell, yyjson_get_str(val));
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "text"))
             {
-                ffStrbufSetS(&options.text, yyjson_get_str(val));
+                ffStrbufSetS(&options->text, yyjson_get_str(val));
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/command/command.h b/src/modules/command/command.h
index eca179b35..8ee5cc82c 100644
--- a/src/modules/command/command.h
+++ b/src/modules/command/command.h
@@ -8,4 +8,4 @@ void ffPrintCommand(FFCommandOptions* options);
 void ffInitCommandOptions(FFCommandOptions* options);
 bool ffParseCommandCommandOptions(FFCommandOptions* options, const char* key, const char* value);
 void ffDestroyCommandOptions(FFCommandOptions* options);
-void ffParseCommandJsonObject(yyjson_val* module);
+void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module);
diff --git a/src/modules/command/option.h b/src/modules/command/option.h
index 41d3408a4..6aab8a3c2 100644
--- a/src/modules/command/option.h
+++ b/src/modules/command/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFCommandOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFstrbuf shell;
diff --git a/src/modules/cpu/cpu.c b/src/modules/cpu/cpu.c
index fe4379243..5556c2e58 100644
--- a/src/modules/cpu/cpu.c
+++ b/src/modules/cpu/cpu.c
@@ -79,7 +79,7 @@ void ffPrintCPU(FFCPUOptions* options)
 
 void ffInitCPUOptions(FFCPUOptions* options)
 {
-    options->moduleName = FF_CPU_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CPU_MODULE_NAME, ffParseCPUCommandOptions, ffParseCPUJsonObject, ffPrintCPU);
     ffOptionInitModuleArg(&options->moduleArgs);
     options->temp = false;
 }
@@ -105,11 +105,8 @@ void ffDestroyCPUOptions(FFCPUOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCPUJsonObject(yyjson_val* module)
+void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module)
 {
-    FFCPUOptions __attribute__((__cleanup__(ffDestroyCPUOptions))) options;
-    ffInitCPUOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -120,18 +117,16 @@ void ffParseCPUJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "temp"))
             {
-                options.temp = yyjson_get_bool(val);
+                options->temp = yyjson_get_bool(val);
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/cpu/cpu.h b/src/modules/cpu/cpu.h
index 731149d5b..acff0a13c 100644
--- a/src/modules/cpu/cpu.h
+++ b/src/modules/cpu/cpu.h
@@ -8,4 +8,4 @@ void ffPrintCPU(FFCPUOptions* options);
 void ffInitCPUOptions(FFCPUOptions* options);
 bool ffParseCPUCommandOptions(FFCPUOptions* options, const char* key, const char* value);
 void ffDestroyCPUOptions(FFCPUOptions* options);
-void ffParseCPUJsonObject(yyjson_val* module);
+void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module);
diff --git a/src/modules/cpu/option.h b/src/modules/cpu/option.h
index 9e54bfeaf..1902ddfc2 100644
--- a/src/modules/cpu/option.h
+++ b/src/modules/cpu/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFCPUOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     bool temp;
diff --git a/src/modules/cpuusage/cpuusage.c b/src/modules/cpuusage/cpuusage.c
index 263fe109f..59a4ae3cc 100644
--- a/src/modules/cpuusage/cpuusage.c
+++ b/src/modules/cpuusage/cpuusage.c
@@ -44,7 +44,7 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options)
 
 void ffInitCPUUsageOptions(FFCPUUsageOptions* options)
 {
-    options->moduleName = FF_CPUUSAGE_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageCommandOptions, ffParseCPUUsageJsonObject, ffPrintCPUUsage);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -63,11 +63,8 @@ void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCPUUsageJsonObject(yyjson_val* module)
+void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module)
 {
-    FFCPUUsageOptions __attribute__((__cleanup__(ffDestroyCPUUsageOptions))) options;
-    ffInitCPUUsageOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -78,12 +75,10 @@ void ffParseCPUUsageJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/cpuusage/cpuusage.h b/src/modules/cpuusage/cpuusage.h
index e0275a5ea..5a221f554 100644
--- a/src/modules/cpuusage/cpuusage.h
+++ b/src/modules/cpuusage/cpuusage.h
@@ -10,4 +10,4 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options);
 void ffInitCPUUsageOptions(FFCPUUsageOptions* options);
 bool ffParseCPUUsageCommandOptions(FFCPUUsageOptions* options, const char* key, const char* value);
 void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options);
-void ffParseCPUUsageJsonObject(yyjson_val* module);
+void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module);
diff --git a/src/modules/cpuusage/option.h b/src/modules/cpuusage/option.h
index c779b6c5a..946855301 100644
--- a/src/modules/cpuusage/option.h
+++ b/src/modules/cpuusage/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFCPUUsageOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFCPUUsageOptions;
diff --git a/src/modules/cursor/cursor.c b/src/modules/cursor/cursor.c
index 7a5602f5d..a011643e3 100644
--- a/src/modules/cursor/cursor.c
+++ b/src/modules/cursor/cursor.c
@@ -52,7 +52,7 @@ void ffPrintCursor(FFCursorOptions* options)
 
 void ffInitCursorOptions(FFCursorOptions* options)
 {
-    options->moduleName = FF_CURSOR_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CURSOR_MODULE_NAME, ffParseCursorCommandOptions, ffParseCursorJsonObject, ffPrintCursor);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -71,11 +71,8 @@ void ffDestroyCursorOptions(FFCursorOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCursorJsonObject(yyjson_val* module)
+void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module)
 {
-    FFCursorOptions __attribute__((__cleanup__(ffDestroyCursorOptions))) options;
-    ffInitCursorOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -86,12 +83,10 @@ void ffParseCursorJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/cursor/cursor.h b/src/modules/cursor/cursor.h
index 5c23741a2..ff849b547 100644
--- a/src/modules/cursor/cursor.h
+++ b/src/modules/cursor/cursor.h
@@ -8,4 +8,4 @@ void ffPrintCursor(FFCursorOptions* options);
 void ffInitCursorOptions(FFCursorOptions* options);
 bool ffParseCursorCommandOptions(FFCursorOptions* options, const char* key, const char* value);
 void ffDestroyCursorOptions(FFCursorOptions* options);
-void ffParseCursorJsonObject(yyjson_val* module);
+void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module);
diff --git a/src/modules/cursor/option.h b/src/modules/cursor/option.h
index 9a648c844..26c2bb9f4 100644
--- a/src/modules/cursor/option.h
+++ b/src/modules/cursor/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFCursorOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFCursorOptions;
diff --git a/src/modules/custom/custom.c b/src/modules/custom/custom.c
index b7b679241..f1f4a2d81 100644
--- a/src/modules/custom/custom.c
+++ b/src/modules/custom/custom.c
@@ -19,7 +19,7 @@ void ffPrintCustom(FFCustomOptions* options)
 
 void ffInitCustomOptions(FFCustomOptions* options)
 {
-    options->moduleName = FF_CUSTOM_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CUSTOM_MODULE_NAME, ffParseCustomCommandOptions, ffParseCustomJsonObject, ffPrintCustom);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -38,11 +38,8 @@ void ffDestroyCustomOptions(FFCustomOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseCustomJsonObject(yyjson_val* module)
+void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module)
 {
-    FFCustomOptions __attribute__((__cleanup__(ffDestroyCustomOptions))) options;
-    ffInitCustomOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -53,12 +50,10 @@ void ffParseCustomJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/custom/custom.h b/src/modules/custom/custom.h
index 6d1981d7c..4c4c40b5d 100644
--- a/src/modules/custom/custom.h
+++ b/src/modules/custom/custom.h
@@ -8,4 +8,4 @@ void ffPrintCustom(FFCustomOptions* options);
 void ffInitCustomOptions(FFCustomOptions* options);
 bool ffParseCustomCommandOptions(FFCustomOptions* options, const char* key, const char* value);
 void ffDestroyCustomOptions(FFCustomOptions* options);
-void ffParseCustomJsonObject(yyjson_val* module);
+void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module);
diff --git a/src/modules/custom/option.h b/src/modules/custom/option.h
index f2b238831..b0776a833 100644
--- a/src/modules/custom/option.h
+++ b/src/modules/custom/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFCustomOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFCustomOptions;
diff --git a/src/modules/datetime/datetime.c b/src/modules/datetime/datetime.c
index 7d2cbd941..a89d5238a 100644
--- a/src/modules/datetime/datetime.c
+++ b/src/modules/datetime/datetime.c
@@ -51,7 +51,7 @@ void ffPrintDateTime(FFDateTimeOptions* options)
 
 void ffInitDateTimeOptions(FFDateTimeOptions* options)
 {
-    options->moduleName = FF_DATETIME_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DATETIME_MODULE_NAME, ffParseDateTimeCommandOptions, ffParseDateTimeJsonObject, ffPrintDateTime);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -70,11 +70,8 @@ void ffDestroyDateTimeOptions(FFDateTimeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDateTimeJsonObject(yyjson_val* module)
+void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module)
 {
-    FFDateTimeOptions __attribute__((__cleanup__(ffDestroyDateTimeOptions))) options;
-    ffInitDateTimeOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseDateTimeJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/datetime/datetime.h b/src/modules/datetime/datetime.h
index 269343711..6ccb30b27 100644
--- a/src/modules/datetime/datetime.h
+++ b/src/modules/datetime/datetime.h
@@ -8,4 +8,4 @@ void ffPrintDateTime(FFDateTimeOptions* options);
 void ffInitDateTimeOptions(FFDateTimeOptions* options);
 bool ffParseDateTimeCommandOptions(FFDateTimeOptions* options, const char* key, const char* value);
 void ffDestroyDateTimeOptions(FFDateTimeOptions* options);
-void ffParseDateTimeJsonObject(yyjson_val* module);
+void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module);
diff --git a/src/modules/datetime/option.h b/src/modules/datetime/option.h
index 1c32501e6..f9d25cfe3 100644
--- a/src/modules/datetime/option.h
+++ b/src/modules/datetime/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFDateTimeOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFDateTimeOptions;
diff --git a/src/modules/de/de.c b/src/modules/de/de.c
index db3c775b5..e4abefd0b 100644
--- a/src/modules/de/de.c
+++ b/src/modules/de/de.c
@@ -42,7 +42,7 @@ void ffPrintDE(FFDEOptions* options)
 
 void ffInitDEOptions(FFDEOptions* options)
 {
-    options->moduleName = FF_DE_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DE_MODULE_NAME, ffParseDECommandOptions, ffParseDEJsonObject, ffPrintDE);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -61,11 +61,8 @@ void ffDestroyDEOptions(FFDEOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDEJsonObject(yyjson_val* module)
+void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module)
 {
-    FFDEOptions __attribute__((__cleanup__(ffDestroyDEOptions))) options;
-    ffInitDEOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -76,12 +73,10 @@ void ffParseDEJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/de/de.h b/src/modules/de/de.h
index 267665584..0a4e14541 100644
--- a/src/modules/de/de.h
+++ b/src/modules/de/de.h
@@ -8,4 +8,4 @@ void ffPrintDE(FFDEOptions* options);
 void ffInitDEOptions(FFDEOptions* options);
 bool ffParseDECommandOptions(FFDEOptions* options, const char* key, const char* value);
 void ffDestroyDEOptions(FFDEOptions* options);
-void ffParseDEJsonObject(yyjson_val* module);
+void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module);
diff --git a/src/modules/de/option.h b/src/modules/de/option.h
index 52b8954e7..8ad2b2000 100644
--- a/src/modules/de/option.h
+++ b/src/modules/de/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFDEOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFDEOptions;
diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c
index e79bcd692..a43a1537e 100644
--- a/src/modules/disk/disk.c
+++ b/src/modules/disk/disk.c
@@ -184,10 +184,9 @@ void ffPrintDisk(FFDiskOptions* options)
     }
 }
 
-
 void ffInitDiskOptions(FFDiskOptions* options)
 {
-    options->moduleName = FF_DISK_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DISK_MODULE_NAME, ffParseDiskCommandOptions, ffParseDiskJsonObject, ffPrintDisk);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     ffStrbufInit(&options->folders);
@@ -260,11 +259,8 @@ void ffDestroyDiskOptions(FFDiskOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDiskJsonObject(yyjson_val* module)
+void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module)
 {
-    FFDiskOptions __attribute__((__cleanup__(ffDestroyDiskOptions))) options;
-    ffInitDiskOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -275,54 +271,52 @@ void ffParseDiskJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "folders"))
             {
-                ffStrbufSetS(&options.folders, yyjson_get_str(val));
+                ffStrbufSetS(&options->folders, yyjson_get_str(val));
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "showExternal"))
             {
                 if (yyjson_get_bool(val))
-                    options.showTypes |= FF_DISK_TYPE_EXTERNAL_BIT;
+                    options->showTypes |= FF_DISK_TYPE_EXTERNAL_BIT;
                 else
-                    options.showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT;
+                    options->showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "showHidden"))
             {
                 if (yyjson_get_bool(val))
-                    options.showTypes |= FF_DISK_TYPE_HIDDEN_BIT;
+                    options->showTypes |= FF_DISK_TYPE_HIDDEN_BIT;
                 else
-                    options.showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT;
+                    options->showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "showSubvolumes"))
             {
                 if (yyjson_get_bool(val))
-                    options.showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT;
+                    options->showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT;
                 else
-                    options.showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT;
+                    options->showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "showUnknown"))
             {
                 if (yyjson_get_bool(val))
-                    options.showTypes |= FF_DISK_TYPE_UNKNOWN_BIT;
+                    options->showTypes |= FF_DISK_TYPE_UNKNOWN_BIT;
                 else
-                    options.showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT;
+                    options->showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT;
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/disk/disk.h b/src/modules/disk/disk.h
index aa508df14..1f71f766b 100644
--- a/src/modules/disk/disk.h
+++ b/src/modules/disk/disk.h
@@ -8,4 +8,4 @@ void ffPrintDisk(FFDiskOptions* options);
 void ffInitDiskOptions(FFDiskOptions* options);
 bool ffParseDiskCommandOptions(FFDiskOptions* options, const char* key, const char* value);
 void ffDestroyDiskOptions(FFDiskOptions* options);
-void ffParseDiskJsonObject(yyjson_val* module);
+void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module);
diff --git a/src/modules/disk/option.h b/src/modules/disk/option.h
index 702e5bcbf..07e603cd1 100644
--- a/src/modules/disk/option.h
+++ b/src/modules/disk/option.h
@@ -16,7 +16,7 @@ typedef enum FFDiskType
 
 typedef struct FFDiskOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFstrbuf folders;
diff --git a/src/modules/display/display.c b/src/modules/display/display.c
index 6b7980a62..7c11267aa 100644
--- a/src/modules/display/display.c
+++ b/src/modules/display/display.c
@@ -109,7 +109,7 @@ void ffPrintDisplay(FFDisplayOptions* options)
 
 void ffInitDisplayOptions(FFDisplayOptions* options)
 {
-    options->moduleName = FF_DISPLAY_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DISPLAY_MODULE_NAME, ffParseDisplayCommandOptions, ffParseDisplayJsonObject, ffPrintDisplay);
     ffOptionInitModuleArg(&options->moduleArgs);
     options->compactType = FF_DISPLAY_COMPACT_TYPE_NONE;
     options->preciseRefreshRate = false;
@@ -147,11 +147,8 @@ void ffDestroyDisplayOptions(FFDisplayOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseDisplayJsonObject(yyjson_val* module)
+void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module)
 {
-    FFDisplayOptions __attribute__((__cleanup__(ffDestroyDisplayOptions))) options;
-    ffInitDisplayOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -162,7 +159,7 @@ void ffParseDisplayJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "compactType"))
@@ -175,21 +172,19 @@ void ffParseDisplayJsonObject(yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(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;
+                    options->compactType = (FFDisplayCompactType) value;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "preciseRefreshRate"))
             {
-                options.preciseRefreshRate = yyjson_get_bool(val);
+                options->preciseRefreshRate = yyjson_get_bool(val);
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/display/display.h b/src/modules/display/display.h
index 66196f063..b2f757056 100644
--- a/src/modules/display/display.h
+++ b/src/modules/display/display.h
@@ -8,4 +8,4 @@ void ffPrintDisplay(FFDisplayOptions* options);
 void ffInitDisplayOptions(FFDisplayOptions* options);
 bool ffParseDisplayCommandOptions(FFDisplayOptions* options, const char* key, const char* value);
 void ffDestroyDisplayOptions(FFDisplayOptions* options);
-void ffParseDisplayJsonObject(yyjson_val* module);
+void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module);
diff --git a/src/modules/display/option.h b/src/modules/display/option.h
index 20def688c..70b4c2be0 100644
--- a/src/modules/display/option.h
+++ b/src/modules/display/option.h
@@ -13,7 +13,7 @@ typedef enum FFDisplayCompactType
 
 typedef struct FFDisplayOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFDisplayCompactType compactType;
diff --git a/src/modules/font/font.c b/src/modules/font/font.c
index 8bc328cd3..dee13f91b 100644
--- a/src/modules/font/font.c
+++ b/src/modules/font/font.c
@@ -45,7 +45,7 @@ void ffPrintFont(FFFontOptions* options)
 
 void ffInitFontOptions(FFFontOptions* options)
 {
-    options->moduleName = FF_FONT_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_FONT_MODULE_NAME, ffParseFontCommandOptions, ffParseFontJsonObject, ffPrintFont);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -64,11 +64,8 @@ void ffDestroyFontOptions(FFFontOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseFontJsonObject(yyjson_val* module)
+void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module)
 {
-    FFFontOptions __attribute__((__cleanup__(ffDestroyFontOptions))) options;
-    ffInitFontOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -79,12 +76,10 @@ void ffParseFontJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/font/font.h b/src/modules/font/font.h
index a4e46f65a..a51f9d447 100644
--- a/src/modules/font/font.h
+++ b/src/modules/font/font.h
@@ -8,4 +8,4 @@ void ffPrintFont(FFFontOptions* options);
 void ffInitFontOptions(FFFontOptions* options);
 bool ffParseFontCommandOptions(FFFontOptions* options, const char* key, const char* value);
 void ffDestroyFontOptions(FFFontOptions* options);
-void ffParseFontJsonObject(yyjson_val* module);
+void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module);
diff --git a/src/modules/font/option.h b/src/modules/font/option.h
index 9318bac4b..12552bcce 100644
--- a/src/modules/font/option.h
+++ b/src/modules/font/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFFontOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFFontOptions;
diff --git a/src/modules/gamepad/gamepad.c b/src/modules/gamepad/gamepad.c
index 18c417b3c..e057d45c3 100644
--- a/src/modules/gamepad/gamepad.c
+++ b/src/modules/gamepad/gamepad.c
@@ -51,7 +51,7 @@ void ffPrintGamepad(FFGamepadOptions* options)
 
 void ffInitGamepadOptions(FFGamepadOptions* options)
 {
-    options->moduleName = FF_GAMEPAD_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_GAMEPAD_MODULE_NAME, ffParseGamepadCommandOptions, ffParseGamepadJsonObject, ffPrintGamepad);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -70,11 +70,8 @@ void ffDestroyGamepadOptions(FFGamepadOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseGamepadJsonObject(yyjson_val* module)
+void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module)
 {
-    FFGamepadOptions __attribute__((__cleanup__(ffDestroyGamepadOptions))) options;
-    ffInitGamepadOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseGamepadJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/gamepad/gamepad.h b/src/modules/gamepad/gamepad.h
index df81768d7..eae8a8a17 100644
--- a/src/modules/gamepad/gamepad.h
+++ b/src/modules/gamepad/gamepad.h
@@ -8,4 +8,4 @@ void ffPrintGamepad(FFGamepadOptions* options);
 void ffInitGamepadOptions(FFGamepadOptions* options);
 bool ffParseGamepadCommandOptions(FFGamepadOptions* options, const char* key, const char* value);
 void ffDestroyGamepadOptions(FFGamepadOptions* options);
-void ffParseGamepadJsonObject(yyjson_val* module);
+void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module);
diff --git a/src/modules/gamepad/option.h b/src/modules/gamepad/option.h
index 6cca7f2fd..f455b3a42 100644
--- a/src/modules/gamepad/option.h
+++ b/src/modules/gamepad/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFGamepadOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFGamepadOptions;
diff --git a/src/modules/gpu/gpu.c b/src/modules/gpu/gpu.c
index b1b8fa090..58c85648b 100644
--- a/src/modules/gpu/gpu.c
+++ b/src/modules/gpu/gpu.c
@@ -121,7 +121,7 @@ void ffPrintGPU(FFGPUOptions* options)
 
 void ffInitGPUOptions(FFGPUOptions* options)
 {
-    options->moduleName = FF_GPU_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_GPU_MODULE_NAME, ffParseGPUCommandOptions, ffParseGPUJsonObject, ffPrintGPU);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     options->forceVulkan = false;
@@ -166,11 +166,8 @@ void ffDestroyGPUOptions(FFGPUOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseGPUJsonObject(yyjson_val* module)
+void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module)
 {
-    FFGPUOptions __attribute__((__cleanup__(ffDestroyGPUOptions))) options;
-    ffInitGPUOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -181,18 +178,18 @@ void ffParseGPUJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "temp"))
             {
-                options.temp = yyjson_get_bool(val);
+                options->temp = yyjson_get_bool(val);
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "forceVulkan"))
             {
-                options.forceVulkan = yyjson_get_bool(val);
+                options->forceVulkan = yyjson_get_bool(val);
                 continue;
             }
 
@@ -206,15 +203,13 @@ void ffParseGPUJsonObject(yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(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;
+                    options->hideType = (FFGPUType) value;
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/gpu/gpu.h b/src/modules/gpu/gpu.h
index 9462e5fa0..b5334730a 100644
--- a/src/modules/gpu/gpu.h
+++ b/src/modules/gpu/gpu.h
@@ -8,4 +8,4 @@ void ffPrintGPU(FFGPUOptions* options);
 void ffInitGPUOptions(FFGPUOptions* options);
 bool ffParseGPUCommandOptions(FFGPUOptions* options, const char* key, const char* value);
 void ffDestroyGPUOptions(FFGPUOptions* options);
-void ffParseGPUJsonObject(yyjson_val* module);
+void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module);
diff --git a/src/modules/gpu/option.h b/src/modules/gpu/option.h
index 0aaa6a6f7..8525d6127 100644
--- a/src/modules/gpu/option.h
+++ b/src/modules/gpu/option.h
@@ -13,7 +13,7 @@ typedef enum FFGPUType
 
 typedef struct FFGPUOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFGPUType hideType;
diff --git a/src/modules/host/host.c b/src/modules/host/host.c
index 5c878134b..b7033ec0b 100644
--- a/src/modules/host/host.c
+++ b/src/modules/host/host.c
@@ -67,7 +67,7 @@ exit:
 
 void ffInitHostOptions(FFHostOptions* options)
 {
-    options->moduleName = FF_HOST_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_HOST_MODULE_NAME, ffParseHostCommandOptions, ffParseHostJsonObject, ffPrintHost);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -86,11 +86,8 @@ void ffDestroyHostOptions(FFHostOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseHostJsonObject(yyjson_val* module)
+void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module)
 {
-    FFHostOptions __attribute__((__cleanup__(ffDestroyHostOptions))) options;
-    ffInitHostOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -101,12 +98,10 @@ void ffParseHostJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/host/host.h b/src/modules/host/host.h
index 9c9368a27..5a689288a 100644
--- a/src/modules/host/host.h
+++ b/src/modules/host/host.h
@@ -8,4 +8,4 @@ void ffPrintHost(FFHostOptions* options);
 void ffInitHostOptions(FFHostOptions* options);
 bool ffParseHostCommandOptions(FFHostOptions* options, const char* key, const char* value);
 void ffDestroyHostOptions(FFHostOptions* options);
-void ffParseHostJsonObject(yyjson_val* module);
+void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module);
diff --git a/src/modules/host/option.h b/src/modules/host/option.h
index 59073e934..1c6bf26f3 100644
--- a/src/modules/host/option.h
+++ b/src/modules/host/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFHostOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFHostOptions;
diff --git a/src/modules/icons/icons.c b/src/modules/icons/icons.c
index a79a97301..ede179b66 100644
--- a/src/modules/icons/icons.c
+++ b/src/modules/icons/icons.c
@@ -32,7 +32,7 @@ void ffPrintIcons(FFIconsOptions* options)
 
 void ffInitIconsOptions(FFIconsOptions* options)
 {
-    options->moduleName = FF_ICONS_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_ICONS_MODULE_NAME, ffParseIconsCommandOptions, ffParseIconsJsonObject, ffPrintIcons);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -51,11 +51,8 @@ void ffDestroyIconsOptions(FFIconsOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseIconsJsonObject(yyjson_val* module)
+void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module)
 {
-    FFIconsOptions __attribute__((__cleanup__(ffDestroyIconsOptions))) options;
-    ffInitIconsOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseIconsJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/icons/icons.h b/src/modules/icons/icons.h
index 3d4bd7e0d..97533b096 100644
--- a/src/modules/icons/icons.h
+++ b/src/modules/icons/icons.h
@@ -8,4 +8,4 @@ void ffPrintIcons(FFIconsOptions* options);
 void ffInitIconsOptions(FFIconsOptions* options);
 bool ffParseIconsCommandOptions(FFIconsOptions* options, const char* key, const char* value);
 void ffDestroyIconsOptions(FFIconsOptions* options);
-void ffParseIconsJsonObject(yyjson_val* module);
+void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module);
diff --git a/src/modules/icons/option.h b/src/modules/icons/option.h
index fc6427aa4..456668796 100644
--- a/src/modules/icons/option.h
+++ b/src/modules/icons/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFIconsOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFIconsOptions;
diff --git a/src/modules/kernel/kernel.c b/src/modules/kernel/kernel.c
index e33233523..e830debe1 100644
--- a/src/modules/kernel/kernel.c
+++ b/src/modules/kernel/kernel.c
@@ -32,7 +32,7 @@ void ffPrintKernel(FFKernelOptions* options)
 
 void ffInitKernelOptions(FFKernelOptions* options)
 {
-    options->moduleName = FF_KERNEL_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_KERNEL_MODULE_NAME, ffParseKernelCommandOptions, ffParseKernelJsonObject, ffPrintKernel);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -51,11 +51,8 @@ void ffDestroyKernelOptions(FFKernelOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseKernelJsonObject(yyjson_val* module)
+void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module)
 {
-    FFKernelOptions __attribute__((__cleanup__(ffDestroyKernelOptions))) options;
-    ffInitKernelOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseKernelJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/kernel/kernel.h b/src/modules/kernel/kernel.h
index 906a89c11..943641d60 100644
--- a/src/modules/kernel/kernel.h
+++ b/src/modules/kernel/kernel.h
@@ -8,4 +8,4 @@ void ffPrintKernel(FFKernelOptions* options);
 void ffInitKernelOptions(FFKernelOptions* options);
 bool ffParseKernelCommandOptions(FFKernelOptions* options, const char* key, const char* value);
 void ffDestroyKernelOptions(FFKernelOptions* options);
-void ffParseKernelJsonObject(yyjson_val* module);
+void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module);
diff --git a/src/modules/kernel/option.h b/src/modules/kernel/option.h
index 434c3069d..fd3cb17a3 100644
--- a/src/modules/kernel/option.h
+++ b/src/modules/kernel/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFKernelOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFKernelOptions;
diff --git a/src/modules/lm/lm.c b/src/modules/lm/lm.c
index c0608e8a0..3c3053e8e 100644
--- a/src/modules/lm/lm.c
+++ b/src/modules/lm/lm.c
@@ -51,7 +51,7 @@ void ffPrintLM(FFLMOptions* options)
 
 void ffInitLMOptions(FFLMOptions* options)
 {
-    options->moduleName = FF_LM_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LM_MODULE_NAME, ffParseLMCommandOptions, ffParseLMJsonObject, ffPrintLM);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -70,11 +70,8 @@ void ffDestroyLMOptions(FFLMOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseLMJsonObject(yyjson_val* module)
+void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module)
 {
-    FFLMOptions __attribute__((__cleanup__(ffDestroyLMOptions))) options;
-    ffInitLMOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -85,12 +82,10 @@ void ffParseLMJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/lm/lm.h b/src/modules/lm/lm.h
index 788405bed..079f90e5f 100644
--- a/src/modules/lm/lm.h
+++ b/src/modules/lm/lm.h
@@ -8,4 +8,4 @@ void ffPrintLM(FFLMOptions* options);
 void ffInitLMOptions(FFLMOptions* options);
 bool ffParseLMCommandOptions(FFLMOptions* options, const char* key, const char* value);
 void ffDestroyLMOptions(FFLMOptions* options);
-void ffParseLMJsonObject(yyjson_val* module);
+void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module);
diff --git a/src/modules/lm/option.h b/src/modules/lm/option.h
index 2a788186c..4255382ff 100644
--- a/src/modules/lm/option.h
+++ b/src/modules/lm/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFLMOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFLMOptions;
diff --git a/src/modules/locale/locale.c b/src/modules/locale/locale.c
index 21e5a3756..10e00802e 100644
--- a/src/modules/locale/locale.c
+++ b/src/modules/locale/locale.c
@@ -32,7 +32,7 @@ void ffPrintLocale(FFLocaleOptions* options)
 
 void ffInitLocaleOptions(FFLocaleOptions* options)
 {
-    options->moduleName = FF_LOCALE_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LOCALE_MODULE_NAME, ffParseLocaleCommandOptions, ffParseLocaleJsonObject, ffPrintLocale);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -51,11 +51,8 @@ void ffDestroyLocaleOptions(FFLocaleOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseLocaleJsonObject(yyjson_val* module)
+void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module)
 {
-    FFLocaleOptions __attribute__((__cleanup__(ffDestroyLocaleOptions))) options;
-    ffInitLocaleOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseLocaleJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/locale/locale.h b/src/modules/locale/locale.h
index 91e496878..405f697c9 100644
--- a/src/modules/locale/locale.h
+++ b/src/modules/locale/locale.h
@@ -8,4 +8,4 @@ void ffPrintLocale(FFLocaleOptions* options);
 void ffInitLocaleOptions(FFLocaleOptions* options);
 bool ffParseLocaleCommandOptions(FFLocaleOptions* options, const char* key, const char* value);
 void ffDestroyLocaleOptions(FFLocaleOptions* options);
-void ffParseLocaleJsonObject(yyjson_val* module);
+void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module);
diff --git a/src/modules/locale/option.h b/src/modules/locale/option.h
index 3e3253037..c6ba96720 100644
--- a/src/modules/locale/option.h
+++ b/src/modules/locale/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFLocaleOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFLocaleOptions;
diff --git a/src/modules/localip/localip.c b/src/modules/localip/localip.c
index 1b2772b01..95ed7b256 100644
--- a/src/modules/localip/localip.c
+++ b/src/modules/localip/localip.c
@@ -139,7 +139,7 @@ void ffPrintLocalIp(FFLocalIpOptions* options)
 
 void ffInitLocalIpOptions(FFLocalIpOptions* options)
 {
-    options->moduleName = FF_LOCALIP_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LOCALIP_MODULE_NAME, ffParseLocalIpCommandOptions, ffParseLocalIpJsonObject, ffPrintLocalIp);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     options->showType = FF_LOCALIP_TYPE_IPV4_BIT;
@@ -220,11 +220,8 @@ void ffDestroyLocalIpOptions(FFLocalIpOptions* options)
     ffStrbufDestroy(&options->namePrefix);
 }
 
-void ffParseLocalIpJsonObject(yyjson_val* module)
+void ffParseLocalIpJsonObject(FFLocalIpOptions* options, yyjson_val* module)
 {
-    FFLocalIpOptions __attribute__((__cleanup__(ffDestroyLocalIpOptions))) options;
-    ffInitLocalIpOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -235,69 +232,67 @@ void ffParseLocalIpJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "showIpv4"))
             {
                 if (yyjson_get_bool(val))
-                    options.showType |= FF_LOCALIP_TYPE_IPV4_BIT;
+                    options->showType |= FF_LOCALIP_TYPE_IPV4_BIT;
                 else
-                    options.showType &= ~FF_LOCALIP_TYPE_IPV4_BIT;
+                    options->showType &= ~FF_LOCALIP_TYPE_IPV4_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "showIpv6"))
             {
                 if (yyjson_get_bool(val))
-                    options.showType |= FF_LOCALIP_TYPE_IPV6_BIT;
+                    options->showType |= FF_LOCALIP_TYPE_IPV6_BIT;
                 else
-                    options.showType &= ~FF_LOCALIP_TYPE_IPV6_BIT;
+                    options->showType &= ~FF_LOCALIP_TYPE_IPV6_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "showMac"))
             {
                 if (yyjson_get_bool(val))
-                    options.showType |= FF_LOCALIP_TYPE_MAC_BIT;
+                    options->showType |= FF_LOCALIP_TYPE_MAC_BIT;
                 else
-                    options.showType &= ~FF_LOCALIP_TYPE_MAC_BIT;
+                    options->showType &= ~FF_LOCALIP_TYPE_MAC_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "showLoop"))
             {
                 if (yyjson_get_bool(val))
-                    options.showType |= FF_LOCALIP_TYPE_LOOP_BIT;
+                    options->showType |= FF_LOCALIP_TYPE_LOOP_BIT;
                 else
-                    options.showType &= ~FF_LOCALIP_TYPE_LOOP_BIT;
+                    options->showType &= ~FF_LOCALIP_TYPE_LOOP_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "compact"))
             {
                 if (yyjson_get_bool(val))
-                    options.showType |= FF_LOCALIP_TYPE_COMPACT_BIT;
+                    options->showType |= FF_LOCALIP_TYPE_COMPACT_BIT;
                 else
-                    options.showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT;
+                    options->showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT;
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "namePrefix"))
             {
-                ffStrbufSetS(&options.namePrefix, yyjson_get_str(val));
+                ffStrbufSetS(&options->namePrefix, yyjson_get_str(val));
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "defaultRouteOnly"))
             {
-                options.defaultRouteOnly = yyjson_get_bool(val);
+                options->defaultRouteOnly = yyjson_get_bool(val);
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/localip/localip.h b/src/modules/localip/localip.h
index 8d1270c23..114459c6f 100644
--- a/src/modules/localip/localip.h
+++ b/src/modules/localip/localip.h
@@ -8,4 +8,4 @@ void ffPrintLocalIp(FFLocalIpOptions* options);
 void ffInitLocalIpOptions(FFLocalIpOptions* options);
 bool ffParseLocalIpCommandOptions(FFLocalIpOptions* options, const char* key, const char* value);
 void ffDestroyLocalIpOptions(FFLocalIpOptions* options);
-void ffParseLocalIpJsonObject(yyjson_val* module);
+void ffParseLocalIpJsonObject(FFLocalIpOptions* options, yyjson_val* module);
diff --git a/src/modules/localip/option.h b/src/modules/localip/option.h
index 8d58b8235..e2bdda0e3 100644
--- a/src/modules/localip/option.h
+++ b/src/modules/localip/option.h
@@ -17,7 +17,7 @@ typedef enum FFLocalIpType
 
 typedef struct FFLocalIpOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFLocalIpType showType;
diff --git a/src/modules/media/media.c b/src/modules/media/media.c
index f2969dd9a..10fcd66ff 100644
--- a/src/modules/media/media.c
+++ b/src/modules/media/media.c
@@ -107,7 +107,7 @@ void ffPrintMedia(FFMediaOptions* options)
 
 void ffInitMediaOptions(FFMediaOptions* options)
 {
-    options->moduleName = FF_MEDIA_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MEDIA_MODULE_NAME, ffParseMediaCommandOptions, ffParseMediaJsonObject, ffPrintMedia);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -126,11 +126,8 @@ void ffDestroyMediaOptions(FFMediaOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseMediaJsonObject(yyjson_val* module)
+void ffParseMediaJsonObject(FFMediaOptions* options, yyjson_val* module)
 {
-    FFMediaOptions __attribute__((__cleanup__(ffDestroyMediaOptions))) options;
-    ffInitMediaOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -141,12 +138,10 @@ void ffParseMediaJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/media/media.h b/src/modules/media/media.h
index 52fb6ba50..f5267e579 100644
--- a/src/modules/media/media.h
+++ b/src/modules/media/media.h
@@ -8,4 +8,4 @@ void ffPrintMedia(FFMediaOptions* options);
 void ffInitMediaOptions(FFMediaOptions* options);
 bool ffParseMediaCommandOptions(FFMediaOptions* options, const char* key, const char* value);
 void ffDestroyMediaOptions(FFMediaOptions* options);
-void ffParseMediaJsonObject(yyjson_val* module);
+void ffParseMediaJsonObject(FFMediaOptions* options, yyjson_val* module);
diff --git a/src/modules/media/option.h b/src/modules/media/option.h
index 8498c6e9b..cb57b8b6e 100644
--- a/src/modules/media/option.h
+++ b/src/modules/media/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFMediaOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFMediaOptions;
diff --git a/src/modules/memory/memory.c b/src/modules/memory/memory.c
index a8b78316b..b5691e17e 100644
--- a/src/modules/memory/memory.c
+++ b/src/modules/memory/memory.c
@@ -66,7 +66,7 @@ void ffPrintMemory(FFMemoryOptions* options)
 
 void ffInitMemoryOptions(FFMemoryOptions* options)
 {
-    options->moduleName = FF_MEMORY_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MEMORY_MODULE_NAME, ffParseMemoryCommandOptions, ffParseMemoryJsonObject, ffPrintMemory);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -85,11 +85,8 @@ void ffDestroyMemoryOptions(FFMemoryOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseMemoryJsonObject(yyjson_val* module)
+void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module)
 {
-    FFMemoryOptions __attribute__((__cleanup__(ffDestroyMemoryOptions))) options;
-    ffInitMemoryOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -100,12 +97,10 @@ void ffParseMemoryJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/memory/memory.h b/src/modules/memory/memory.h
index e63a45e28..aec76b21f 100644
--- a/src/modules/memory/memory.h
+++ b/src/modules/memory/memory.h
@@ -8,4 +8,4 @@ void ffPrintMemory(FFMemoryOptions* options);
 void ffInitMemoryOptions(FFMemoryOptions* options);
 bool ffParseMemoryCommandOptions(FFMemoryOptions* options, const char* key, const char* value);
 void ffDestroyMemoryOptions(FFMemoryOptions* options);
-void ffParseMemoryJsonObject(yyjson_val* module);
+void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module);
diff --git a/src/modules/memory/option.h b/src/modules/memory/option.h
index 1f8b30bf1..b908943e4 100644
--- a/src/modules/memory/option.h
+++ b/src/modules/memory/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFMemoryOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFMemoryOptions;
diff --git a/src/modules/monitor/monitor.c b/src/modules/monitor/monitor.c
index a267f393c..406263c71 100644
--- a/src/modules/monitor/monitor.c
+++ b/src/modules/monitor/monitor.c
@@ -77,7 +77,7 @@ void ffPrintMonitor(FFMonitorOptions* options)
 
 void ffInitMonitorOptions(FFMonitorOptions* options)
 {
-    options->moduleName = FF_MONITOR_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MONITOR_MODULE_NAME, ffParseMonitorCommandOptions, ffParseMonitorJsonObject, ffPrintMonitor);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -96,11 +96,8 @@ void ffDestroyMonitorOptions(FFMonitorOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseMonitorJsonObject(yyjson_val* module)
+void ffParseMonitorJsonObject(FFMonitorOptions* options, yyjson_val* module)
 {
-    FFMonitorOptions __attribute__((__cleanup__(ffDestroyMonitorOptions))) options;
-    ffInitMonitorOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -111,12 +108,10 @@ void ffParseMonitorJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
         }
     }
-
-    ffPrintMonitor(&options);
 }
diff --git a/src/modules/monitor/monitor.h b/src/modules/monitor/monitor.h
index a95a3fa74..ff03d26e9 100644
--- a/src/modules/monitor/monitor.h
+++ b/src/modules/monitor/monitor.h
@@ -8,4 +8,4 @@ void ffPrintMonitor(FFMonitorOptions* options);
 void ffInitMonitorOptions(FFMonitorOptions* options);
 bool ffParseMonitorCommandOptions(FFMonitorOptions* options, const char* key, const char* value);
 void ffDestroyMonitorOptions(FFMonitorOptions* options);
-void ffParseMonitorJsonObject(yyjson_val* module);
+void ffParseMonitorJsonObject(FFMonitorOptions* options, yyjson_val* module);
diff --git a/src/modules/monitor/option.h b/src/modules/monitor/option.h
index ee2efc964..b474ae7b2 100644
--- a/src/modules/monitor/option.h
+++ b/src/modules/monitor/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFMonitorOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFMonitorOptions;
diff --git a/src/modules/opencl/opencl.c b/src/modules/opencl/opencl.c
index daa4da00a..0d06bd884 100644
--- a/src/modules/opencl/opencl.c
+++ b/src/modules/opencl/opencl.c
@@ -41,7 +41,7 @@ void ffPrintOpenCL(FFOpenCLOptions* options)
 
 void ffInitOpenCLOptions(FFOpenCLOptions* options)
 {
-    options->moduleName = FF_OPENCL_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OPENCL_MODULE_NAME, ffParseOpenCLCommandOptions, ffParseOpenCLJsonObject, ffPrintOpenCL);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -60,11 +60,8 @@ void ffDestroyOpenCLOptions(FFOpenCLOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseOpenCLJsonObject(yyjson_val* module)
+void ffParseOpenCLJsonObject(FFOpenCLOptions* options, yyjson_val* module)
 {
-    FFOpenCLOptions __attribute__((__cleanup__(ffDestroyOpenCLOptions))) options;
-    ffInitOpenCLOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -75,12 +72,10 @@ void ffParseOpenCLJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/opencl/opencl.h b/src/modules/opencl/opencl.h
index b01a2a480..f5e2a32c2 100644
--- a/src/modules/opencl/opencl.h
+++ b/src/modules/opencl/opencl.h
@@ -8,4 +8,4 @@ void ffPrintOpenCL(FFOpenCLOptions* options);
 void ffInitOpenCLOptions(FFOpenCLOptions* options);
 bool ffParseOpenCLCommandOptions(FFOpenCLOptions* options, const char* key, const char* value);
 void ffDestroyOpenCLOptions(FFOpenCLOptions* options);
-void ffParseOpenCLJsonObject(yyjson_val* module);
+void ffParseOpenCLJsonObject(FFOpenCLOptions* options, yyjson_val* module);
diff --git a/src/modules/opencl/option.h b/src/modules/opencl/option.h
index addac5245..048c9b266 100644
--- a/src/modules/opencl/option.h
+++ b/src/modules/opencl/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFOpenCLOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFOpenCLOptions;
diff --git a/src/modules/opengl/opengl.c b/src/modules/opengl/opengl.c
index e4d6ec008..94838b646 100644
--- a/src/modules/opengl/opengl.c
+++ b/src/modules/opengl/opengl.c
@@ -44,7 +44,7 @@ void ffPrintOpenGL(FFOpenGLOptions* options)
 
 void ffInitOpenGLOptions(FFOpenGLOptions* options)
 {
-    options->moduleName = FF_OPENGL_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OPENGL_MODULE_NAME, ffParseOpenGLCommandOptions, ffParseOpenGLJsonObject, ffPrintOpenGL);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     #if defined(__linux__) || defined(__FreeBSD__)
@@ -80,11 +80,8 @@ void ffDestroyOpenGLOptions(FFOpenGLOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseOpenGLJsonObject(yyjson_val* module)
+void ffParseOpenGLJsonObject(FFOpenGLOptions* options, yyjson_val* module)
 {
-    FFOpenGLOptions __attribute__((__cleanup__(ffDestroyOpenGLOptions))) options;
-    ffInitOpenGLOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -95,7 +92,7 @@ void ffParseOpenGLJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             #if defined(__linux__) || defined(__FreeBSD__)
@@ -110,16 +107,14 @@ void ffParseOpenGLJsonObject(yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(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;
+                    options->library = (FFOpenGLLibrary) value;
                 continue;
             }
             #endif
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/opengl/opengl.h b/src/modules/opengl/opengl.h
index 5d4f1ab88..5d0b1937b 100644
--- a/src/modules/opengl/opengl.h
+++ b/src/modules/opengl/opengl.h
@@ -8,4 +8,4 @@ void ffPrintOpenGL(FFOpenGLOptions* options);
 void ffInitOpenGLOptions(FFOpenGLOptions* options);
 bool ffParseOpenGLCommandOptions(FFOpenGLOptions* options, const char* key, const char* value);
 void ffDestroyOpenGLOptions(FFOpenGLOptions* options);
-void ffParseOpenGLJsonObject(yyjson_val* module);
+void ffParseOpenGLJsonObject(FFOpenGLOptions* options, yyjson_val* module);
diff --git a/src/modules/opengl/option.h b/src/modules/opengl/option.h
index 712374d93..dd151f3d3 100644
--- a/src/modules/opengl/option.h
+++ b/src/modules/opengl/option.h
@@ -16,7 +16,7 @@ typedef enum FFOpenGLLibrary
 
 typedef struct FFOpenGLOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     #if defined(__linux__) || defined(__FreeBSD__)
diff --git a/src/modules/options.h b/src/modules/options.h
index fbd845d3a..84bc4764b 100644
--- a/src/modules/options.h
+++ b/src/modules/options.h
@@ -6,6 +6,7 @@
 #include "modules/bios/option.h"
 #include "modules/bluetooth/option.h"
 #include "modules/board/option.h"
+#include "modules/break/option.h"
 #include "modules/brightness/option.h"
 #include "modules/chassis/option.h"
 #include "modules/cpu/option.h"
diff --git a/src/modules/os/option.h b/src/modules/os/option.h
index be1bfda1f..ae098a53a 100644
--- a/src/modules/os/option.h
+++ b/src/modules/os/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFOSOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFOSOptions;
diff --git a/src/modules/os/os.c b/src/modules/os/os.c
index 299079c68..b0e9ac1fb 100644
--- a/src/modules/os/os.c
+++ b/src/modules/os/os.c
@@ -139,7 +139,7 @@ void ffPrintOS(FFOSOptions* options)
 
 void ffInitOSOptions(FFOSOptions* options)
 {
-    options->moduleName = FF_OS_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OS_MODULE_NAME, ffParseOSCommandOptions, ffParseOSJsonObject, ffPrintOS);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -158,11 +158,8 @@ void ffDestroyOSOptions(FFOSOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseOSJsonObject(yyjson_val* module)
+void ffParseOSJsonObject(FFOSOptions* options, yyjson_val* module)
 {
-    FFOSOptions __attribute__((__cleanup__(ffDestroyOSOptions))) options;
-    ffInitOSOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -173,12 +170,10 @@ void ffParseOSJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/os/os.h b/src/modules/os/os.h
index 36856d9b1..07320194d 100644
--- a/src/modules/os/os.h
+++ b/src/modules/os/os.h
@@ -8,4 +8,4 @@ void ffPrintOS(FFOSOptions* options);
 void ffInitOSOptions(FFOSOptions* options);
 bool ffParseOSCommandOptions(FFOSOptions* options, const char* key, const char* value);
 void ffDestroyOSOptions(FFOSOptions* options);
-void ffParseOSJsonObject(yyjson_val* module);
+void ffParseOSJsonObject(FFOSOptions* options, yyjson_val* module);
diff --git a/src/modules/packages/option.h b/src/modules/packages/option.h
index e06b8403b..eb3050b96 100644
--- a/src/modules/packages/option.h
+++ b/src/modules/packages/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFPackagesOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFPackagesOptions;
diff --git a/src/modules/packages/packages.c b/src/modules/packages/packages.c
index cb8c6ba2a..6d9374f19 100644
--- a/src/modules/packages/packages.c
+++ b/src/modules/packages/packages.c
@@ -99,7 +99,7 @@ void ffPrintPackages(FFPackagesOptions* options)
 
 void ffInitPackagesOptions(FFPackagesOptions* options)
 {
-    options->moduleName = FF_PACKAGES_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PACKAGES_MODULE_NAME, ffParsePackagesCommandOptions, ffParsePackagesJsonObject, ffPrintPackages);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -118,11 +118,8 @@ void ffDestroyPackagesOptions(FFPackagesOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParsePackagesJsonObject(yyjson_val* module)
+void ffParsePackagesJsonObject(FFPackagesOptions* options, yyjson_val* module)
 {
-    FFPackagesOptions __attribute__((__cleanup__(ffDestroyPackagesOptions))) options;
-    ffInitPackagesOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -133,12 +130,10 @@ void ffParsePackagesJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/packages/packages.h b/src/modules/packages/packages.h
index 87516579a..14fd7301d 100644
--- a/src/modules/packages/packages.h
+++ b/src/modules/packages/packages.h
@@ -8,4 +8,4 @@ void ffPrintPackages(FFPackagesOptions* options);
 void ffInitPackagesOptions(FFPackagesOptions* options);
 bool ffParsePackagesCommandOptions(FFPackagesOptions* options, const char* key, const char* value);
 void ffDestroyPackagesOptions(FFPackagesOptions* options);
-void ffParsePackagesJsonObject(yyjson_val* module);
+void ffParsePackagesJsonObject(FFPackagesOptions* options, yyjson_val* module);
diff --git a/src/modules/player/option.h b/src/modules/player/option.h
index e27056055..1d34797fb 100644
--- a/src/modules/player/option.h
+++ b/src/modules/player/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFPlayerOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFPlayerOptions;
diff --git a/src/modules/player/player.c b/src/modules/player/player.c
index d78fc3f2f..cca9a240f 100644
--- a/src/modules/player/player.c
+++ b/src/modules/player/player.c
@@ -75,7 +75,7 @@ void ffPrintPlayer(FFPlayerOptions* options)
 
 void ffInitPlayerOptions(FFPlayerOptions* options)
 {
-    options->moduleName = FF_PLAYER_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PLAYER_MODULE_NAME, ffParsePlayerCommandOptions, ffParsePlayerJsonObject, ffPrintPlayer);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -94,11 +94,8 @@ void ffDestroyPlayerOptions(FFPlayerOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParsePlayerJsonObject(yyjson_val* module)
+void ffParsePlayerJsonObject(FFPlayerOptions* options, yyjson_val* module)
 {
-    FFPlayerOptions __attribute__((__cleanup__(ffDestroyPlayerOptions))) options;
-    ffInitPlayerOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -109,12 +106,10 @@ void ffParsePlayerJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/player/player.h b/src/modules/player/player.h
index 6f09b425f..f63e12250 100644
--- a/src/modules/player/player.h
+++ b/src/modules/player/player.h
@@ -9,4 +9,4 @@ void ffPrintPlayer(FFPlayerOptions* options);
 void ffInitPlayerOptions(FFPlayerOptions* options);
 bool ffParsePlayerCommandOptions(FFPlayerOptions* options, const char* key, const char* value);
 void ffDestroyPlayerOptions(FFPlayerOptions* options);
-void ffParsePlayerJsonObject(yyjson_val* module);
+void ffParsePlayerJsonObject(FFPlayerOptions* options, yyjson_val* module);
diff --git a/src/modules/poweradapter/option.h b/src/modules/poweradapter/option.h
index 7acaf29ee..02a72eaf7 100644
--- a/src/modules/poweradapter/option.h
+++ b/src/modules/poweradapter/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFPowerAdapterOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFPowerAdapterOptions;
diff --git a/src/modules/poweradapter/poweradapter.c b/src/modules/poweradapter/poweradapter.c
index a5af37c03..c3babafbd 100644
--- a/src/modules/poweradapter/poweradapter.c
+++ b/src/modules/poweradapter/poweradapter.c
@@ -65,7 +65,7 @@ void ffPrintPowerAdapter(FFPowerAdapterOptions* options)
 
 void ffInitPowerAdapterOptions(FFPowerAdapterOptions* options)
 {
-    options->moduleName = FF_POWERADAPTER_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterCommandOptions, ffParsePowerAdapterJsonObject, ffPrintPowerAdapter);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -84,11 +84,8 @@ void ffDestroyPowerAdapterOptions(FFPowerAdapterOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParsePowerAdapterJsonObject(yyjson_val* module)
+void ffParsePowerAdapterJsonObject(FFPowerAdapterOptions* options, yyjson_val* module)
 {
-    FFPowerAdapterOptions __attribute__((__cleanup__(ffDestroyPowerAdapterOptions))) options;
-    ffInitPowerAdapterOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -99,12 +96,10 @@ void ffParsePowerAdapterJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/poweradapter/poweradapter.h b/src/modules/poweradapter/poweradapter.h
index 93c6a7704..e9490c832 100644
--- a/src/modules/poweradapter/poweradapter.h
+++ b/src/modules/poweradapter/poweradapter.h
@@ -8,4 +8,4 @@ void ffPrintPowerAdapter(FFPowerAdapterOptions* options);
 void ffInitPowerAdapterOptions(FFPowerAdapterOptions* options);
 bool ffParsePowerAdapterCommandOptions(FFPowerAdapterOptions* options, const char* key, const char* value);
 void ffDestroyPowerAdapterOptions(FFPowerAdapterOptions* options);
-void ffParsePowerAdapterJsonObject(yyjson_val* module);
+void ffParsePowerAdapterJsonObject(FFPowerAdapterOptions* options, yyjson_val* module);
diff --git a/src/modules/processes/option.h b/src/modules/processes/option.h
index 9d2cd8086..6946ecad4 100644
--- a/src/modules/processes/option.h
+++ b/src/modules/processes/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFProcessesOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFProcessesOptions;
diff --git a/src/modules/processes/processes.c b/src/modules/processes/processes.c
index 81b804124..b759184c2 100644
--- a/src/modules/processes/processes.c
+++ b/src/modules/processes/processes.c
@@ -33,7 +33,7 @@ void ffPrintProcesses(FFProcessesOptions* options)
 
 void ffInitProcessesOptions(FFProcessesOptions* options)
 {
-    options->moduleName = FF_PROCESSES_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PROCESSES_MODULE_NAME, ffParseProcessesCommandOptions, ffParseProcessesJsonObject, ffPrintProcesses);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -52,11 +52,8 @@ void ffDestroyProcessesOptions(FFProcessesOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseProcessesJsonObject(yyjson_val* module)
+void ffParseProcessesJsonObject(FFProcessesOptions* options, yyjson_val* module)
 {
-    FFProcessesOptions __attribute__((__cleanup__(ffDestroyProcessesOptions))) options;
-    ffInitProcessesOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -67,12 +64,10 @@ void ffParseProcessesJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/processes/processes.h b/src/modules/processes/processes.h
index 84696356d..724faf7fb 100644
--- a/src/modules/processes/processes.h
+++ b/src/modules/processes/processes.h
@@ -8,4 +8,4 @@ void ffPrintProcesses(FFProcessesOptions* options);
 void ffInitProcessesOptions(FFProcessesOptions* options);
 bool ffParseProcessesCommandOptions(FFProcessesOptions* options, const char* key, const char* value);
 void ffDestroyProcessesOptions(FFProcessesOptions* options);
-void ffParseProcessesJsonObject(yyjson_val* module);
+void ffParseProcessesJsonObject(FFProcessesOptions* options, yyjson_val* module);
diff --git a/src/modules/publicip/option.h b/src/modules/publicip/option.h
index aef383fc5..f05b95c23 100644
--- a/src/modules/publicip/option.h
+++ b/src/modules/publicip/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFPublicIpOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFstrbuf url;
diff --git a/src/modules/publicip/publicip.c b/src/modules/publicip/publicip.c
index a5707e20e..3c71b9b68 100644
--- a/src/modules/publicip/publicip.c
+++ b/src/modules/publicip/publicip.c
@@ -91,7 +91,7 @@ void ffPrintPublicIp(FFPublicIpOptions* options)
 
 void ffInitPublicIpOptions(FFPublicIpOptions* options)
 {
-    options->moduleName = FF_PUBLICIP_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpCommandOptions, ffParsePublicIpJsonObject, ffPrintPublicIp);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     ffStrbufInit(&options->url);
@@ -127,11 +127,8 @@ void ffDestroyPublicIpOptions(FFPublicIpOptions* options)
     ffStrbufDestroy(&options->url);
 }
 
-void ffParsePublicIpJsonObject(yyjson_val* module)
+void ffParsePublicIpJsonObject(FFPublicIpOptions* options, yyjson_val* module)
 {
-    FFPublicIpOptions __attribute__((__cleanup__(ffDestroyPublicIpOptions))) options;
-    ffInitPublicIpOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -142,24 +139,22 @@ void ffParsePublicIpJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "url"))
             {
-                ffStrbufSetS(&options.url, yyjson_get_str(val));
+                ffStrbufSetS(&options->url, yyjson_get_str(val));
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "timeout"))
             {
-                options.timeout = (uint32_t) yyjson_get_uint(val);
+                options->timeout = (uint32_t) yyjson_get_uint(val);
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/publicip/publicip.h b/src/modules/publicip/publicip.h
index 8328023f5..6a7c739d2 100644
--- a/src/modules/publicip/publicip.h
+++ b/src/modules/publicip/publicip.h
@@ -10,4 +10,4 @@ void ffPrintPublicIp(FFPublicIpOptions* options);
 void ffInitPublicIpOptions(FFPublicIpOptions* options);
 bool ffParsePublicIpCommandOptions(FFPublicIpOptions* options, const char* key, const char* value);
 void ffDestroyPublicIpOptions(FFPublicIpOptions* options);
-void ffParsePublicIpJsonObject(yyjson_val* module);
+void ffParsePublicIpJsonObject(FFPublicIpOptions* options, yyjson_val* module);
diff --git a/src/modules/separator/option.h b/src/modules/separator/option.h
index 10f5effdf..c858e6193 100644
--- a/src/modules/separator/option.h
+++ b/src/modules/separator/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFSeparatorOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
 
     FFstrbuf string;
 } FFSeparatorOptions;
diff --git a/src/modules/separator/separator.c b/src/modules/separator/separator.c
index 74108fd3b..dd860a3b0 100644
--- a/src/modules/separator/separator.c
+++ b/src/modules/separator/separator.c
@@ -77,7 +77,7 @@ void ffPrintSeparator(FFSeparatorOptions* options)
 
 void ffInitSeparatorOptions(FFSeparatorOptions* options)
 {
-    options->moduleName = FF_SEPARATOR_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorCommandOptions, ffParseSeparatorJsonObject, ffPrintSeparator);
     ffStrbufInit(&options->string);
 }
 
@@ -100,11 +100,8 @@ void ffDestroySeparatorOptions(FFSeparatorOptions* options)
     ffStrbufDestroy(&options->string);
 }
 
-void ffParseSeparatorJsonObject(yyjson_val* module)
+void ffParseSeparatorJsonObject(FFSeparatorOptions* options, yyjson_val* module)
 {
-    FFSeparatorOptions __attribute__((__cleanup__(ffDestroySeparatorOptions))) options;
-    ffInitSeparatorOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -117,13 +114,11 @@ void ffParseSeparatorJsonObject(yyjson_val* module)
 
             if (ffStrEqualsIgnCase(key, "string"))
             {
-                ffStrbufSetS(&options.string, yyjson_get_str(val));
+                ffStrbufSetS(&options->string, yyjson_get_str(val));
                 continue;
             }
 
             ffPrintErrorString(FF_SEPARATOR_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key);
         }
     }
-
-    ffPrintSeparator(&options);
 }
diff --git a/src/modules/separator/separator.h b/src/modules/separator/separator.h
index 3e97ac464..a5dc91285 100644
--- a/src/modules/separator/separator.h
+++ b/src/modules/separator/separator.h
@@ -8,4 +8,4 @@ void ffPrintSeparator(FFSeparatorOptions* options);
 void ffInitSeparatorOptions(FFSeparatorOptions* options);
 bool ffParseSeparatorCommandOptions(FFSeparatorOptions* options, const char* key, const char* value);
 void ffDestroySeparatorOptions(FFSeparatorOptions* options);
-void ffParseSeparatorJsonObject(yyjson_val* module);
+void ffParseSeparatorJsonObject(FFSeparatorOptions* options, yyjson_val* module);
diff --git a/src/modules/shell/option.h b/src/modules/shell/option.h
index dd6223a36..4d430e818 100644
--- a/src/modules/shell/option.h
+++ b/src/modules/shell/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFShellOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     bool version;
diff --git a/src/modules/shell/shell.c b/src/modules/shell/shell.c
index 00a305db7..b9c7a4dae 100644
--- a/src/modules/shell/shell.c
+++ b/src/modules/shell/shell.c
@@ -45,7 +45,7 @@ void ffPrintShell(FFShellOptions* options)
 
 void ffInitShellOptions(FFShellOptions* options)
 {
-    options->moduleName = FF_SHELL_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SHELL_MODULE_NAME, ffParseShellCommandOptions, ffParseShellJsonObject, ffPrintShell);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -64,11 +64,8 @@ void ffDestroyShellOptions(FFShellOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseShellJsonObject(yyjson_val* module)
+void ffParseShellJsonObject(FFShellOptions* options, yyjson_val* module)
 {
-    FFShellOptions __attribute__((__cleanup__(ffDestroyShellOptions))) options;
-    ffInitShellOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -79,12 +76,10 @@ void ffParseShellJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/shell/shell.h b/src/modules/shell/shell.h
index b2579cd49..4e4f976bf 100644
--- a/src/modules/shell/shell.h
+++ b/src/modules/shell/shell.h
@@ -8,4 +8,4 @@ void ffPrintShell(FFShellOptions* options);
 void ffInitShellOptions(FFShellOptions* options);
 bool ffParseShellCommandOptions(FFShellOptions* options, const char* key, const char* value);
 void ffDestroyShellOptions(FFShellOptions* options);
-void ffParseShellJsonObject(yyjson_val* module);
+void ffParseShellJsonObject(FFShellOptions* options, yyjson_val* module);
diff --git a/src/modules/sound/option.h b/src/modules/sound/option.h
index b0586036b..11f652602 100644
--- a/src/modules/sound/option.h
+++ b/src/modules/sound/option.h
@@ -13,7 +13,7 @@ typedef enum FFSoundType
 
 typedef struct FFSoundOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFSoundType soundType;
diff --git a/src/modules/sound/sound.c b/src/modules/sound/sound.c
index d3e0e86dd..f206c2b18 100644
--- a/src/modules/sound/sound.c
+++ b/src/modules/sound/sound.c
@@ -85,7 +85,7 @@ void ffPrintSound(FFSoundOptions* options)
 
 void ffInitSoundOptions(FFSoundOptions* options)
 {
-    options->moduleName = FF_SOUND_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SOUND_MODULE_NAME, ffParseSoundCommandOptions, ffParseSoundJsonObject, ffPrintSound);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     options->soundType = FF_SOUND_TYPE_MAIN;
@@ -117,11 +117,8 @@ void ffDestroySoundOptions(FFSoundOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseSoundJsonObject(yyjson_val* module)
+void ffParseSoundJsonObject(FFSoundOptions* options, yyjson_val* module)
 {
-    FFSoundOptions __attribute__((__cleanup__(ffDestroySoundOptions))) options;
-    ffInitSoundOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -132,7 +129,7 @@ void ffParseSoundJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "soundType"))
@@ -145,15 +142,13 @@ void ffParseSoundJsonObject(yyjson_val* module)
                     {},
                 });
                 if (error)
-                    ffPrintError(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;
+                    options->soundType = (FFSoundType) value;
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/sound/sound.h b/src/modules/sound/sound.h
index 4b02f4d24..c35c16801 100644
--- a/src/modules/sound/sound.h
+++ b/src/modules/sound/sound.h
@@ -8,4 +8,4 @@ void ffPrintSound(FFSoundOptions* options);
 void ffInitSoundOptions(FFSoundOptions* options);
 bool ffParseSoundCommandOptions(FFSoundOptions* options, const char* key, const char* value);
 void ffDestroySoundOptions(FFSoundOptions* options);
-void ffParseSoundJsonObject(yyjson_val* module);
+void ffParseSoundJsonObject(FFSoundOptions* options, yyjson_val* module);
diff --git a/src/modules/swap/option.h b/src/modules/swap/option.h
index 4053cfbe1..52fea1733 100644
--- a/src/modules/swap/option.h
+++ b/src/modules/swap/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFSwapOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFSwapOptions;
diff --git a/src/modules/swap/swap.c b/src/modules/swap/swap.c
index 7da77e086..aa1b1b9a1 100644
--- a/src/modules/swap/swap.c
+++ b/src/modules/swap/swap.c
@@ -73,7 +73,7 @@ void ffPrintSwap(FFSwapOptions* options)
 
 void ffInitSwapOptions(FFSwapOptions* options)
 {
-    options->moduleName = FF_SWAP_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SWAP_MODULE_NAME, ffParseSwapCommandOptions, ffParseSwapJsonObject, ffPrintSwap);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -92,11 +92,8 @@ void ffDestroySwapOptions(FFSwapOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseSwapJsonObject(yyjson_val* module)
+void ffParseSwapJsonObject(FFSwapOptions* options, yyjson_val* module)
 {
-    FFSwapOptions __attribute__((__cleanup__(ffDestroySwapOptions))) options;
-    ffInitSwapOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -107,12 +104,10 @@ void ffParseSwapJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/swap/swap.h b/src/modules/swap/swap.h
index 3cd4f5b14..5921ad9c5 100644
--- a/src/modules/swap/swap.h
+++ b/src/modules/swap/swap.h
@@ -8,4 +8,4 @@ void ffPrintSwap(FFSwapOptions* options);
 void ffInitSwapOptions(FFSwapOptions* options);
 bool ffParseSwapCommandOptions(FFSwapOptions* options, const char* key, const char* value);
 void ffDestroySwapOptions(FFSwapOptions* options);
-void ffParseSwapJsonObject(yyjson_val* module);
+void ffParseSwapJsonObject(FFSwapOptions* options, yyjson_val* module);
diff --git a/src/modules/terminal/option.h b/src/modules/terminal/option.h
index 151129e13..e974c9979 100644
--- a/src/modules/terminal/option.h
+++ b/src/modules/terminal/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFTerminalOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFTerminalOptions;
diff --git a/src/modules/terminal/terminal.c b/src/modules/terminal/terminal.c
index ed257fd52..2cba2e302 100644
--- a/src/modules/terminal/terminal.c
+++ b/src/modules/terminal/terminal.c
@@ -46,7 +46,7 @@ void ffPrintTerminal(FFTerminalOptions* options)
 
 void ffInitTerminalOptions(FFTerminalOptions* options)
 {
-    options->moduleName = FF_TERMINAL_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TERMINAL_MODULE_NAME, ffParseTerminalCommandOptions, ffParseTerminalJsonObject, ffPrintTerminal);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -65,11 +65,8 @@ void ffDestroyTerminalOptions(FFTerminalOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseTerminalJsonObject(yyjson_val* module)
+void ffParseTerminalJsonObject(FFTerminalOptions* options, yyjson_val* module)
 {
-    FFTerminalOptions __attribute__((__cleanup__(ffDestroyTerminalOptions))) options;
-    ffInitTerminalOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -80,12 +77,10 @@ void ffParseTerminalJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/terminal/terminal.h b/src/modules/terminal/terminal.h
index 45372754d..09949b00d 100644
--- a/src/modules/terminal/terminal.h
+++ b/src/modules/terminal/terminal.h
@@ -8,4 +8,4 @@ void ffPrintTerminal(FFTerminalOptions* options);
 void ffInitTerminalOptions(FFTerminalOptions* options);
 bool ffParseTerminalCommandOptions(FFTerminalOptions* options, const char* key, const char* value);
 void ffDestroyTerminalOptions(FFTerminalOptions* options);
-void ffParseTerminalJsonObject(yyjson_val* module);
+void ffParseTerminalJsonObject(FFTerminalOptions* options, yyjson_val* module);
diff --git a/src/modules/terminalfont/option.h b/src/modules/terminalfont/option.h
index ba62efbb5..64417bf0a 100644
--- a/src/modules/terminalfont/option.h
+++ b/src/modules/terminalfont/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFTerminalFontOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFTerminalFontOptions;
diff --git a/src/modules/terminalfont/terminalfont.c b/src/modules/terminalfont/terminalfont.c
index 2c2886027..f0bb786c4 100644
--- a/src/modules/terminalfont/terminalfont.c
+++ b/src/modules/terminalfont/terminalfont.c
@@ -49,7 +49,7 @@ void ffPrintTerminalFont(FFTerminalFontOptions* options)
 
 void ffInitTerminalFontOptions(FFTerminalFontOptions* options)
 {
-    options->moduleName = FF_TERMINALFONT_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontCommandOptions, ffParseTerminalFontJsonObject, ffPrintTerminalFont);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -68,11 +68,8 @@ void ffDestroyTerminalFontOptions(FFTerminalFontOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseTerminalFontJsonObject(yyjson_val* module)
+void ffParseTerminalFontJsonObject(FFTerminalFontOptions* options, yyjson_val* module)
 {
-    FFTerminalFontOptions __attribute__((__cleanup__(ffDestroyTerminalFontOptions))) options;
-    ffInitTerminalFontOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -83,12 +80,10 @@ void ffParseTerminalFontJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/terminalfont/terminalfont.h b/src/modules/terminalfont/terminalfont.h
index a538cd0d7..ac5953a36 100644
--- a/src/modules/terminalfont/terminalfont.h
+++ b/src/modules/terminalfont/terminalfont.h
@@ -8,4 +8,4 @@ void ffPrintTerminalFont(FFTerminalFontOptions* options);
 void ffInitTerminalFontOptions(FFTerminalFontOptions* options);
 bool ffParseTerminalFontCommandOptions(FFTerminalFontOptions* options, const char* key, const char* value);
 void ffDestroyTerminalFontOptions(FFTerminalFontOptions* options);
-void ffParseTerminalFontJsonObject(yyjson_val* module);
+void ffParseTerminalFontJsonObject(FFTerminalFontOptions* options, yyjson_val* module);
diff --git a/src/modules/terminalsize/option.h b/src/modules/terminalsize/option.h
index 16f482466..7d584837f 100644
--- a/src/modules/terminalsize/option.h
+++ b/src/modules/terminalsize/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFTerminalSizeOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFTerminalSizeOptions;
diff --git a/src/modules/terminalsize/terminalsize.c b/src/modules/terminalsize/terminalsize.c
index 3a794cbfe..0f10f2c6c 100644
--- a/src/modules/terminalsize/terminalsize.c
+++ b/src/modules/terminalsize/terminalsize.c
@@ -41,7 +41,7 @@ void ffPrintTerminalSize(FFTerminalSizeOptions* options)
 
 void ffInitTerminalSizeOptions(FFTerminalSizeOptions* options)
 {
-    options->moduleName = FF_TERMINALSIZE_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TERMINALSIZE_MODULE_NAME, ffParseTerminalSizeCommandOptions, ffParseTerminalSizeJsonObject, ffPrintTerminalSize);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -60,11 +60,8 @@ void ffDestroyTerminalSizeOptions(FFTerminalSizeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseTerminalSizeJsonObject(yyjson_val* module)
+void ffParseTerminalSizeJsonObject(FFTerminalSizeOptions* options, yyjson_val* module)
 {
-    FFTerminalSizeOptions __attribute__((__cleanup__(ffDestroyTerminalSizeOptions))) options;
-    ffInitTerminalSizeOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -75,12 +72,10 @@ void ffParseTerminalSizeJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(FF_TERMINALSIZE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(FF_TERMINALSIZE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key);
         }
     }
-
-    ffPrintTerminalSize(&options);
 }
diff --git a/src/modules/terminalsize/terminalsize.h b/src/modules/terminalsize/terminalsize.h
index 0b1b37d32..1703c5944 100644
--- a/src/modules/terminalsize/terminalsize.h
+++ b/src/modules/terminalsize/terminalsize.h
@@ -8,4 +8,4 @@ void ffPrintTerminalSize(FFTerminalSizeOptions* options);
 void ffInitTerminalSizeOptions(FFTerminalSizeOptions* options);
 bool ffParseTerminalSizeCommandOptions(FFTerminalSizeOptions* options, const char* key, const char* value);
 void ffDestroyTerminalSizeOptions(FFTerminalSizeOptions* options);
-void ffParseTerminalSizeJsonObject(yyjson_val* module);
+void ffParseTerminalSizeJsonObject(FFTerminalSizeOptions* options, yyjson_val* module);
diff --git a/src/modules/theme/option.h b/src/modules/theme/option.h
index f322c3a62..9c3b32a88 100644
--- a/src/modules/theme/option.h
+++ b/src/modules/theme/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFThemeOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFThemeOptions;
diff --git a/src/modules/theme/theme.c b/src/modules/theme/theme.c
index 053c7cb57..e54b33ed6 100644
--- a/src/modules/theme/theme.c
+++ b/src/modules/theme/theme.c
@@ -32,7 +32,7 @@ void ffPrintTheme(FFThemeOptions* options)
 
 void ffInitThemeOptions(FFThemeOptions* options)
 {
-    options->moduleName = FF_THEME_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_THEME_MODULE_NAME, ffParseThemeCommandOptions, ffParseThemeJsonObject, ffPrintTheme);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -51,11 +51,8 @@ void ffDestroyThemeOptions(FFThemeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseThemeJsonObject(yyjson_val* module)
+void ffParseThemeJsonObject(FFThemeOptions* options, yyjson_val* module)
 {
-    FFThemeOptions __attribute__((__cleanup__(ffDestroyThemeOptions))) options;
-    ffInitThemeOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseThemeJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/theme/theme.h b/src/modules/theme/theme.h
index 37a006dd4..ef8f18a79 100644
--- a/src/modules/theme/theme.h
+++ b/src/modules/theme/theme.h
@@ -8,4 +8,4 @@ void ffPrintTheme(FFThemeOptions* options);
 void ffInitThemeOptions(FFThemeOptions* options);
 bool ffParseThemeCommandOptions(FFThemeOptions* options, const char* key, const char* value);
 void ffDestroyThemeOptions(FFThemeOptions* options);
-void ffParseThemeJsonObject(yyjson_val* module);
+void ffParseThemeJsonObject(FFThemeOptions* options, yyjson_val* module);
diff --git a/src/modules/title/option.h b/src/modules/title/option.h
index b44aef8ed..9c3ea074b 100644
--- a/src/modules/title/option.h
+++ b/src/modules/title/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFTitleOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     bool fqdn;
diff --git a/src/modules/title/title.c b/src/modules/title/title.c
index 297b0a6bb..b0730cab4 100644
--- a/src/modules/title/title.c
+++ b/src/modules/title/title.c
@@ -51,7 +51,7 @@ void ffPrintTitle(FFTitleOptions* options)
 
 void ffInitTitleOptions(FFTitleOptions* options)
 {
-    options->moduleName = FF_TITLE_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TITLE_MODULE_NAME, ffParseTitleCommandOptions, ffParseTitleJsonObject, ffPrintTitle);
     ffOptionInitModuleArg(&options->moduleArgs);
     options->fqdn = false;
     ffStrbufInit(&options->colorUser);
@@ -101,11 +101,8 @@ void ffDestroyTitleOptions(FFTitleOptions* options)
     ffStrbufDestroy(&options->colorHost);
 }
 
-void ffParseTitleJsonObject(yyjson_val* module)
+void ffParseTitleJsonObject(FFTitleOptions* options, yyjson_val* module)
 {
-    FFTitleOptions __attribute__((__cleanup__(ffDestroyTitleOptions))) options;
-    ffInitTitleOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -116,12 +113,12 @@ void ffParseTitleJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "fqdn"))
             {
-                options.fqdn = yyjson_get_bool(val);
+                options->fqdn = yyjson_get_bool(val);
                 continue;
             }
 
@@ -132,19 +129,17 @@ void ffParseTitleJsonObject(yyjson_val* module)
 
                 yyjson_val* color = yyjson_obj_get(val, "user");
                 if (color)
-                    ffOptionParseColor(yyjson_get_str(color), &options.colorUser);
+                    ffOptionParseColor(yyjson_get_str(color), &options->colorUser);
                 color = yyjson_obj_get(val, "at");
                 if (color)
-                    ffOptionParseColor(yyjson_get_str(color), &options.colorAt);
+                    ffOptionParseColor(yyjson_get_str(color), &options->colorAt);
                 color = yyjson_obj_get(val, "host");
                 if (color)
-                    ffOptionParseColor(yyjson_get_str(color), &options.colorHost);
+                    ffOptionParseColor(yyjson_get_str(color), &options->colorHost);
                 continue;
             }
 
             ffPrintErrorString(FF_TITLE_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key);
         }
     }
-
-    ffPrintTitle(&options);
 }
diff --git a/src/modules/title/title.h b/src/modules/title/title.h
index 7bd407243..fd7ae5e68 100644
--- a/src/modules/title/title.h
+++ b/src/modules/title/title.h
@@ -8,4 +8,4 @@ void ffPrintTitle(FFTitleOptions* options);
 void ffInitTitleOptions(FFTitleOptions* options);
 bool ffParseTitleCommandOptions(FFTitleOptions* options, const char* key, const char* value);
 void ffDestroyTitleOptions(FFTitleOptions* options);
-void ffParseTitleJsonObject(yyjson_val* module);
+void ffParseTitleJsonObject(FFTitleOptions* options, yyjson_val* module);
diff --git a/src/modules/uptime/option.h b/src/modules/uptime/option.h
index 722d236d3..f047db76c 100644
--- a/src/modules/uptime/option.h
+++ b/src/modules/uptime/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFUptimeOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFUptimeOptions;
diff --git a/src/modules/uptime/uptime.c b/src/modules/uptime/uptime.c
index 3de7d80f7..9f96b6d16 100644
--- a/src/modules/uptime/uptime.c
+++ b/src/modules/uptime/uptime.c
@@ -81,7 +81,7 @@ void ffPrintUptime(FFUptimeOptions* options)
 
 void ffInitUptimeOptions(FFUptimeOptions* options)
 {
-    options->moduleName = FF_UPTIME_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_UPTIME_MODULE_NAME, ffParseUptimeCommandOptions, ffParseUptimeJsonObject, ffPrintUptime);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -100,11 +100,8 @@ void ffDestroyUptimeOptions(FFUptimeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseUptimeJsonObject(yyjson_val* module)
+void ffParseUptimeJsonObject(FFUptimeOptions* options, yyjson_val* module)
 {
-    FFUptimeOptions __attribute__((__cleanup__(ffDestroyUptimeOptions))) options;
-    ffInitUptimeOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -115,12 +112,10 @@ void ffParseUptimeJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/uptime/uptime.h b/src/modules/uptime/uptime.h
index 4708dbd39..3bc1fd55f 100644
--- a/src/modules/uptime/uptime.h
+++ b/src/modules/uptime/uptime.h
@@ -8,4 +8,4 @@ void ffPrintUptime(FFUptimeOptions* options);
 void ffInitUptimeOptions(FFUptimeOptions* options);
 bool ffParseUptimeCommandOptions(FFUptimeOptions* options, const char* key, const char* value);
 void ffDestroyUptimeOptions(FFUptimeOptions* options);
-void ffParseUptimeJsonObject(yyjson_val* module);
+void ffParseUptimeJsonObject(FFUptimeOptions* options, yyjson_val* module);
diff --git a/src/modules/users/option.h b/src/modules/users/option.h
index f7f0b099e..80bf87698 100644
--- a/src/modules/users/option.h
+++ b/src/modules/users/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFUsersOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFUsersOptions;
diff --git a/src/modules/users/users.c b/src/modules/users/users.c
index 260cd87d3..242566a0c 100644
--- a/src/modules/users/users.c
+++ b/src/modules/users/users.c
@@ -45,7 +45,7 @@ void ffPrintUsers(FFUsersOptions* options)
 
 void ffInitUsersOptions(FFUsersOptions* options)
 {
-    options->moduleName = FF_USERS_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_USERS_MODULE_NAME, ffParseUsersCommandOptions, ffParseUsersJsonObject, ffPrintUsers);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -64,11 +64,8 @@ void ffDestroyUsersOptions(FFUsersOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseUsersJsonObject(yyjson_val* module)
+void ffParseUsersJsonObject(FFUsersOptions* options, yyjson_val* module)
 {
-    FFUsersOptions __attribute__((__cleanup__(ffDestroyUsersOptions))) options;
-    ffInitUsersOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -79,12 +76,10 @@ void ffParseUsersJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/users/users.h b/src/modules/users/users.h
index 64aab51b7..86d5f66f4 100644
--- a/src/modules/users/users.h
+++ b/src/modules/users/users.h
@@ -8,4 +8,4 @@ void ffPrintUsers(FFUsersOptions* options);
 void ffInitUsersOptions(FFUsersOptions* options);
 bool ffParseUsersCommandOptions(FFUsersOptions* options, const char* key, const char* value);
 void ffDestroyUsersOptions(FFUsersOptions* options);
-void ffParseUsersJsonObject(yyjson_val* module);
+void ffParseUsersJsonObject(FFUsersOptions* options, yyjson_val* module);
diff --git a/src/modules/vulkan/option.h b/src/modules/vulkan/option.h
index c5efd077b..132af5bbe 100644
--- a/src/modules/vulkan/option.h
+++ b/src/modules/vulkan/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFVulkanOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFVulkanOptions;
diff --git a/src/modules/vulkan/vulkan.c b/src/modules/vulkan/vulkan.c
index aa79c6ddf..d24c82d04 100644
--- a/src/modules/vulkan/vulkan.c
+++ b/src/modules/vulkan/vulkan.c
@@ -45,7 +45,7 @@ void ffPrintVulkan(FFVulkanOptions* options)
 
 void ffInitVulkanOptions(FFVulkanOptions* options)
 {
-    options->moduleName = FF_VULKAN_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_VULKAN_MODULE_NAME, ffParseVulkanCommandOptions, ffParseVulkanJsonObject, ffPrintVulkan);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -64,11 +64,8 @@ void ffDestroyVulkanOptions(FFVulkanOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseVulkanJsonObject(yyjson_val* module)
+void ffParseVulkanJsonObject(FFVulkanOptions* options, yyjson_val* module)
 {
-    FFVulkanOptions __attribute__((__cleanup__(ffDestroyVulkanOptions))) options;
-    ffInitVulkanOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -79,12 +76,10 @@ void ffParseVulkanJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/vulkan/vulkan.h b/src/modules/vulkan/vulkan.h
index 5b92ff850..e9b7d3954 100644
--- a/src/modules/vulkan/vulkan.h
+++ b/src/modules/vulkan/vulkan.h
@@ -8,4 +8,4 @@ void ffPrintVulkan(FFVulkanOptions* options);
 void ffInitVulkanOptions(FFVulkanOptions* options);
 bool ffParseVulkanCommandOptions(FFVulkanOptions* options, const char* key, const char* value);
 void ffDestroyVulkanOptions(FFVulkanOptions* options);
-void ffParseVulkanJsonObject(yyjson_val* module);
+void ffParseVulkanJsonObject(FFVulkanOptions* options, yyjson_val* module);
diff --git a/src/modules/wallpaper/option.h b/src/modules/wallpaper/option.h
index ff7aa55fe..539a57f9b 100644
--- a/src/modules/wallpaper/option.h
+++ b/src/modules/wallpaper/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFWallpaperOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFWallpaperOptions;
diff --git a/src/modules/wallpaper/wallpaper.c b/src/modules/wallpaper/wallpaper.c
index 08720f891..03128c48c 100644
--- a/src/modules/wallpaper/wallpaper.c
+++ b/src/modules/wallpaper/wallpaper.c
@@ -44,7 +44,7 @@ void ffPrintWallpaper(FFWallpaperOptions* options)
 
 void ffInitWallpaperOptions(FFWallpaperOptions* options)
 {
-    options->moduleName = FF_WALLPAPER_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperCommandOptions, ffParseWallpaperJsonObject, ffPrintWallpaper);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -63,11 +63,8 @@ void ffDestroyWallpaperOptions(FFWallpaperOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWallpaperJsonObject(yyjson_val* module)
+void ffParseWallpaperJsonObject(FFWallpaperOptions* options, yyjson_val* module)
 {
-    FFWallpaperOptions __attribute__((__cleanup__(ffDestroyWallpaperOptions))) options;
-    ffInitWallpaperOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -78,12 +75,10 @@ void ffParseWallpaperJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/wallpaper/wallpaper.h b/src/modules/wallpaper/wallpaper.h
index b274f037d..244684fc4 100644
--- a/src/modules/wallpaper/wallpaper.h
+++ b/src/modules/wallpaper/wallpaper.h
@@ -8,4 +8,4 @@ void ffPrintWallpaper(FFWallpaperOptions* options);
 void ffInitWallpaperOptions(FFWallpaperOptions* options);
 bool ffParseWallpaperCommandOptions(FFWallpaperOptions* options, const char* key, const char* value);
 void ffDestroyWallpaperOptions(FFWallpaperOptions* options);
-void ffParseWallpaperJsonObject(yyjson_val* module);
+void ffParseWallpaperJsonObject(FFWallpaperOptions* options, yyjson_val* module);
diff --git a/src/modules/weather/option.h b/src/modules/weather/option.h
index 6f82f5388..b8c7e7cad 100644
--- a/src/modules/weather/option.h
+++ b/src/modules/weather/option.h
@@ -6,7 +6,7 @@
 
 typedef struct FFWeatherOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 
     FFstrbuf location;
diff --git a/src/modules/weather/weather.c b/src/modules/weather/weather.c
index a32292f7d..61e0bdeaa 100644
--- a/src/modules/weather/weather.c
+++ b/src/modules/weather/weather.c
@@ -55,7 +55,7 @@ void ffPrintWeather(FFWeatherOptions* options)
 
 void ffInitWeatherOptions(FFWeatherOptions* options)
 {
-    options->moduleName = FF_WEATHER_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WEATHER_MODULE_NAME, ffParseWeatherCommandOptions, ffParseWeatherJsonObject, ffPrintWeather);
     ffOptionInitModuleArg(&options->moduleArgs);
 
     ffStrbufInit(&options->location);
@@ -98,11 +98,8 @@ void ffDestroyWeatherOptions(FFWeatherOptions* options)
     ffStrbufDestroy(&options->outputFormat);
 }
 
-void ffParseWeatherJsonObject(yyjson_val* module)
+void ffParseWeatherJsonObject(FFWeatherOptions* options, yyjson_val* module)
 {
-    FFWeatherOptions __attribute__((__cleanup__(ffDestroyWeatherOptions))) options;
-    ffInitWeatherOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -113,30 +110,28 @@ void ffParseWeatherJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
             if (ffStrEqualsIgnCase(key, "location"))
             {
-                ffStrbufSetS(&options.location, yyjson_get_str(val));
+                ffStrbufSetS(&options->location, yyjson_get_str(val));
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "outputFormat"))
             {
-                ffStrbufSetS(&options.outputFormat, yyjson_get_str(val));
+                ffStrbufSetS(&options->outputFormat, yyjson_get_str(val));
                 continue;
             }
 
             if (ffStrEqualsIgnCase(key, "timeout"))
             {
-                options.timeout = (uint32_t) yyjson_get_uint(val);
+                options->timeout = (uint32_t) yyjson_get_uint(val);
                 continue;
             }
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/weather/weather.h b/src/modules/weather/weather.h
index 640201176..888606957 100644
--- a/src/modules/weather/weather.h
+++ b/src/modules/weather/weather.h
@@ -10,4 +10,4 @@ void ffPrintWeather(FFWeatherOptions* options);
 void ffInitWeatherOptions(FFWeatherOptions* options);
 bool ffParseWeatherCommandOptions(FFWeatherOptions* options, const char* key, const char* value);
 void ffDestroyWeatherOptions(FFWeatherOptions* options);
-void ffParseWeatherJsonObject(yyjson_val* module);
+void ffParseWeatherJsonObject(FFWeatherOptions* options, yyjson_val* module);
diff --git a/src/modules/wifi/option.h b/src/modules/wifi/option.h
index 4d713b5d8..0dcad05fd 100644
--- a/src/modules/wifi/option.h
+++ b/src/modules/wifi/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFWifiOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFWifiOptions;
diff --git a/src/modules/wifi/wifi.c b/src/modules/wifi/wifi.c
index 6798c063f..608ab86b0 100644
--- a/src/modules/wifi/wifi.c
+++ b/src/modules/wifi/wifi.c
@@ -72,7 +72,7 @@ void ffPrintWifi(FFWifiOptions* options)
 
 void ffInitWifiOptions(FFWifiOptions* options)
 {
-    options->moduleName = FF_WIFI_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WIFI_MODULE_NAME, ffParseWifiCommandOptions, ffParseWifiJsonObject, ffPrintWifi);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -91,11 +91,8 @@ void ffDestroyWifiOptions(FFWifiOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWifiJsonObject(yyjson_val* module)
+void ffParseWifiJsonObject(FFWifiOptions* options, yyjson_val* module)
 {
-    FFWifiOptions __attribute__((__cleanup__(ffDestroyWifiOptions))) options;
-    ffInitWifiOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -106,12 +103,10 @@ void ffParseWifiJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/wifi/wifi.h b/src/modules/wifi/wifi.h
index b8291fdfc..0a7b78e2d 100644
--- a/src/modules/wifi/wifi.h
+++ b/src/modules/wifi/wifi.h
@@ -8,4 +8,4 @@ void ffPrintWifi(FFWifiOptions* options);
 void ffInitWifiOptions(FFWifiOptions* options);
 bool ffParseWifiCommandOptions(FFWifiOptions* options, const char* key, const char* value);
 void ffDestroyWifiOptions(FFWifiOptions* options);
-void ffParseWifiJsonObject(yyjson_val* module);
+void ffParseWifiJsonObject(FFWifiOptions* options, yyjson_val* module);
diff --git a/src/modules/wm/option.h b/src/modules/wm/option.h
index fcc7b0231..24c16f311 100644
--- a/src/modules/wm/option.h
+++ b/src/modules/wm/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFWMOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFWMOptions;
diff --git a/src/modules/wm/wm.c b/src/modules/wm/wm.c
index 018bbee73..101d93d7b 100644
--- a/src/modules/wm/wm.c
+++ b/src/modules/wm/wm.c
@@ -43,7 +43,7 @@ void ffPrintWM(FFWMOptions* options)
 
 void ffInitWMOptions(FFWMOptions* options)
 {
-    options->moduleName = FF_WM_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WM_MODULE_NAME, ffParseWMCommandOptions, ffParseWMJsonObject, ffPrintWM);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -62,11 +62,8 @@ void ffDestroyWMOptions(FFWMOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWMJsonObject(yyjson_val* module)
+void ffParseWMJsonObject(FFWMOptions* options, yyjson_val* module)
 {
-    FFWMOptions __attribute__((__cleanup__(ffDestroyWMOptions))) options;
-    ffInitWMOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -77,12 +74,10 @@ void ffParseWMJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/wm/wm.h b/src/modules/wm/wm.h
index 243d6a647..607732d72 100644
--- a/src/modules/wm/wm.h
+++ b/src/modules/wm/wm.h
@@ -8,4 +8,4 @@ void ffPrintWM(FFWMOptions* options);
 void ffInitWMOptions(FFWMOptions* options);
 bool ffParseWMCommandOptions(FFWMOptions* options, const char* key, const char* value);
 void ffDestroyWMOptions(FFWMOptions* options);
-void ffParseWMJsonObject(yyjson_val* module);
+void ffParseWMJsonObject(FFWMOptions* options, yyjson_val* module);
diff --git a/src/modules/wmtheme/option.h b/src/modules/wmtheme/option.h
index 11b14458b..b2b9fc5a8 100644
--- a/src/modules/wmtheme/option.h
+++ b/src/modules/wmtheme/option.h
@@ -6,6 +6,6 @@
 
 typedef struct FFWMThemeOptions
 {
-    const char* moduleName;
+    FFModuleBaseInfo moduleInfo;
     FFModuleArgs moduleArgs;
 } FFWMThemeOptions;
diff --git a/src/modules/wmtheme/wmtheme.c b/src/modules/wmtheme/wmtheme.c
index c61f216e6..9a4edb19f 100644
--- a/src/modules/wmtheme/wmtheme.c
+++ b/src/modules/wmtheme/wmtheme.c
@@ -32,7 +32,7 @@ void ffPrintWMTheme(FFWMThemeOptions* options)
 
 void ffInitWMThemeOptions(FFWMThemeOptions* options)
 {
-    options->moduleName = FF_WMTHEME_MODULE_NAME;
+    ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WMTHEME_MODULE_NAME, ffParseWMThemeCommandOptions, ffParseWMThemeJsonObject, ffPrintWMTheme);
     ffOptionInitModuleArg(&options->moduleArgs);
 }
 
@@ -51,11 +51,8 @@ void ffDestroyWMThemeOptions(FFWMThemeOptions* options)
     ffOptionDestroyModuleArg(&options->moduleArgs);
 }
 
-void ffParseWMThemeJsonObject(yyjson_val* module)
+void ffParseWMThemeJsonObject(FFWMThemeOptions* options, yyjson_val* module)
 {
-    FFWMThemeOptions __attribute__((__cleanup__(ffDestroyWMThemeOptions))) options;
-    ffInitWMThemeOptions(&options);
-
     if (module)
     {
         yyjson_val *key_, *val;
@@ -66,12 +63,10 @@ void ffParseWMThemeJsonObject(yyjson_val* module)
             if(ffStrEqualsIgnCase(key, "type"))
                 continue;
 
-            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+            if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
                 continue;
 
-            ffPrintError(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(&options);
 }
diff --git a/src/modules/wmtheme/wmtheme.h b/src/modules/wmtheme/wmtheme.h
index 021408945..216fdc723 100644
--- a/src/modules/wmtheme/wmtheme.h
+++ b/src/modules/wmtheme/wmtheme.h
@@ -8,4 +8,4 @@ void ffPrintWMTheme(FFWMThemeOptions* options);
 void ffInitWMThemeOptions(FFWMThemeOptions* options);
 bool ffParseWMThemeCommandOptions(FFWMThemeOptions* options, const char* key, const char* value);
 void ffDestroyWMThemeOptions(FFWMThemeOptions* options);
-void ffParseWMThemeJsonObject(yyjson_val* module);
+void ffParseWMThemeJsonObject(FFWMThemeOptions* options, yyjson_val* module);