diff --git a/make/source.mk b/make/source.mk
index 3b4ff82b4d..a70ff9564d 100644
--- a/make/source.mk
+++ b/make/source.mk
@@ -320,7 +320,7 @@ SIZE_OPTIMISED_SRC := $(SIZE_OPTIMISED_SRC) \
             config/config_eeprom.c \
             config/feature.c \
             config/config_streamer.c \
-            config/tuning_sliders.c \
+            config/simplified_tuning.c \
             i2c_bst.c \
             io/dashboard.c \
             io/serial.c \
diff --git a/src/main/cli/cli.c b/src/main/cli/cli.c
index efc3e35f4e..19c6246e2d 100644
--- a/src/main/cli/cli.c
+++ b/src/main/cli/cli.c
@@ -57,7 +57,7 @@ bool cliMode = false;
 #include "config/config.h"
 #include "config/config_eeprom.h"
 #include "config/feature.h"
-#include "config/tuning_sliders.h"
+#include "config/simplified_tuning.h"
 
 #include "drivers/accgyro/accgyro.h"
 #include "drivers/adc.h"
@@ -3094,14 +3094,14 @@ static void cliVtxInfo(const char *cmdName, char *cmdline)
 }
 #endif // USE_VTX_TABLE
 
-#ifdef USE_TUNING_SLIDERS
-static void cliTuningSliders(const char *cmdName, char *cmdline)
+#ifdef USE_SIMPLIFIED_TUNING
+static void cliApplySimplifiedTuning(const char *cmdName, char *cmdline)
 {
     UNUSED(cmdName);
     UNUSED(cmdline);
 
-    applyTuningSliders(currentPidProfile);
-    cliPrintLine("Applied tuning slider calculation");
+    applySimplifiedTuning(currentPidProfile);
+    cliPrintLine("Applied tuning based on simplified tuning settings.");
 }
 #endif
 
@@ -6403,8 +6403,8 @@ static void cliHelp(const char *cmdName, char *cmdline);
 // should be sorted a..z for bsearch()
 const clicmd_t cmdTable[] = {
     CLI_COMMAND_DEF("adjrange", "configure adjustment ranges", "<index> <unused> <range channel> <start> <end> <function> <select channel> [<center> <scale>]", cliAdjustmentRange),
-#ifdef USE_TUNING_SLIDERS
-    CLI_COMMAND_DEF("apply_tuning_sliders", "applies tuning sliders calculation based on slider positions", NULL, cliTuningSliders),
+#ifdef USE_SIMPLIFIED_TUNING
+    CLI_COMMAND_DEF("apply_simplified_tuning", "applies tuning based on simplified tuning settings", NULL, cliApplySimplifiedTuning),
 #endif
     CLI_COMMAND_DEF("aux", "configure modes", "<index> <mode> <aux> <start> <end> <logic>", cliAux),
 #ifdef USE_CLI_BATCH
diff --git a/src/main/cli/settings.c b/src/main/cli/settings.c
index 6aa6ccd03a..9925e5334d 100644
--- a/src/main/cli/settings.c
+++ b/src/main/cli/settings.c
@@ -33,7 +33,7 @@
 #include "common/utils.h"
 #include "common/time.h"
 
-#include "config/tuning_sliders.h"
+#include "config/simplified_tuning.h"
 
 #include "drivers/adc.h"
 #include "drivers/bus_i2c.h"
@@ -502,7 +502,7 @@ static const char * const lookupTableOsdLogoOnArming[] = {
     "OFF", "ON", "FIRST_ARMING",
 };
 #endif
-const char * const lookupTableSliderPidsMode[] = {
+const char * const lookupTableSimplifiedTuningPidsMode[] = {
     "OFF", "RP", "RPY",
 };
 
@@ -632,7 +632,7 @@ const lookupTableEntry_t lookupTables[] = {
     LOOKUP_TABLE_ENTRY(lookupTableOsdLogoOnArming),
 #endif
     LOOKUP_TABLE_ENTRY(lookupTableMixerType),
-    LOOKUP_TABLE_ENTRY(lookupTableSliderPidsMode),
+    LOOKUP_TABLE_ENTRY(lookupTableSimplifiedTuningPidsMode),
 };
 
 #undef LOOKUP_TABLE_ENTRY
@@ -1175,21 +1175,21 @@ const clivalue_t valueTable[] = {
 #endif
     { "level_race_mode",            VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_PID_PROFILE, offsetof(pidProfile_t, level_race_mode) },
 
-#ifdef USE_TUNING_SLIDERS
-    { "slider_pids_mode",               VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_SLIDER_PIDS_MODE }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_pids_mode) },
-    { "slider_master_multiplier",       VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_master_multiplier) },
-    { "slider_roll_pitch_ratio",        VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_roll_pitch_ratio) },
-    { "slider_i_gain",                  VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_i_gain) },
-    { "slider_pd_ratio",                VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_pd_ratio) },
-    { "slider_pd_gain",                 VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_pd_gain) },
-    { "slider_dmin_ratio",              VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_dmin_ratio) },
-    { "slider_ff_gain",                 VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_ff_gain) },
+#ifdef USE_SIMPLIFIED_TUNING
+    { "simplified_pids_mode",               VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_SIMPLIFIED_TUNING_PIDS_MODE }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pids_mode) },
+    { "simplified_master_multiplier",       VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_master_multiplier) },
+    { "simplified_roll_pitch_ratio",        VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_roll_pitch_ratio) },
+    { "simplified_i_gain",                  VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_i_gain) },
+    { "simplified_pd_ratio",                VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pd_ratio) },
+    { "simplified_pd_gain",                 VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_pd_gain) },
+    { "simplified_dmin_ratio",              VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_dmin_ratio) },
+    { "simplified_ff_gain",                 VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_ff_gain) },
 
-    { "slider_dterm_filter",            VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_dterm_filter) },
-    { "slider_dterm_filter_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, slider_dterm_filter_multiplier) },
+    { "simplified_dterm_filter",            VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_dterm_filter) },
+    { "simplified_dterm_filter_multiplier", VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_PID_PROFILE, offsetof(pidProfile_t, simplified_dterm_filter_multiplier) },
 
-    { "slider_gyro_filter",             VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, slider_gyro_filter) },
-    { "slider_gyro_filter_multiplier",  VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SLIDER_MIN, SLIDER_MAX }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, slider_gyro_filter_multiplier) },
+    { "simplified_gyro_filter",             VAR_UINT8 | PROFILE_VALUE | MODE_LOOKUP, .config.lookup = { TABLE_OFF_ON }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, simplified_gyro_filter) },
+    { "simplified_gyro_filter_multiplier",  VAR_UINT8 | PROFILE_VALUE, .config.minmaxUnsigned = { SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX }, PG_GYRO_CONFIG, offsetof(gyroConfig_t, simplified_gyro_filter_multiplier) },
 #endif
 
 // PG_TELEMETRY_CONFIG
diff --git a/src/main/cli/settings.h b/src/main/cli/settings.h
index 6ebcf8f143..d4972c1e73 100644
--- a/src/main/cli/settings.h
+++ b/src/main/cli/settings.h
@@ -142,7 +142,7 @@ typedef enum {
     TABLE_OSD_LOGO_ON_ARMING,
 #endif
     TABLE_MIXER_TYPE,
-    TABLE_SLIDER_PIDS_MODE,
+    TABLE_SIMPLIFIED_TUNING_PIDS_MODE,
 
     LOOKUP_TABLE_COUNT
 } lookupTableIndex_e;
@@ -264,4 +264,4 @@ extern const char * const lookupTableInterpolatedSetpoint[];
 
 extern const char * const lookupTableOffOn[];
 
-extern const char * const lookupTableSliderPidsMode[];
+extern const char * const lookupTableSimplifiedTuningPidsMode[];
diff --git a/src/main/cms/cms_menu_imu.c b/src/main/cms/cms_menu_imu.c
index 81b0ef118e..d798ebdb8b 100644
--- a/src/main/cms/cms_menu_imu.c
+++ b/src/main/cms/cms_menu_imu.c
@@ -40,7 +40,7 @@
 #include "common/utils.h"
 
 #include "config/feature.h"
-#include "config/tuning_sliders.h"
+#include "config/simplified_tuning.h"
 
 #include "drivers/pwm_output.h"
 
@@ -229,112 +229,113 @@ static CMS_Menu cmsx_menuPid = {
     .entries = cmsx_menuPidEntries
 };
 
-#ifdef USE_TUNING_SLIDERS
-static uint8_t cmsx_slider_pids_mode;
-static uint8_t cmsx_slider_master_multiplier;
-static uint8_t cmsx_slider_roll_pitch_ratio;
-static uint8_t cmsx_slider_i_gain;
-static uint8_t cmsx_slider_pd_ratio;
-static uint8_t cmsx_slider_pd_gain;
-static uint8_t cmsx_slider_dmin_ratio;
-static uint8_t cmsx_slider_ff_gain;
+#ifdef USE_SIMPLIFIED_TUNING
+static uint8_t cmsx_simplified_pids_mode;
+static uint8_t cmsx_simplified_master_multiplier;
+static uint8_t cmsx_simplified_roll_pitch_ratio;
+static uint8_t cmsx_simplified_i_gain;
+static uint8_t cmsx_simplified_pd_ratio;
+static uint8_t cmsx_simplified_pd_gain;
+static uint8_t cmsx_simplified_dmin_ratio;
+static uint8_t cmsx_simplified_ff_gain;
 
-static uint8_t cmsx_slider_dterm_filter;
-static uint8_t cmsx_slider_dterm_filter_multiplier;
-static uint8_t cmsx_slider_gyro_filter;
-static uint8_t cmsx_slider_gyro_filter_multiplier;
+static uint8_t cmsx_simplified_dterm_filter;
+static uint8_t cmsx_simplified_dterm_filter_multiplier;
+static uint8_t cmsx_simplified_gyro_filter;
+static uint8_t cmsx_simplified_gyro_filter_multiplier;
 
-static const void *cmsx_slidersOnEnter(displayPort_t *pDisp)
+static const void *cmsx_simplifiedTuningOnEnter(displayPort_t *pDisp)
 {
     UNUSED(pDisp);
 
     const pidProfile_t *pidProfile = pidProfiles(pidProfileIndex);
 
-    cmsx_slider_pids_mode = pidProfile->slider_pids_mode;
-    cmsx_slider_master_multiplier = pidProfile->slider_master_multiplier;
-    cmsx_slider_roll_pitch_ratio = pidProfile->slider_roll_pitch_ratio;
-    cmsx_slider_i_gain = pidProfile->slider_i_gain;
-    cmsx_slider_pd_ratio = pidProfile->slider_pd_ratio;
-    cmsx_slider_pd_gain = pidProfile->slider_pd_gain;
-    cmsx_slider_dmin_ratio = pidProfile->slider_dmin_ratio;
-    cmsx_slider_ff_gain = pidProfile->slider_ff_gain;
+    cmsx_simplified_pids_mode = pidProfile->simplified_pids_mode;
+    cmsx_simplified_master_multiplier = pidProfile->simplified_master_multiplier;
+    cmsx_simplified_roll_pitch_ratio = pidProfile->simplified_roll_pitch_ratio;
+    cmsx_simplified_i_gain = pidProfile->simplified_i_gain;
+    cmsx_simplified_pd_ratio = pidProfile->simplified_pd_ratio;
+    cmsx_simplified_pd_gain = pidProfile->simplified_pd_gain;
+    cmsx_simplified_dmin_ratio = pidProfile->simplified_dmin_ratio;
+    cmsx_simplified_ff_gain = pidProfile->simplified_ff_gain;
 
-    cmsx_slider_dterm_filter = pidProfile->slider_dterm_filter;
-    cmsx_slider_dterm_filter_multiplier = pidProfile->slider_dterm_filter_multiplier;
-    cmsx_slider_gyro_filter = gyroConfig()->slider_gyro_filter;
-    cmsx_slider_gyro_filter_multiplier = gyroConfig()->slider_gyro_filter_multiplier;
+    cmsx_simplified_dterm_filter = pidProfile->simplified_dterm_filter;
+    cmsx_simplified_dterm_filter_multiplier = pidProfile->simplified_dterm_filter_multiplier;
+    cmsx_simplified_gyro_filter = gyroConfig()->simplified_gyro_filter;
+    cmsx_simplified_gyro_filter_multiplier = gyroConfig()->simplified_gyro_filter_multiplier;
 
     return 0;
 }
 
-static const void *cmsx_slidersOnExit(displayPort_t *pDisp, const OSD_Entry *self)
+static const void *cmsx_simplifiedTuningOnExit(displayPort_t *pDisp, const OSD_Entry *self)
 {
     UNUSED(pDisp);
     UNUSED(self);
 
     pidProfile_t *pidProfile = currentPidProfile;
 
-    pidProfile->slider_pids_mode = cmsx_slider_pids_mode;
-    pidProfile->slider_master_multiplier = cmsx_slider_master_multiplier;
-    pidProfile->slider_roll_pitch_ratio = cmsx_slider_roll_pitch_ratio;
-    pidProfile->slider_i_gain = cmsx_slider_i_gain;
-    pidProfile->slider_pd_ratio = cmsx_slider_pd_ratio;
-    pidProfile->slider_pd_gain = cmsx_slider_pd_gain;
-    pidProfile->slider_dmin_ratio = cmsx_slider_dmin_ratio;
-    pidProfile->slider_ff_gain = cmsx_slider_ff_gain;
+    pidProfile->simplified_pids_mode = cmsx_simplified_pids_mode;
+    pidProfile->simplified_master_multiplier = cmsx_simplified_master_multiplier;
+    pidProfile->simplified_roll_pitch_ratio = cmsx_simplified_roll_pitch_ratio;
+    pidProfile->simplified_i_gain = cmsx_simplified_i_gain;
+    pidProfile->simplified_pd_ratio = cmsx_simplified_pd_ratio;
+    pidProfile->simplified_pd_gain = cmsx_simplified_pd_gain;
+    pidProfile->simplified_dmin_ratio = cmsx_simplified_dmin_ratio;
+    pidProfile->simplified_ff_gain = cmsx_simplified_ff_gain;
 
-    pidProfile->slider_dterm_filter = cmsx_slider_dterm_filter;
-    pidProfile->slider_dterm_filter_multiplier = cmsx_slider_dterm_filter_multiplier;
-    gyroConfigMutable()->slider_gyro_filter = cmsx_slider_gyro_filter;
-    gyroConfigMutable()->slider_gyro_filter_multiplier = cmsx_slider_gyro_filter_multiplier;
+    pidProfile->simplified_dterm_filter = cmsx_simplified_dterm_filter;
+    pidProfile->simplified_dterm_filter_multiplier = cmsx_simplified_dterm_filter_multiplier;
+    gyroConfigMutable()->simplified_gyro_filter = cmsx_simplified_gyro_filter;
+    gyroConfigMutable()->simplified_gyro_filter_multiplier = cmsx_simplified_gyro_filter_multiplier;
 
     return 0;
 }
 
-static const void *cmsx_applyTuningSliders(displayPort_t *pDisp, const void *self)
+static const void *cmsx_applySimplifiedTuning(displayPort_t *pDisp, const void *self)
 {
     UNUSED(pDisp);
     UNUSED(self);
 
-    applyTuningSliders(currentPidProfile);
+    applySimplifiedTuning(currentPidProfile);
 
-    return 0;
+    return MENU_CHAIN_BACK;
 }
 
-static const OSD_Entry cmsx_menuSlidersEntries[] =
+static const OSD_Entry cmsx_menuSimplifiedTuningEntries[] =
 {
-    { "-- PID SLIDERS --", OME_Label, NULL, NULL, 0},
-    { "PID SLIDERS",    OME_TAB,   NULL, &(OSD_TAB_t)   { &cmsx_slider_pids_mode, PID_TUNING_SLIDERS_MODE_COUNT - 1, lookupTableSliderPidsMode }, 0 },
-    { "MASTER MULT",    OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_master_multiplier, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
-    { "R/P RATIO",      OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_roll_pitch_ratio,  SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
-    { "I GAIN",         OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_i_gain,            SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
-    { "PD RATIO",       OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_pd_ratio,          SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
-    { "PD GAIN",        OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_pd_gain,           SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
-    { "DMIN RATIO",     OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_dmin_ratio,        SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
-    { "FF GAIN",        OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_ff_gain,           SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
+    { "-- SIMPLIFIED PID --", OME_Label, NULL, NULL, 0},
+    { "PID TUNING",    OME_TAB,   NULL, &(OSD_TAB_t)   { &cmsx_simplified_pids_mode, PID_SIMPLIFIED_TUNING_MODE_COUNT - 1, lookupTableSimplifiedTuningPidsMode }, 0 },
+    { "MASTER MULT",    OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_master_multiplier, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
+    { "R/P RATIO",      OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_roll_pitch_ratio,  SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
+    { "I GAIN",         OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_i_gain,            SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
+    { "PD RATIO",       OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_pd_ratio,          SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
+    { "PD GAIN",        OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_pd_gain,           SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
+    { "DMIN RATIO",     OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_dmin_ratio,        SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
+    { "FF GAIN",        OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_ff_gain,           SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
 
-    { "-- FILTER SLIDERS --", OME_Label, NULL, NULL, 0},
-    { "GYRO SLIDER",    OME_TAB,   NULL, &(OSD_TAB_t)   { &cmsx_slider_gyro_filter,  1, lookupTableOffOn }, 0 },
-    { "GYRO MULT",      OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_gyro_filter_multiplier,  SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
-    { "DTERM SLIDER",   OME_TAB,   NULL, &(OSD_TAB_t)   { &cmsx_slider_dterm_filter, 1, lookupTableOffOn }, 0 },
-    { "DTERM MULT",     OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_slider_dterm_filter_multiplier, SLIDER_MIN, SLIDER_MAX, 1, 10 }, 0 },
+    { "-- SIMPLIFIED FILTER --", OME_Label, NULL, NULL, 0},
+    { "GYRO TUNING",    OME_TAB,   NULL, &(OSD_TAB_t)   { &cmsx_simplified_gyro_filter,  1, lookupTableOffOn }, 0 },
+    { "GYRO MULT",      OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_gyro_filter_multiplier,  SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
+    { "DTERM TUNING",   OME_TAB,   NULL, &(OSD_TAB_t)   { &cmsx_simplified_dterm_filter, 1, lookupTableOffOn }, 0 },
+    { "DTERM MULT",     OME_FLOAT, NULL, &(OSD_FLOAT_t) { &cmsx_simplified_dterm_filter_multiplier, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, 1, 10 }, 0 },
 
-    { "APPLY SLIDERS",  OME_Funcall, cmsx_applyTuningSliders, NULL, 0 },
+    { "-- GENERAL --", OME_Label, NULL, NULL, 0},
+    { "APPLY TUNING",  OME_Funcall, cmsx_applySimplifiedTuning, NULL, 0 },
 
     { "BACK", OME_Back, NULL, NULL, 0 },
     { NULL, OME_END, NULL, NULL, 0 }
 };
 
-static CMS_Menu cmsx_menuSliders = {
+static CMS_Menu cmsx_menuSimplifiedTuning = {
 #ifdef CMS_MENU_DEBUG
-    .GUARD_text = "XSLIDER",
+    .GUARD_text = "XSIMPLIFIED",
     .GUARD_type = OME_MENU,
 #endif
-    .onEnter = cmsx_slidersOnEnter,
-    .onExit = cmsx_slidersOnExit,
-    .entries = cmsx_menuSlidersEntries,
+    .onEnter = cmsx_simplifiedTuningOnEnter,
+    .onExit = cmsx_simplifiedTuningOnExit,
+    .entries = cmsx_menuSimplifiedTuningEntries,
 };
-#endif // USE_TUNING_SLIDERS
+#endif // USE_SIMPLIFIED_TUNING
 
 //
 // Rate & Expo
@@ -972,8 +973,8 @@ static const OSD_Entry cmsx_menuImuEntries[] =
 
     {"PID PROF",  OME_UINT8,   cmsx_profileIndexOnChange,     &(OSD_UINT8_t){ &tmpPidProfileIndex, 1, PID_PROFILE_COUNT, 1},    0},
     {"PID",       OME_Submenu, cmsMenuChange,                 &cmsx_menuPid,                                                 0},
-#ifdef USE_TUNING_SLIDERS
-    {"SLIDERS",   OME_Submenu, cmsMenuChange,                 &cmsx_menuSliders,                                             0},
+#ifdef USE_SIMPLIFIED_TUNING
+    {"SIMPLIFIED TUNING",   OME_Submenu, cmsMenuChange,                 &cmsx_menuSimplifiedTuning,                                             0},
 #endif
     {"MISC PP",   OME_Submenu, cmsMenuChange,                 &cmsx_menuProfileOther,                                        0},
     {"FILT PP",   OME_Submenu, cmsMenuChange,                 &cmsx_menuFilterPerProfile,                                    0},
diff --git a/src/main/config/tuning_sliders.c b/src/main/config/simplified_tuning.c
similarity index 56%
rename from src/main/config/tuning_sliders.c
rename to src/main/config/simplified_tuning.c
index 5059e07a42..b2c389f9de 100644
--- a/src/main/config/tuning_sliders.c
+++ b/src/main/config/simplified_tuning.c
@@ -21,12 +21,12 @@
 #include <math.h>
 #include "platform.h"
 
-#ifdef USE_TUNING_SLIDERS
+#ifdef USE_SIMPLIFIED_TUNING
 
 #include "common/axis.h"
 #include "common/maths.h"
 
-#include "config/tuning_sliders.h"
+#include "config/simplified_tuning.h"
 
 #include "sensors/gyro.h"
 
@@ -40,86 +40,86 @@ static void calculateNewPidValues(pidProfile_t *pidProfile)
     const int dMinDefaults[FLIGHT_DYNAMICS_INDEX_COUNT] = D_MIN_DEFAULT;
 
     // MASTER MULTIPLIER
-    for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
-        pidProfile->pid[axis].P = constrain(pidDefaults[axis].P * pidProfile->slider_master_multiplier / 100, 0, PID_GAIN_MAX);
-        pidProfile->pid[axis].I = constrain(pidDefaults[axis].I * pidProfile->slider_master_multiplier / 100, 0, PID_GAIN_MAX);
-        pidProfile->pid[axis].D = constrain(pidDefaults[axis].D * pidProfile->slider_master_multiplier / 100, 0, PID_GAIN_MAX);
-        pidProfile->d_min[axis] = constrain(dMinDefaults[axis] * pidProfile->slider_master_multiplier / 100, 0, D_MIN_GAIN_MAX);
-        pidProfile->pid[axis].F = constrain(pidDefaults[axis].F * pidProfile->slider_master_multiplier / 100, 0, F_GAIN_MAX);
+    for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
+        pidProfile->pid[axis].P = constrain(pidDefaults[axis].P * pidProfile->simplified_master_multiplier / 100, 0, PID_GAIN_MAX);
+        pidProfile->pid[axis].I = constrain(pidDefaults[axis].I * pidProfile->simplified_master_multiplier / 100, 0, PID_GAIN_MAX);
+        pidProfile->pid[axis].D = constrain(pidDefaults[axis].D * pidProfile->simplified_master_multiplier / 100, 0, PID_GAIN_MAX);
+        pidProfile->d_min[axis] = constrain(dMinDefaults[axis] * pidProfile->simplified_master_multiplier / 100, 0, D_MIN_GAIN_MAX);
+        pidProfile->pid[axis].F = constrain(pidDefaults[axis].F * pidProfile->simplified_master_multiplier / 100, 0, F_GAIN_MAX);
     }
 
     // ROLL PITCH RATIO
-    pidProfile->pid[FD_ROLL].P = constrain(pidProfile->pid[FD_ROLL].P * pidProfile->slider_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
-    pidProfile->pid[FD_ROLL].I = constrain(pidProfile->pid[FD_ROLL].I * pidProfile->slider_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
-    pidProfile->pid[FD_ROLL].D = constrain(pidProfile->pid[FD_ROLL].D * pidProfile->slider_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
-    pidProfile->d_min[FD_ROLL] = constrain(pidProfile->d_min[FD_ROLL] * pidProfile->slider_roll_pitch_ratio / 100, 0, D_MIN_GAIN_MAX);
-    pidProfile->pid[FD_ROLL].F = constrain(pidProfile->pid[FD_ROLL].F * pidProfile->slider_roll_pitch_ratio / 100, 0, F_GAIN_MAX);
+    pidProfile->pid[FD_ROLL].P = constrain(pidProfile->pid[FD_ROLL].P * pidProfile->simplified_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
+    pidProfile->pid[FD_ROLL].I = constrain(pidProfile->pid[FD_ROLL].I * pidProfile->simplified_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
+    pidProfile->pid[FD_ROLL].D = constrain(pidProfile->pid[FD_ROLL].D * pidProfile->simplified_roll_pitch_ratio / 100, 0, PID_GAIN_MAX);
+    pidProfile->d_min[FD_ROLL] = constrain(pidProfile->d_min[FD_ROLL] * pidProfile->simplified_roll_pitch_ratio / 100, 0, D_MIN_GAIN_MAX);
+    pidProfile->pid[FD_ROLL].F = constrain(pidProfile->pid[FD_ROLL].F * pidProfile->simplified_roll_pitch_ratio / 100, 0, F_GAIN_MAX);
 
     // I GAIN
-    for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
-        pidProfile->pid[axis].I = constrain(pidProfile->pid[axis].I * pidProfile->slider_i_gain / 100, 0, PID_GAIN_MAX);
+    for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
+        pidProfile->pid[axis].I = constrain(pidProfile->pid[axis].I * pidProfile->simplified_i_gain / 100, 0, PID_GAIN_MAX);
     }
 
     // PD RATIO - applied only on roll and pitch because on yaw default D gain is 0
     const float defaultPDRatio = pidDefaults[FD_ROLL].P / (float)pidDefaults[FD_ROLL].D;
     for (int axis = FD_ROLL; axis <= FD_PITCH; ++axis) {
-        pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].D * defaultPDRatio * pidProfile->slider_pd_ratio / 100, 0, PID_GAIN_MAX);
+        pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].D * defaultPDRatio * pidProfile->simplified_pd_ratio / 100, 0, PID_GAIN_MAX);
     }
 
     // PD GAIN
-    for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
-        pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].P * pidProfile->slider_pd_gain / 100, 0, PID_GAIN_MAX);
-        pidProfile->pid[axis].D = constrain(pidProfile->pid[axis].D * pidProfile->slider_pd_gain / 100, 0, PID_GAIN_MAX);
-        pidProfile->d_min[axis] = constrain(pidProfile->d_min[axis] * pidProfile->slider_pd_gain / 100, 0, D_MIN_GAIN_MAX);
+    for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
+        pidProfile->pid[axis].P = constrain(pidProfile->pid[axis].P * pidProfile->simplified_pd_gain / 100, 0, PID_GAIN_MAX);
+        pidProfile->pid[axis].D = constrain(pidProfile->pid[axis].D * pidProfile->simplified_pd_gain / 100, 0, PID_GAIN_MAX);
+        pidProfile->d_min[axis] = constrain(pidProfile->d_min[axis] * pidProfile->simplified_pd_gain / 100, 0, D_MIN_GAIN_MAX);
     }
 
     // D MIN RATIO
     const float defaultDMinRatio = dMinDefaults[FD_ROLL] / (float)pidDefaults[FD_ROLL].D;
-    const float scaledDminRatioSliderValue = scaleRangef(pidProfile->slider_dmin_ratio, SLIDER_MIN, SLIDER_MAX, SLIDER_MIN + SLIDER_MAX - 100 / defaultDMinRatio, 100 / defaultDMinRatio);
-    for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
-        if (pidProfile->slider_dmin_ratio == 200) {
-            pidProfile->d_min[axis] = 0; // disable d_min if slider maxed out
+    const float scaledDminRatioSimplifiedValue = scaleRangef(pidProfile->simplified_dmin_ratio, SIMPLIFIED_TUNING_MIN, SIMPLIFIED_TUNING_MAX, SIMPLIFIED_TUNING_MIN + SIMPLIFIED_TUNING_MAX - 100 / defaultDMinRatio, 100 / defaultDMinRatio);
+    for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
+        if (pidProfile->simplified_dmin_ratio == 200) {
+            pidProfile->d_min[axis] = 0; // disable d_min if range maxed out
         } else {
-            pidProfile->d_min[axis] = constrain(constrain(pidProfile->pid[axis].D * defaultDMinRatio * scaledDminRatioSliderValue / 100, 0, pidProfile->pid[axis].D - 1), 0, D_MIN_GAIN_MAX);
+            pidProfile->d_min[axis] = constrain(constrain(pidProfile->pid[axis].D * defaultDMinRatio * scaledDminRatioSimplifiedValue / 100, 0, pidProfile->pid[axis].D - 1), 0, D_MIN_GAIN_MAX);
         }
     }
 
     // FF GAIN
-    for (int axis = FD_ROLL; axis <= pidProfile->slider_pids_mode; ++axis) {
-        pidProfile->pid[axis].F = constrain(pidProfile->pid[axis].F * pidProfile->slider_ff_gain / 100, 0, F_GAIN_MAX);
+    for (int axis = FD_ROLL; axis <= pidProfile->simplified_pids_mode; ++axis) {
+        pidProfile->pid[axis].F = constrain(pidProfile->pid[axis].F * pidProfile->simplified_ff_gain / 100, 0, F_GAIN_MAX);
     }
 }
 
 static void calculateNewDTermFilterValues(pidProfile_t *pidProfile)
 {
-    pidProfile->dyn_lpf_dterm_min_hz = constrain(DYN_LPF_DTERM_MIN_HZ_DEFAULT * pidProfile->slider_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
-    pidProfile->dyn_lpf_dterm_max_hz = constrain(DYN_LPF_DTERM_MAX_HZ_DEFAULT * pidProfile->slider_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
-    pidProfile->dterm_lowpass2_hz = constrain(DTERM_LOWPASS_2_HZ_DEFAULT * pidProfile->slider_dterm_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
+    pidProfile->dyn_lpf_dterm_min_hz = constrain(DYN_LPF_DTERM_MIN_HZ_DEFAULT * pidProfile->simplified_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
+    pidProfile->dyn_lpf_dterm_max_hz = constrain(DYN_LPF_DTERM_MAX_HZ_DEFAULT * pidProfile->simplified_dterm_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
+    pidProfile->dterm_lowpass2_hz = constrain(DTERM_LOWPASS_2_HZ_DEFAULT * pidProfile->simplified_dterm_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
     pidProfile->dterm_filter_type = FILTER_PT1;
     pidProfile->dterm_filter2_type = FILTER_PT1;
 }
 
 static void calculateNewGyroFilterValues()
 {
-    gyroConfigMutable()->dyn_lpf_gyro_min_hz = constrain(DYN_LPF_GYRO_MIN_HZ_DEFAULT * gyroConfig()->slider_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
-    gyroConfigMutable()->dyn_lpf_gyro_max_hz = constrain(DYN_LPF_GYRO_MAX_HZ_DEFAULT * gyroConfig()->slider_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
-    gyroConfigMutable()->gyro_lowpass2_hz = constrain(GYRO_LOWPASS_2_HZ_DEFAULT * gyroConfig()->slider_gyro_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
+    gyroConfigMutable()->dyn_lpf_gyro_min_hz = constrain(DYN_LPF_GYRO_MIN_HZ_DEFAULT * gyroConfig()->simplified_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
+    gyroConfigMutable()->dyn_lpf_gyro_max_hz = constrain(DYN_LPF_GYRO_MAX_HZ_DEFAULT * gyroConfig()->simplified_gyro_filter_multiplier / 100, 0, DYN_LPF_FILTER_FREQUENCY_MAX);
+    gyroConfigMutable()->gyro_lowpass2_hz = constrain(GYRO_LOWPASS_2_HZ_DEFAULT * gyroConfig()->simplified_gyro_filter_multiplier / 100, 0, FILTER_FREQUENCY_MAX);
     gyroConfigMutable()->gyro_lowpass_type = FILTER_PT1;
     gyroConfigMutable()->gyro_lowpass2_type = FILTER_PT1;
 }
 
-void applyTuningSliders(pidProfile_t *pidProfile)
+void applySimplifiedTuning(pidProfile_t *pidProfile)
 {
-    if (pidProfile->slider_pids_mode != PID_TUNING_SLIDERS_OFF) {
+    if (pidProfile->simplified_pids_mode != PID_SIMPLIFIED_TUNING_OFF) {
         calculateNewPidValues(pidProfile);
     }
 
-    if (pidProfile->slider_dterm_filter) {
+    if (pidProfile->simplified_dterm_filter) {
         calculateNewDTermFilterValues(pidProfile);
     }
 
-    if (gyroConfig()->slider_gyro_filter) {
+    if (gyroConfig()->simplified_gyro_filter) {
         calculateNewGyroFilterValues();
     }
 }
-#endif // USE_TUNING_SLIDERS
+#endif // USE_SIMPLIFIED_TUNING
diff --git a/src/main/config/tuning_sliders.h b/src/main/config/simplified_tuning.h
similarity index 74%
rename from src/main/config/tuning_sliders.h
rename to src/main/config/simplified_tuning.h
index 9eed0e4e35..15360caafe 100644
--- a/src/main/config/tuning_sliders.h
+++ b/src/main/config/simplified_tuning.h
@@ -22,14 +22,14 @@
 
 #include "flight/pid.h"
 
-#define SLIDER_MIN 50
-#define SLIDER_MAX 200
+#define SIMPLIFIED_TUNING_MIN 50
+#define SIMPLIFIED_TUNING_MAX 200
 
 typedef enum {
-    PID_TUNING_SLIDERS_OFF = 0,
-    PID_TUNING_SLIDERS_RP,
-    PID_TUNING_SLIDERS_RPY,
-    PID_TUNING_SLIDERS_MODE_COUNT,
-} pidTuningSlidersMode_e;
+    PID_SIMPLIFIED_TUNING_OFF = 0,
+    PID_SIMPLIFIED_TUNING_RP,
+    PID_SIMPLIFIED_TUNING_RPY,
+    PID_SIMPLIFIED_TUNING_MODE_COUNT,
+} pidSimplifiedTuningMode_e;
 
-void applyTuningSliders(pidProfile_t *pidProfile);
+void applySimplifiedTuning(pidProfile_t *pidProfile);
diff --git a/src/main/flight/pid.c b/src/main/flight/pid.c
index 448222ffe8..f0f79257dc 100644
--- a/src/main/flight/pid.c
+++ b/src/main/flight/pid.c
@@ -33,7 +33,7 @@
 #include "common/maths.h"
 
 #include "config/config_reset.h"
-#include "config/tuning_sliders.h"
+#include "config/simplified_tuning.h"
 
 #include "drivers/pwm_output.h"
 #include "drivers/sound_beeper.h"
@@ -210,16 +210,16 @@ void resetPidProfile(pidProfile_t *pidProfile)
         .dyn_lpf_curve_expo = 5,
         .level_race_mode = false,
         .vbat_sag_compensation = 0,
-        .slider_pids_mode = PID_TUNING_SLIDERS_OFF,
-        .slider_master_multiplier = 100,
-        .slider_roll_pitch_ratio = 100,
-        .slider_i_gain = 100,
-        .slider_pd_ratio = 100,
-        .slider_pd_gain = 100,
-        .slider_dmin_ratio = 100,
-        .slider_ff_gain = 100,
-        .slider_dterm_filter = true,
-        .slider_dterm_filter_multiplier = 100,
+        .simplified_pids_mode = PID_SIMPLIFIED_TUNING_OFF,
+        .simplified_master_multiplier = 100,
+        .simplified_roll_pitch_ratio = 100,
+        .simplified_i_gain = 100,
+        .simplified_pd_ratio = 100,
+        .simplified_pd_gain = 100,
+        .simplified_dmin_ratio = 100,
+        .simplified_ff_gain = 100,
+        .simplified_dterm_filter = true,
+        .simplified_dterm_filter_multiplier = 100,
     );
 #ifndef USE_D_MIN
     pidProfile->pid[PID_ROLL].D = 30;
diff --git a/src/main/flight/pid.h b/src/main/flight/pid.h
index 86be1cef0a..ae7b669029 100644
--- a/src/main/flight/pid.h
+++ b/src/main/flight/pid.h
@@ -214,17 +214,17 @@ typedef struct pidProfile_s {
     uint8_t level_race_mode;                // NFE race mode - when true pitch setpoint calcualtion is gyro based in level mode
     uint8_t vbat_sag_compensation;          // Reduce motor output by this percentage of the maximum compensation amount
 
-    uint8_t slider_pids_mode;
-    uint8_t slider_master_multiplier;
-    uint8_t slider_roll_pitch_ratio;
-    uint8_t slider_i_gain;
-    uint8_t slider_pd_ratio;
-    uint8_t slider_pd_gain;
-    uint8_t slider_dmin_ratio;
-    uint8_t slider_ff_gain;
+    uint8_t simplified_pids_mode;
+    uint8_t simplified_master_multiplier;
+    uint8_t simplified_roll_pitch_ratio;
+    uint8_t simplified_i_gain;
+    uint8_t simplified_pd_ratio;
+    uint8_t simplified_pd_gain;
+    uint8_t simplified_dmin_ratio;
+    uint8_t simplified_ff_gain;
 
-    uint8_t slider_dterm_filter;
-    uint8_t slider_dterm_filter_multiplier;
+    uint8_t simplified_dterm_filter;
+    uint8_t simplified_dterm_filter_multiplier;
 } pidProfile_t;
 
 PG_DECLARE_ARRAY(pidProfile_t, PID_PROFILE_COUNT, pidProfiles);
diff --git a/src/main/msp/msp.c b/src/main/msp/msp.c
index 0ec11d4ef0..29d52dfe3f 100644
--- a/src/main/msp/msp.c
+++ b/src/main/msp/msp.c
@@ -47,7 +47,7 @@
 #include "config/config.h"
 #include "config/config_eeprom.h"
 #include "config/feature.h"
-#include "config/tuning_sliders.h"
+#include "config/simplified_tuning.h"
 
 #include "drivers/accgyro/accgyro.h"
 #include "drivers/bus_i2c.h"
@@ -2088,24 +2088,24 @@ static mspResult_e mspFcProcessOutCommandWithArg(mspDescriptor_t srcDesc, int16_
         break;
 #endif // USE_VTX_TABLE
 
-#ifdef USE_TUNING_SLIDERS
+#ifdef USE_SIMPLIFIED_TUNING
     // Added in MSP API 1.43
-    case MSP_TUNING_SLIDERS:
+    case MSP_SIMPLIFIED_TUNING:
         {
-            sbufWriteU8(dst, currentPidProfile->slider_pids_mode);
-            sbufWriteU8(dst, currentPidProfile->slider_master_multiplier);
-            sbufWriteU8(dst, currentPidProfile->slider_roll_pitch_ratio);
-            sbufWriteU8(dst, currentPidProfile->slider_i_gain);
-            sbufWriteU8(dst, currentPidProfile->slider_pd_ratio);
-            sbufWriteU8(dst, currentPidProfile->slider_pd_gain);
-            sbufWriteU8(dst, currentPidProfile->slider_dmin_ratio);
-            sbufWriteU8(dst, currentPidProfile->slider_ff_gain);
+            sbufWriteU8(dst, currentPidProfile->simplified_pids_mode);
+            sbufWriteU8(dst, currentPidProfile->simplified_master_multiplier);
+            sbufWriteU8(dst, currentPidProfile->simplified_roll_pitch_ratio);
+            sbufWriteU8(dst, currentPidProfile->simplified_i_gain);
+            sbufWriteU8(dst, currentPidProfile->simplified_pd_ratio);
+            sbufWriteU8(dst, currentPidProfile->simplified_pd_gain);
+            sbufWriteU8(dst, currentPidProfile->simplified_dmin_ratio);
+            sbufWriteU8(dst, currentPidProfile->simplified_ff_gain);
 
-            sbufWriteU8(dst, currentPidProfile->slider_dterm_filter);
-            sbufWriteU8(dst, currentPidProfile->slider_dterm_filter_multiplier);
+            sbufWriteU8(dst, currentPidProfile->simplified_dterm_filter);
+            sbufWriteU8(dst, currentPidProfile->simplified_dterm_filter_multiplier);
 
-            sbufWriteU8(dst, gyroConfig()->slider_gyro_filter);
-            sbufWriteU8(dst, gyroConfig()->slider_gyro_filter_multiplier);
+            sbufWriteU8(dst, gyroConfig()->simplified_gyro_filter);
+            sbufWriteU8(dst, gyroConfig()->simplified_gyro_filter_multiplier);
         }
         break;
 #endif
@@ -3054,25 +3054,25 @@ static mspResult_e mspProcessInCommand(mspDescriptor_t srcDesc, int16_t cmdMSP,
         break;
 #endif
 
-#ifdef USE_TUNING_SLIDERS
+#ifdef USE_SIMPLIFIED_TUNING
     // Added in MSP API 1.43
-    case MSP_SET_TUNING_SLIDERS:
-        currentPidProfile->slider_pids_mode = sbufReadU8(src);
-        currentPidProfile->slider_master_multiplier = sbufReadU8(src);
-        currentPidProfile->slider_roll_pitch_ratio = sbufReadU8(src);
-        currentPidProfile->slider_i_gain = sbufReadU8(src);
-        currentPidProfile->slider_pd_ratio = sbufReadU8(src);
-        currentPidProfile->slider_pd_gain = sbufReadU8(src);
-        currentPidProfile->slider_dmin_ratio = sbufReadU8(src);
-        currentPidProfile->slider_ff_gain = sbufReadU8(src);
+    case MSP_SET_SIMPLIFIED_TUNING:
+        currentPidProfile->simplified_pids_mode = sbufReadU8(src);
+        currentPidProfile->simplified_master_multiplier = sbufReadU8(src);
+        currentPidProfile->simplified_roll_pitch_ratio = sbufReadU8(src);
+        currentPidProfile->simplified_i_gain = sbufReadU8(src);
+        currentPidProfile->simplified_pd_ratio = sbufReadU8(src);
+        currentPidProfile->simplified_pd_gain = sbufReadU8(src);
+        currentPidProfile->simplified_dmin_ratio = sbufReadU8(src);
+        currentPidProfile->simplified_ff_gain = sbufReadU8(src);
 
-        currentPidProfile->slider_dterm_filter = sbufReadU8(src);
-        currentPidProfile->slider_dterm_filter_multiplier = sbufReadU8(src);
+        currentPidProfile->simplified_dterm_filter = sbufReadU8(src);
+        currentPidProfile->simplified_dterm_filter_multiplier = sbufReadU8(src);
 
-        gyroConfigMutable()->slider_gyro_filter = sbufReadU8(src);
-        gyroConfigMutable()->slider_gyro_filter_multiplier = sbufReadU8(src);
+        gyroConfigMutable()->simplified_gyro_filter = sbufReadU8(src);
+        gyroConfigMutable()->simplified_gyro_filter_multiplier = sbufReadU8(src);
 
-        applyTuningSliders(currentPidProfile);
+        applySimplifiedTuning(currentPidProfile);
 
         break;
 #endif
diff --git a/src/main/msp/msp_protocol.h b/src/main/msp/msp_protocol.h
index 554366a3ab..7f4bc7f6bf 100644
--- a/src/main/msp/msp_protocol.h
+++ b/src/main/msp/msp_protocol.h
@@ -285,8 +285,8 @@
 #define MSP_VTXTABLE_POWERLEVEL  138    //out message         vtxTable powerLevel data
 #define MSP_MOTOR_TELEMETRY      139    //out message         Per-motor telemetry data (RPM, packet stats, ESC temp, etc.)
 
-#define MSP_TUNING_SLIDERS       140    //out message         Tuning slider poisitons and enabled state
-#define MSP_SET_TUNING_SLIDERS   141    //in message          Set tuning slider positions and apply tuning slider calculation
+#define MSP_SIMPLIFIED_TUNING       140    //out message         Simplified tuning values and enabled state
+#define MSP_SET_SIMPLIFIED_TUNING   141    //in message          Set simplified tuning positions and apply the calculated tuning
 
 #define MSP_SET_RAW_RC           200    //in message          8 rc chan
 #define MSP_SET_RAW_GPS          201    //in message          fix, numsat, lat, lon, alt, speed
diff --git a/src/main/sensors/gyro.h b/src/main/sensors/gyro.h
index 9da79a02bb..52c9a59c34 100644
--- a/src/main/sensors/gyro.h
+++ b/src/main/sensors/gyro.h
@@ -204,8 +204,8 @@ typedef struct gyroConfig_s {
 
     uint8_t gyrosDetected; // What gyros should detection be attempted for on startup. Automatically set on first startup.
     uint8_t dyn_lpf_curve_expo; // set the curve for dynamic gyro lowpass filter
-    uint8_t  slider_gyro_filter;
-    uint8_t  slider_gyro_filter_multiplier;
+    uint8_t  simplified_gyro_filter;
+    uint8_t  simplified_gyro_filter_multiplier;
 } gyroConfig_t;
 
 PG_DECLARE(gyroConfig_t, gyroConfig);
diff --git a/src/main/target/common_pre.h b/src/main/target/common_pre.h
index 595181be3e..e0dacb18ed 100644
--- a/src/main/target/common_pre.h
+++ b/src/main/target/common_pre.h
@@ -395,5 +395,5 @@
 #define USE_CUSTOM_BOX_NAMES
 #define USE_BATTERY_VOLTAGE_SAG_COMPENSATION
 #define USE_RX_MSP_OVERRIDE
-#define USE_TUNING_SLIDERS
+#define USE_SIMPLIFIED_TUNING
 #endif