diff --git a/CMakeLists.txt b/CMakeLists.txt
index d66f177a7..1bad75611 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -65,11 +65,8 @@ set(SRCS
     src/common/logo.c
     src/common/format.c
     src/common/parsing.c
-    src/common/calculateOS.c
-    src/common/calculatePlasma.c
-    src/common/calculateGTK.c
-    src/common/calculateTerminal.c
-    src/common/calculateWM.c
+    src/common/detectPlasma.c
+    src/common/detectGTK.c
     src/modules/break.c
     src/modules/custom.c
     src/modules/title.c
diff --git a/src/common/calculateOS.c b/src/common/calculateOS.c
deleted file mode 100644
index f301428fb..000000000
--- a/src/common/calculateOS.c
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "fastfetch.h"
-
-#include <pthread.h>
-
-const FFOSResult* ffCalculateOS(FFinstance* instance)
-{
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFOSResult result;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-    init = true;
-
-    FILE* osRelease = fopen("/etc/os-release", "r");
-
-    if(osRelease == NULL)
-        osRelease = fopen("/usr/lib/os-release", "r");
-
-    ffStrbufInitA(&result.error, 64);
-    if(osRelease == NULL)
-    {
-        ffStrbufAppendS(&result.error, "couldn't read /etc/os-release nor /usr/lib/os-release");
-        return &result;
-    }
-
-    ffStrbufInitA(&result.systemName, 256);
-    ffStrbufInitA(&result.name, 256);
-    ffStrbufInitA(&result.prettyName, 256);
-    ffStrbufInitA(&result.id, 256);
-    ffStrbufInitA(&result.idLike, 256);
-    ffStrbufInitA(&result.variant, 256);
-    ffStrbufInitA(&result.variantID, 256);
-    ffStrbufInitA(&result.version, 256);
-    ffStrbufInitA(&result.versionID, 256);
-    ffStrbufInitA(&result.codename, 256);
-    ffStrbufInitA(&result.buildID, 256);
-    ffStrbufInitA(&result.architecture, 256);
-    ffStrbufInitA(&result.error, 256);
-
-    ffStrbufSetS(&result.systemName, instance->state.utsname.sysname);
-    ffStrbufSetS(&result.architecture, instance->state.utsname.machine);
-
-    char* line = NULL;
-    size_t len = 0;
-
-    // Documentation of the fields:
-    // https://www.freedesktop.org/software/systemd/man/os-release.html
-    while (getline(&line, &len, osRelease) != -1)
-    {
-        sscanf(line, "NAME=%[^\n]", result.name.chars);
-        sscanf(line, "NAME=\"%[^\"]+", result.name.chars);
-        sscanf(line, "PRETTY_NAME=%[^\n]", result.prettyName.chars);
-        sscanf(line, "PRETTY_NAME=\"%[^\"]+", result.prettyName.chars);
-        sscanf(line, "ID=%[^\n]", result.id.chars);
-        sscanf(line, "ID=\"%[^\"]+", result.id.chars);
-        sscanf(line, "ID_LIKE=%[^\n]", result.idLike.chars);
-        sscanf(line, "ID_LIKE=\"%[^\"]+", result.idLike.chars);
-        sscanf(line, "VARIANT=%[^\n]", result.variant.chars);
-        sscanf(line, "VARIANT=\"%[^\"]+", result.variant.chars);
-        sscanf(line, "VARIANT_ID=%[^\n]", result.variantID.chars);
-        sscanf(line, "VARIANT_ID=\"%[^\"]+", result.variantID.chars);
-        sscanf(line, "VERSION=%[^\n]", result.version.chars);
-        sscanf(line, "VERSION=\"%[^\"]+", result.version.chars);
-        sscanf(line, "VERSION_ID=%[^\n]", result.versionID.chars);
-        sscanf(line, "VERSION_ID=\"%[^\"]+", result.versionID.chars);
-        sscanf(line, "VERSION_CODENAME=%[^\n]", result.codename.chars);
-        sscanf(line, "VERSION_CODENAME=\"%[^\"]+", result.codename.chars);
-        sscanf(line, "BUILD_ID=%[^\n]", result.buildID.chars);
-        sscanf(line, "BUILD_ID=\"%[^\"]+", result.buildID.chars);
-    }
-
-    ffStrbufRecalculateLength(&result.systemName);
-    ffStrbufRecalculateLength(&result.name);
-    ffStrbufRecalculateLength(&result.prettyName);
-    ffStrbufRecalculateLength(&result.id);
-    ffStrbufRecalculateLength(&result.idLike);
-    ffStrbufRecalculateLength(&result.variant);
-    ffStrbufRecalculateLength(&result.variantID);
-    ffStrbufRecalculateLength(&result.version);
-    ffStrbufRecalculateLength(&result.versionID);
-    ffStrbufRecalculateLength(&result.codename);
-    ffStrbufRecalculateLength(&result.buildID);
-    ffStrbufRecalculateLength(&result.architecture);
-    ffStrbufRecalculateLength(&result.error);
-
-    if(line != NULL)
-        free(line);
-
-    fclose(osRelease);
-
-    pthread_mutex_unlock(&mutex);
-
-    return &result;
-}
diff --git a/src/common/calculateTerminal.c b/src/common/calculateTerminal.c
deleted file mode 100644
index b48cf7ba5..000000000
--- a/src/common/calculateTerminal.c
+++ /dev/null
@@ -1,79 +0,0 @@
-#include "fastfetch.h"
-
-#include <string.h>
-#include <unistd.h>
-#include <pthread.h>
-
-static void getTerminalName(FFinstance* instance, const char* pid, FFTerminalResult* result)
-{
-    char statFile[234];
-    sprintf(statFile, "/proc/%s/stat", pid);
-
-    FILE* stat = fopen(statFile, "r");
-    if(stat == NULL)
-    {
-        ffStrbufSetF(&result->error, "fopen(\"%s\", \"r\") == NULL", statFile);
-        return;
-    }
-
-    char name[256];
-    char ppid[256];
-    if(fscanf(stat, "%*s (%[^)])%*s%s", name, ppid) != 2)
-    {
-        ffStrbufSetS(&result->error, "fscanf(stat, \"%*s (%[^)])%*s%s\", name, ppid) != 2");
-        return;
-    }
-
-    fclose(stat);
-
-    if (
-        strcasecmp(name, "bash")   == 0 ||
-        strcasecmp(name, "sh")     == 0 ||
-        strcasecmp(name, "zsh")    == 0 ||
-        strcasecmp(name, "ksh")    == 0 ||
-        strcasecmp(name, "fish")   == 0 ||
-        strcasecmp(name, "sudo")   == 0 ||
-        strcasecmp(name, "su")     == 0 ||
-        strcasecmp(name, "doas")   == 0 ||
-        strcasecmp(name, "strace") == 0 )
-    {
-        getTerminalName(instance, ppid, result);
-        return;
-    }
-
-    char cmdlineFile[234];
-    sprintf(cmdlineFile, "/proc/%s/cmdline", pid);
-
-    ffGetFileContent(cmdlineFile, &result->exeName);
-    ffStrbufSubstrBeforeFirstC(&result->exeName, '\0');
-    ffStrbufSubstrAfterLastC(&result->exeName, '/');
-
-    ffStrbufSetS(&result->processName, name);
-}
-
-const FFTerminalResult* ffCalculateTerminal(FFinstance* instance)
-{
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFTerminalResult result;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-    init = true;
-
-    ffStrbufInit(&result.exeName);
-    ffStrbufInit(&result.processName);
-    ffStrbufInit(&result.error);
-
-    char ppid[256];
-    sprintf(ppid, "%i", getppid());
-
-    getTerminalName(instance, ppid, &result);
-
-    pthread_mutex_unlock(&mutex);
-
-    return &result;
-}
diff --git a/src/common/calculateWM.c b/src/common/calculateWM.c
deleted file mode 100644
index b9c46262c..000000000
--- a/src/common/calculateWM.c
+++ /dev/null
@@ -1,128 +0,0 @@
-#include "fastfetch.h"
-
-#include <string.h>
-#include <dirent.h>
-#include <pthread.h>
-
-const char* ffGetSessionDesktop()
-{
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static char* sessionDesktop = NULL;
-
-    pthread_mutex_lock(&mutex);
-
-    if(sessionDesktop == NULL)
-        sessionDesktop = getenv("XDG_CURRENT_DESKTOP");
-
-    if(sessionDesktop == NULL)
-        sessionDesktop = getenv("XDG_SESSION_DESKTOP");
-
-    pthread_mutex_unlock(&mutex);
-
-    return sessionDesktop;
-}
-
-static void getFromProcDir(FFWMResult* result)
-{
-    DIR* proc = opendir("/proc/");
-    if(proc == NULL)
-        return;
-
-    struct dirent* dirent;
-
-    while((dirent = readdir(proc)) != NULL)
-    {
-        if(dirent->d_type != DT_DIR)
-            continue;
-
-        char path[20];
-        sprintf(path, "/proc/%.8s/comm", dirent->d_name);
-
-        ffGetFileContent(path, &result->processName);
-
-        if(ffStrbufIgnCaseCompS(&result->processName, "kwin_wayland") == 0)
-        {
-            ffStrbufSetS(&result->prettyName, "KWin");
-            ffStrbufSetS(&result->protocolName, "Wayland");
-        }
-        else if(ffStrbufIgnCaseCompS(&result->processName, "kwin_x11") == 0)
-        {
-            ffStrbufSetS(&result->prettyName, "KWin");
-            ffStrbufSetS(&result->protocolName, "X11");
-        }
-        else if(ffStrbufIgnCaseCompS(&result->processName, "openbox") == 0)
-            ffStrbufSetS(&result->prettyName, "Openbox");
-		else if(ffStrbufIgnCaseCompS(&result->processName, "cinnamon") == 0)
-            ffStrbufSetS(&result->prettyName, "Muffin");
-		else if(ffStrbufIgnCaseCompS(&result->processName, "xfwm4") == 0)
-            ffStrbufSetS(&result->prettyName, "XFWM");
-		else if(ffStrbufIgnCaseCompS(&result->processName, "wayfire") == 0)
-            ffStrbufSetS(&result->prettyName, "Wayfire");
-
-        if(result->prettyName.length > 0)
-            break;
-    }
-
-    closedir(proc);
-}
-
-static void getSessionType(FFstrbuf* sessionType)
-{
-    const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
-    if (xdgSessionType == NULL)
-        return;
-
-    else if(strcasecmp(xdgSessionType, "wayland") == 0)
-        ffStrbufSetS(sessionType, "Wayland");
-    else if(strcasecmp(xdgSessionType, "x11") == 0)
-        ffStrbufSetS(sessionType, "X11");
-    else if(strcasecmp(xdgSessionType, "tty") == 0)
-        ffStrbufSetS(sessionType, "TTY");
-    else if(strcasecmp(xdgSessionType, "mir") == 0)
-        ffStrbufSetS(sessionType, "Mir");
-    else
-        ffStrbufSetS(sessionType, xdgSessionType);
-}
-
-const FFWMResult* ffCalculateWM(FFinstance* instance)
-{
-    UNUSED(instance);
-
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFWMResult result;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-    init = true;
-
-    ffStrbufInit(&result.processName);
-    ffStrbufInit(&result.prettyName);
-    ffStrbufInit(&result.protocolName);
-    ffStrbufInit(&result.error);
-
-    getFromProcDir(&result);
-
-    if(result.prettyName.length == 0)
-    {
-        const char* sessionDesktop = ffGetSessionDesktop();
-        ffStrbufSetS(&result.processName, sessionDesktop);
-        ffStrbufSetS(&result.prettyName, sessionDesktop);
-    }
-
-    if(result.protocolName.length == 0)
-        getSessionType(&result.protocolName);
-
-    if(result.prettyName.length == 0 && result.protocolName.length == 0)
-    {
-        ffStrbufClear(&result.processName);
-        ffStrbufSetS(&result.error, "No WM or WM protocol type found");
-    }
-
-    pthread_mutex_unlock(&mutex);
-
-    return &result;
-}
diff --git a/src/common/calculateGTK.c b/src/common/detectGTK.c
similarity index 91%
rename from src/common/calculateGTK.c
rename to src/common/detectGTK.c
index b8cd5eeb6..aebad380b 100644
--- a/src/common/calculateGTK.c
+++ b/src/common/detectGTK.c
@@ -157,7 +157,7 @@ static void parseGTKConfigFile(FFstrbuf* fileName, FFGTKResult* result)
     ffStrbufRecalculateLength(&result->font);
 }
 
-static void calculateGTKFromConfigDir(const char* configDir, const char* version, FFGTKResult* result)
+static void detectGTKFromConfigDir(const char* configDir, const char* version, FFGTKResult* result)
 {
     // <configdir>/gtk-<version>.0/settings.ini
     FFstrbuf file1;
@@ -206,7 +206,7 @@ static void calculateGTKFromConfigDir(const char* configDir, const char* version
     ffStrbufDestroy(&file4);
 }
 
-static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult* result)
+static void detectGTK(FFinstance* instance, const char* version, FFGTKResult* result)
 {
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
@@ -239,18 +239,18 @@ static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult*
     if(xdgIsDifferent)
     {
         // $XDG_CONFIG_HOME
-        calculateGTKFromConfigDir(xdgConfigDir.chars, version, result);
+        detectGTKFromConfigDir(xdgConfigDir.chars, version, result);
         if(allPropertiesSet(result))
             return;
     }
 
     // /home/<user>/.config
-    calculateGTKFromConfigDir(configDir.chars, version, result);
+    detectGTKFromConfigDir(configDir.chars, version, result);
     if(allPropertiesSet(result))
             return;
 
     // /home/<user>
-    calculateGTKFromConfigDir(instance->state.passwd->pw_dir, version, result);
+    detectGTKFromConfigDir(instance->state.passwd->pw_dir, version, result);
     if(allPropertiesSet(result))
             return;
 
@@ -259,7 +259,7 @@ static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult*
         return;
 
     // /etc
-    calculateGTKFromConfigDir("/etc/", version, result);
+    detectGTKFromConfigDir("/etc/", version, result);
 }
 
 #define FF_CALCULATE_GTK_IMPL(version) \
@@ -275,21 +275,21 @@ static void calculateGTK(FFinstance* instance, const char* version, FFGTKResult*
     ffStrbufInit(&result.theme); \
     ffStrbufInit(&result.icons); \
     ffStrbufInit(&result.font); \
-    calculateGTK(instance, #version, &result); \
+    detectGTK(instance, #version, &result); \
     pthread_mutex_unlock(&mutex); \
     return &result;
 
-const FFGTKResult* ffCalculateGTK2(FFinstance* instance)
+const FFGTKResult* ffDetectGTK2(FFinstance* instance)
 {
     FF_CALCULATE_GTK_IMPL(2)
 }
 
-const FFGTKResult* ffCalculateGTK3(FFinstance* instance)
+const FFGTKResult* ffDetectGTK3(FFinstance* instance)
 {
     FF_CALCULATE_GTK_IMPL(3)
 }
 
-const FFGTKResult* ffCalculateGTK4(FFinstance* instance)
+const FFGTKResult* ffDetectGTK4(FFinstance* instance)
 {
     FF_CALCULATE_GTK_IMPL(4)
 }
diff --git a/src/common/calculatePlasma.c b/src/common/detectPlasma.c
similarity index 98%
rename from src/common/calculatePlasma.c
rename to src/common/detectPlasma.c
index f2909761d..13e7ac079 100644
--- a/src/common/calculatePlasma.c
+++ b/src/common/detectPlasma.c
@@ -11,7 +11,7 @@ typedef enum PlasmaCategory
     PLASMA_CATEGORY_OTHER
 } PlasmaCategory;
 
-const FFPlasmaResult* ffCalculatePlasma(FFinstance* instance)
+const FFPlasmaResult* ffDetectPlasma(FFinstance* instance)
 {
     static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
     static FFPlasmaResult result;
diff --git a/src/common/logo.c b/src/common/logo.c
index 33c522075..e2df7b73a 100644
--- a/src/common/logo.c
+++ b/src/common/logo.c
@@ -303,7 +303,7 @@ void ffLoadLogo(FFinstance* instance)
         ffStrbufDestroy(&content);
     }
 
-    const FFOSResult* result = ffCalculateOS(instance);
+    const FFOSResult* result = ffDetectOS(instance);
 
     if(result->id.length > 0)
     {
diff --git a/src/common/threading.c b/src/common/threading.c
index e75115de0..ec6012cf1 100644
--- a/src/common/threading.c
+++ b/src/common/threading.c
@@ -2,66 +2,66 @@
 
 #include <pthread.h>
 
-static inline void* calculatePlasmaThreadMain(void* instance)
+static inline void* detectPlasmaThreadMain(void* instance)
 {
-    ffCalculatePlasma((FFinstance*)instance);
+    ffDetectPlasma((FFinstance*)instance);
     return NULL;
 }
 
-static inline void* calculateGTK2ThreadMain(void* instance)
+static inline void* detectGTK2ThreadMain(void* instance)
 {
-    ffCalculateGTK2((FFinstance*)instance);
+    ffDetectGTK2((FFinstance*)instance);
     return NULL;
 }
 
-static inline void* calculateGTK3ThreadMain(void* instance)
+static inline void* detectGTK3ThreadMain(void* instance)
 {
-    ffCalculateGTK3((FFinstance*)instance);
+    ffDetectGTK3((FFinstance*)instance);
     return NULL;
 }
 
-static inline void* calculateGTK4ThreadMain(void* instance)
+static inline void* detectGTK4ThreadMain(void* instance)
 {
-    ffCalculateGTK4((FFinstance*)instance);
+    ffDetectGTK4((FFinstance*)instance);
     return NULL;
 }
 
-static inline void* calculateWMThreadMain(void* instance)
+static inline void* detectWMThreadMain(void* instance)
 {
-    ffCalculateWM((FFinstance*)instance);
+    ffDetectWM((FFinstance*)instance);
     return NULL;
 }
 
-static inline void* calculateTerminalThreadMain(void* instance)
+static inline void* detectTerminalThreadMain(void* instance)
 {
-    ffCalculateTerminal((FFinstance*)instance);
+    ffDetectTerminal((FFinstance*)instance);
     return NULL;
 }
 
 static inline void* startThreadsThreadMain(void* instance)
 {
     pthread_t wmThread;
-    pthread_create(&wmThread, NULL, calculateWMThreadMain, instance);
+    pthread_create(&wmThread, NULL, detectWMThreadMain, instance);
     pthread_detach(wmThread);
 
     pthread_t gtk2Thread;
-    pthread_create(&gtk2Thread, NULL, calculateGTK2ThreadMain, instance);
+    pthread_create(&gtk2Thread, NULL, detectGTK2ThreadMain, instance);
     pthread_detach(gtk2Thread);
 
     pthread_t gtk3Thread;
-    pthread_create(&gtk3Thread, NULL, calculateGTK3ThreadMain, instance);
+    pthread_create(&gtk3Thread, NULL, detectGTK3ThreadMain, instance);
     pthread_detach(gtk3Thread);
 
     pthread_t gtk4Thread;
-    pthread_create(&gtk4Thread, NULL, calculateGTK4ThreadMain, instance);
+    pthread_create(&gtk4Thread, NULL, detectGTK4ThreadMain, instance);
     pthread_detach(gtk4Thread);
 
     pthread_t terminalThread;
-    pthread_create(&terminalThread, NULL, calculateTerminalThreadMain, instance);
+    pthread_create(&terminalThread, NULL, detectTerminalThreadMain, instance);
     pthread_detach(terminalThread);
 
     pthread_t plasmaThread;
-    pthread_create(&plasmaThread, NULL, calculatePlasmaThreadMain, instance);
+    pthread_create(&plasmaThread, NULL, detectPlasmaThreadMain, instance);
     pthread_detach(plasmaThread);
 
     return NULL;
diff --git a/src/fastfetch.c b/src/fastfetch.c
index 98ace55e3..6c409b477 100644
--- a/src/fastfetch.c
+++ b/src/fastfetch.c
@@ -56,7 +56,7 @@ static inline void printHelp()
         "   -r <?value>  --recache <?value>:              generate new cached values\n"
         "                --nocache <?value>:              dont use cached values, but also dont overwrite existing ones\n"
         "                --print-remaining-logo <?value>: print the remaining logo, if it is higher than the number of lines shown\n"
-        "                --multithreading <?value>:       use multiple threads to calculate values\n"
+        "                --multithreading <?value>:       use multiple threads to detect values\n"
         "                --load-config <file>:            load a config file (+)\n"
         "\n"
         "Logo options:\n"
diff --git a/src/fastfetch.h b/src/fastfetch.h
index 90c6613b0..38319fe1d 100644
--- a/src/fastfetch.h
+++ b/src/fastfetch.h
@@ -244,28 +244,28 @@ void ffGetGtkPretty(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3
 void ffGetFont(const char* font, FFstrbuf* name, double* size);
 void ffGetFontPretty(FFstrbuf* buffer, const FFstrbuf* name, double size);
 
-//common/calculateOS.c
-const FFOSResult* ffCalculateOS(FFinstance* instance);
+//common/detectPlasma.c
+const FFPlasmaResult* ffDetectPlasma(FFinstance* instance);
 
-//common/calculatePlasma.c
-const FFPlasmaResult* ffCalculatePlasma(FFinstance* instance);
-
-//common/calculateGTK.c
-const FFGTKResult* ffCalculateGTK2(FFinstance* instance);
-const FFGTKResult* ffCalculateGTK4(FFinstance* instance);
-const FFGTKResult* ffCalculateGTK3(FFinstance* instance);
-
-//common/calculateWM.c
-const FFWMResult* ffCalculateWM(FFinstance* instance);
-
-//common/calculateTerminal.c
-const char* ffGetSessionDesktop();
-const FFTerminalResult* ffCalculateTerminal(FFinstance* instance);
+//common/detectGTK.c
+const FFGTKResult* ffDetectGTK2(FFinstance* instance);
+const FFGTKResult* ffDetectGTK4(FFinstance* instance);
+const FFGTKResult* ffDetectGTK3(FFinstance* instance);
 
 /********************/
 /* Module functions */
 /********************/
 
+//Common
+
+const char* ffGetSessionDesktop();
+
+const FFOSResult* ffDetectOS(FFinstance* instance);
+const FFTerminalResult* ffDetectTerminal(FFinstance* instance);
+const FFWMResult* ffDetectWM(FFinstance* instance);
+
+//Printing
+
 void ffPrintCustom(FFinstance* instance, const char* key, const char* value);
 void ffPrintBreak(FFinstance* instance);
 void ffPrintTitle(FFinstance* instance);
diff --git a/src/modules/de.c b/src/modules/de.c
index 9ebf07f53..9bacd2818 100644
--- a/src/modules/de.c
+++ b/src/modules/de.c
@@ -25,7 +25,7 @@ void ffPrintDesktopEnvironment(FFinstance* instance)
         return;
     }
 
-    const FFWMResult* wm = ffCalculateWM(instance);
+    const FFWMResult* wm = ffDetectWM(instance);
 
     // test if we are running only a WM
     if(
diff --git a/src/modules/font.c b/src/modules/font.c
index 757b87c3e..2453df3fd 100644
--- a/src/modules/font.c
+++ b/src/modules/font.c
@@ -5,10 +5,10 @@
 
 void ffPrintFont(FFinstance* instance)
 {
-    const FFstrbuf* plasma = &ffCalculatePlasma(instance)->font;
-    const FFstrbuf* gtk2 = &ffCalculateGTK2(instance)->font;
-    const FFstrbuf* gtk3 = &ffCalculateGTK3(instance)->font;
-    const FFstrbuf* gtk4 = &ffCalculateGTK4(instance)->font;
+    const FFstrbuf* plasma = &ffDetectPlasma(instance)->font;
+    const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->font;
+    const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->font;
+    const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->font;
 
     if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
     {
diff --git a/src/modules/icons.c b/src/modules/icons.c
index 73b9c4ef7..9160aef7d 100644
--- a/src/modules/icons.c
+++ b/src/modules/icons.c
@@ -5,10 +5,10 @@
 
 void ffPrintIcons(FFinstance* instance)
 {
-    const FFstrbuf* plasma = &ffCalculatePlasma(instance)->icons;
-    const FFstrbuf* gtk2 = &ffCalculateGTK2(instance)->icons;
-    const FFstrbuf* gtk3 = &ffCalculateGTK3(instance)->icons;
-    const FFstrbuf* gtk4 = &ffCalculateGTK4(instance)->icons;
+    const FFstrbuf* plasma = &ffDetectPlasma(instance)->icons;
+    const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->icons;
+    const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->icons;
+    const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->icons;
 
 
     if(plasma->length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
diff --git a/src/modules/os.c b/src/modules/os.c
index cc5dc063b..f85a72d4b 100644
--- a/src/modules/os.c
+++ b/src/modules/os.c
@@ -1,14 +1,111 @@
 #include "fastfetch.h"
 
+#include <pthread.h>
+
 #define FF_OS_MODULE_NAME "OS"
 #define FF_OS_NUM_FORMAT_ARGS 12
 
+const FFOSResult* ffDetectOS(FFinstance* instance)
+{
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    static FFOSResult result;
+    static bool init = false;
+    pthread_mutex_lock(&mutex);
+    if(init)
+    {
+        pthread_mutex_unlock(&mutex);
+        return &result;
+    }
+    init = true;
+
+    FILE* osRelease = fopen("/etc/os-release", "r");
+
+    if(osRelease == NULL)
+        osRelease = fopen("/usr/lib/os-release", "r");
+
+    ffStrbufInitA(&result.error, 64);
+    if(osRelease == NULL)
+    {
+        ffStrbufAppendS(&result.error, "couldn't read /etc/os-release nor /usr/lib/os-release");
+        return &result;
+    }
+
+    ffStrbufInitA(&result.systemName, 256);
+    ffStrbufInitA(&result.name, 256);
+    ffStrbufInitA(&result.prettyName, 256);
+    ffStrbufInitA(&result.id, 256);
+    ffStrbufInitA(&result.idLike, 256);
+    ffStrbufInitA(&result.variant, 256);
+    ffStrbufInitA(&result.variantID, 256);
+    ffStrbufInitA(&result.version, 256);
+    ffStrbufInitA(&result.versionID, 256);
+    ffStrbufInitA(&result.codename, 256);
+    ffStrbufInitA(&result.buildID, 256);
+    ffStrbufInitA(&result.architecture, 256);
+    ffStrbufInitA(&result.error, 256);
+
+    ffStrbufSetS(&result.systemName, instance->state.utsname.sysname);
+    ffStrbufSetS(&result.architecture, instance->state.utsname.machine);
+
+    char* line = NULL;
+    size_t len = 0;
+
+    // Documentation of the fields:
+    // https://www.freedesktop.org/software/systemd/man/os-release.html
+    while (getline(&line, &len, osRelease) != -1)
+    {
+        sscanf(line, "NAME=%[^\n]", result.name.chars);
+        sscanf(line, "NAME=\"%[^\"]+", result.name.chars);
+        sscanf(line, "PRETTY_NAME=%[^\n]", result.prettyName.chars);
+        sscanf(line, "PRETTY_NAME=\"%[^\"]+", result.prettyName.chars);
+        sscanf(line, "ID=%[^\n]", result.id.chars);
+        sscanf(line, "ID=\"%[^\"]+", result.id.chars);
+        sscanf(line, "ID_LIKE=%[^\n]", result.idLike.chars);
+        sscanf(line, "ID_LIKE=\"%[^\"]+", result.idLike.chars);
+        sscanf(line, "VARIANT=%[^\n]", result.variant.chars);
+        sscanf(line, "VARIANT=\"%[^\"]+", result.variant.chars);
+        sscanf(line, "VARIANT_ID=%[^\n]", result.variantID.chars);
+        sscanf(line, "VARIANT_ID=\"%[^\"]+", result.variantID.chars);
+        sscanf(line, "VERSION=%[^\n]", result.version.chars);
+        sscanf(line, "VERSION=\"%[^\"]+", result.version.chars);
+        sscanf(line, "VERSION_ID=%[^\n]", result.versionID.chars);
+        sscanf(line, "VERSION_ID=\"%[^\"]+", result.versionID.chars);
+        sscanf(line, "VERSION_CODENAME=%[^\n]", result.codename.chars);
+        sscanf(line, "VERSION_CODENAME=\"%[^\"]+", result.codename.chars);
+        sscanf(line, "BUILD_ID=%[^\n]", result.buildID.chars);
+        sscanf(line, "BUILD_ID=\"%[^\"]+", result.buildID.chars);
+    }
+
+    ffStrbufRecalculateLength(&result.systemName);
+    ffStrbufRecalculateLength(&result.name);
+    ffStrbufRecalculateLength(&result.prettyName);
+    ffStrbufRecalculateLength(&result.id);
+    ffStrbufRecalculateLength(&result.idLike);
+    ffStrbufRecalculateLength(&result.variant);
+    ffStrbufRecalculateLength(&result.variantID);
+    ffStrbufRecalculateLength(&result.version);
+    ffStrbufRecalculateLength(&result.versionID);
+    ffStrbufRecalculateLength(&result.codename);
+    ffStrbufRecalculateLength(&result.buildID);
+    ffStrbufRecalculateLength(&result.architecture);
+    ffStrbufRecalculateLength(&result.error);
+
+    if(line != NULL)
+        free(line);
+
+    fclose(osRelease);
+
+    pthread_mutex_unlock(&mutex);
+
+    return &result;
+}
+
 void ffPrintOS(FFinstance* instance)
 {
     if(ffPrintFromCache(instance, FF_OS_MODULE_NAME, &instance->config.osKey, &instance->config.osFormat, FF_OS_NUM_FORMAT_ARGS))
         return;
 
-    const FFOSResult* result = ffCalculateOS(instance);
+    const FFOSResult* result = ffDetectOS(instance);
 
     if(result->error.length > 0)
     {
diff --git a/src/modules/terminal.c b/src/modules/terminal.c
index bbe672779..764eb8cac 100644
--- a/src/modules/terminal.c
+++ b/src/modules/terminal.c
@@ -1,11 +1,89 @@
 #include "fastfetch.h"
 
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+
 #define FF_TERMINAL_MODULE_NAME "Terminal"
 #define FF_TERMINAL_NUM_FORMAT_ARGS 3
 
+static void getTerminalName(FFinstance* instance, const char* pid, FFTerminalResult* result)
+{
+    char statFile[234];
+    sprintf(statFile, "/proc/%s/stat", pid);
+
+    FILE* stat = fopen(statFile, "r");
+    if(stat == NULL)
+    {
+        ffStrbufSetF(&result->error, "fopen(\"%s\", \"r\") == NULL", statFile);
+        return;
+    }
+
+    char name[256];
+    char ppid[256];
+    if(fscanf(stat, "%*s (%[^)])%*s%s", name, ppid) != 2)
+    {
+        ffStrbufSetS(&result->error, "fscanf(stat, \"%*s (%[^)])%*s%s\", name, ppid) != 2");
+        return;
+    }
+
+    fclose(stat);
+
+    if (
+        strcasecmp(name, "bash")   == 0 ||
+        strcasecmp(name, "sh")     == 0 ||
+        strcasecmp(name, "zsh")    == 0 ||
+        strcasecmp(name, "ksh")    == 0 ||
+        strcasecmp(name, "fish")   == 0 ||
+        strcasecmp(name, "sudo")   == 0 ||
+        strcasecmp(name, "su")     == 0 ||
+        strcasecmp(name, "doas")   == 0 ||
+        strcasecmp(name, "strace") == 0 )
+    {
+        getTerminalName(instance, ppid, result);
+        return;
+    }
+
+    char cmdlineFile[234];
+    sprintf(cmdlineFile, "/proc/%s/cmdline", pid);
+
+    ffGetFileContent(cmdlineFile, &result->exeName);
+    ffStrbufSubstrBeforeFirstC(&result->exeName, '\0');
+    ffStrbufSubstrAfterLastC(&result->exeName, '/');
+
+    ffStrbufSetS(&result->processName, name);
+}
+
+const FFTerminalResult* ffDetectTerminal(FFinstance* instance)
+{
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    static FFTerminalResult result;
+    static bool init = false;
+    pthread_mutex_lock(&mutex);
+    if(init)
+    {
+        pthread_mutex_unlock(&mutex);
+        return &result;
+    }
+    init = true;
+
+    ffStrbufInit(&result.exeName);
+    ffStrbufInit(&result.processName);
+    ffStrbufInit(&result.error);
+
+    char ppid[256];
+    sprintf(ppid, "%i", getppid());
+
+    getTerminalName(instance, ppid, &result);
+
+    pthread_mutex_unlock(&mutex);
+
+    return &result;
+}
+
 void ffPrintTerminal(FFinstance* instance)
 {
-    const FFTerminalResult* result = ffCalculateTerminal(instance);
+    const FFTerminalResult* result = ffDetectTerminal(instance);
 
     if(result->error.length > 0)
     {
diff --git a/src/modules/terminalfont.c b/src/modules/terminalfont.c
index d670ba5b7..f335c03ba 100644
--- a/src/modules/terminalfont.c
+++ b/src/modules/terminalfont.c
@@ -81,7 +81,7 @@ static void printTTY(FFinstance* instance)
 
 void ffPrintTerminalFont(FFinstance* instance)
 {
-    const FFTerminalResult* result = ffCalculateTerminal(instance);
+    const FFTerminalResult* result = ffDetectTerminal(instance);
 
     if(result->exeName.length == 0)
     {
diff --git a/src/modules/theme.c b/src/modules/theme.c
index 12e9195af..01539600f 100644
--- a/src/modules/theme.c
+++ b/src/modules/theme.c
@@ -5,10 +5,10 @@
 
 void ffPrintTheme(FFinstance* instance)
 {
-    const FFPlasmaResult* plasma = ffCalculatePlasma(instance);
-    const FFstrbuf* gtk2 = &ffCalculateGTK2(instance)->theme;
-    const FFstrbuf* gtk3 = &ffCalculateGTK3(instance)->theme;
-    const FFstrbuf* gtk4 = &ffCalculateGTK4(instance)->theme;
+    const FFPlasmaResult* plasma = ffDetectPlasma(instance);
+    const FFstrbuf* gtk2 = &ffDetectGTK2(instance)->theme;
+    const FFstrbuf* gtk3 = &ffDetectGTK3(instance)->theme;
+    const FFstrbuf* gtk4 = &ffDetectGTK4(instance)->theme;
 
     if(plasma->widgetStyle.length == 0 && plasma->colorScheme.length == 0 && gtk2->length == 0 && gtk3->length == 0 && gtk4->length == 0)
     {
diff --git a/src/modules/wm.c b/src/modules/wm.c
index eaab0e7e5..8d14d9d6d 100644
--- a/src/modules/wm.c
+++ b/src/modules/wm.c
@@ -1,11 +1,138 @@
 #include "fastfetch.h"
 
+#include <string.h>
+#include <dirent.h>
+#include <pthread.h>
+
 #define FF_WM_MODULE_NAME "WM"
 #define FF_WM_NUM_FORMAT_ARGS 3
 
+const char* ffGetSessionDesktop()
+{
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    static char* sessionDesktop = NULL;
+
+    pthread_mutex_lock(&mutex);
+
+    if(sessionDesktop == NULL)
+        sessionDesktop = getenv("XDG_CURRENT_DESKTOP");
+
+    if(sessionDesktop == NULL)
+        sessionDesktop = getenv("XDG_SESSION_DESKTOP");
+
+    pthread_mutex_unlock(&mutex);
+
+    return sessionDesktop;
+}
+
+static void getFromProcDir(FFWMResult* result)
+{
+    DIR* proc = opendir("/proc/");
+    if(proc == NULL)
+        return;
+
+    struct dirent* dirent;
+
+    while((dirent = readdir(proc)) != NULL)
+    {
+        if(dirent->d_type != DT_DIR)
+            continue;
+
+        char path[20];
+        sprintf(path, "/proc/%.8s/comm", dirent->d_name);
+
+        ffGetFileContent(path, &result->processName);
+
+        if(ffStrbufIgnCaseCompS(&result->processName, "kwin_wayland") == 0)
+        {
+            ffStrbufSetS(&result->prettyName, "KWin");
+            ffStrbufSetS(&result->protocolName, "Wayland");
+        }
+        else if(ffStrbufIgnCaseCompS(&result->processName, "kwin_x11") == 0)
+        {
+            ffStrbufSetS(&result->prettyName, "KWin");
+            ffStrbufSetS(&result->protocolName, "X11");
+        }
+        else if(ffStrbufIgnCaseCompS(&result->processName, "openbox") == 0)
+            ffStrbufSetS(&result->prettyName, "Openbox");
+		else if(ffStrbufIgnCaseCompS(&result->processName, "cinnamon") == 0)
+            ffStrbufSetS(&result->prettyName, "Muffin");
+		else if(ffStrbufIgnCaseCompS(&result->processName, "xfwm4") == 0)
+            ffStrbufSetS(&result->prettyName, "XFWM");
+		else if(ffStrbufIgnCaseCompS(&result->processName, "wayfire") == 0)
+            ffStrbufSetS(&result->prettyName, "Wayfire");
+
+        if(result->prettyName.length > 0)
+            break;
+    }
+
+    closedir(proc);
+}
+
+static void getSessionType(FFstrbuf* sessionType)
+{
+    const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
+    if (xdgSessionType == NULL)
+        return;
+
+    else if(strcasecmp(xdgSessionType, "wayland") == 0)
+        ffStrbufSetS(sessionType, "Wayland");
+    else if(strcasecmp(xdgSessionType, "x11") == 0)
+        ffStrbufSetS(sessionType, "X11");
+    else if(strcasecmp(xdgSessionType, "tty") == 0)
+        ffStrbufSetS(sessionType, "TTY");
+    else if(strcasecmp(xdgSessionType, "mir") == 0)
+        ffStrbufSetS(sessionType, "Mir");
+    else
+        ffStrbufSetS(sessionType, xdgSessionType);
+}
+
+const FFWMResult* ffDetectWM(FFinstance* instance)
+{
+    UNUSED(instance);
+
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    static FFWMResult result;
+    static bool init = false;
+    pthread_mutex_lock(&mutex);
+    if(init)
+    {
+        pthread_mutex_unlock(&mutex);
+        return &result;
+    }
+    init = true;
+
+    ffStrbufInit(&result.processName);
+    ffStrbufInit(&result.prettyName);
+    ffStrbufInit(&result.protocolName);
+    ffStrbufInit(&result.error);
+
+    getFromProcDir(&result);
+
+    if(result.prettyName.length == 0)
+    {
+        const char* sessionDesktop = ffGetSessionDesktop();
+        ffStrbufSetS(&result.processName, sessionDesktop);
+        ffStrbufSetS(&result.prettyName, sessionDesktop);
+    }
+
+    if(result.protocolName.length == 0)
+        getSessionType(&result.protocolName);
+
+    if(result.prettyName.length == 0 && result.protocolName.length == 0)
+    {
+        ffStrbufClear(&result.processName);
+        ffStrbufSetS(&result.error, "No WM or WM protocol type found");
+    }
+
+    pthread_mutex_unlock(&mutex);
+
+    return &result;
+}
+
 void ffPrintWM(FFinstance* instance)
 {
-    const FFWMResult* result = ffCalculateWM(instance);
+    const FFWMResult* result = ffDetectWM(instance);
 
     if(result->error.length > 0)
     {
diff --git a/src/modules/wmtheme.c b/src/modules/wmtheme.c
index 68519a1c1..354ac1920 100644
--- a/src/modules/wmtheme.c
+++ b/src/modules/wmtheme.c
@@ -102,7 +102,7 @@ static void printOpenbox(FFinstance* instance)
 
 void ffPrintWMTheme(FFinstance* instance)
 {
-    const FFWMResult* result = ffCalculateWM(instance);
+    const FFWMResult* result = ffDetectWM(instance);
 
     if(result->prettyName.length == 0)
     {