diff --git a/plugins/feature/limerfe/limerfe.cpp b/plugins/feature/limerfe/limerfe.cpp
index fc631375c..80d67b76d 100644
--- a/plugins/feature/limerfe/limerfe.cpp
+++ b/plugins/feature/limerfe/limerfe.cpp
@@ -105,10 +105,16 @@ void LimeRFE::listComPorts()
     }
 }
 
-void LimeRFE::applySettings(const LimeRFESettings& settings, bool force)
+void LimeRFE::applySettings(const LimeRFESettings& settings, const QList<QString>& settingsKeys, bool force)
 {
-    (void) force;
-    m_settings = settings;
+    qDebug() << "LimeRFE::applySettings:" << settings.getDebugString(settingsKeys, force) << " force:" << force;
+
+    if (force) {
+        m_settings = settings;
+    } else {
+        m_settings.applySettings(settingsKeys, settings);
+    }
+
 }
 
 bool LimeRFE::handleMessage(const Message& cmd)
@@ -117,7 +123,7 @@ bool LimeRFE::handleMessage(const Message& cmd)
 	{
         MsgConfigureLimeRFE& cfg = (MsgConfigureLimeRFE&) cmd;
         qDebug() << "LimeRFE::handleMessage: MsgConfigureLimeRFE";
-        applySettings(cfg.getSettings(), cfg.getForce());
+        applySettings(cfg.getSettings(), cfg.getSettingsKeys(), cfg.getForce());
 
 		return true;
 	}
@@ -149,14 +155,14 @@ bool LimeRFE::deserialize(const QByteArray& data)
 
         if (m_settings.deserialize(bytetmp))
         {
-            MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(m_settings, true);
+            MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(m_settings, QList<QString>(), true);
             m_inputMessageQueue.push(msg);
             return true;
         }
         else
         {
             m_settings.resetToDefaults();
-            MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(m_settings, true);
+            MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(m_settings, QList<QString>(), true);
             m_inputMessageQueue.push(msg);
             return false;
         }
@@ -542,87 +548,119 @@ void LimeRFE::settingsToState(const LimeRFESettings& settings)
     }
 }
 
-void LimeRFE::stateToSettings(LimeRFESettings& settings)
+void LimeRFE::stateToSettings(LimeRFESettings& settings, QList<QString>& settingsKeys)
 {
     if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND01)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_rxCellularChannel = LimeRFESettings::CellularChannel::CellularBand1;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxCellularChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND02)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_rxCellularChannel = LimeRFESettings::CellularChannel::CellularBand2;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxCellularChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND03)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_rxCellularChannel = LimeRFESettings::CellularChannel::CellularBand3;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxCellularChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND07)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_rxCellularChannel = LimeRFESettings::CellularChannel::CellularBand7;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxCellularChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_CELL_BAND38)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_rxCellularChannel = LimeRFESettings::CellularChannel::CellularBand38;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxCellularChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_WB_1000)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsWideband;
         settings.m_rxWidebandChannel = LimeRFESettings::WidebandChannel::WidebandLow;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxWidebandChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_WB_4000)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsWideband;
         settings.m_rxWidebandChannel = LimeRFESettings::WidebandChannel::WidebandHigh;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxWidebandChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0030)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_30M;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0070)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_50_70MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0145)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_144_146MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0220)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_220_225MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0435)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_430_440MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_0920)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_902_928MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_1280)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_1240_1325MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_2400)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_2300_2450MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
     else if (m_rfeBoardState.channelIDRX == RFE_CID_HAM_3500)
     {
         settings.m_rxChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_rxHAMChannel = LimeRFESettings::HAMChannel::HAM_3300_3500MHz;
+        settingsKeys.append("rxChannels");
+        settingsKeys.append("rxHAMChannel");
     }
 
     if (m_rfeBoardState.selPortRX == RFE_PORT_1) {
@@ -631,85 +669,119 @@ void LimeRFE::stateToSettings(LimeRFESettings& settings)
         settings.m_rxPort = LimeRFESettings::RxPort::RxPortJ5;
     }
 
+    settingsKeys.append("rxPort");
+
     if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND01)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_txCellularChannel = LimeRFESettings::CellularChannel::CellularBand1;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txCellularChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND02)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_txCellularChannel = LimeRFESettings::CellularChannel::CellularBand2;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txCellularChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND03)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_txCellularChannel = LimeRFESettings::CellularChannel::CellularBand3;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txCellularChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND07)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_txCellularChannel = LimeRFESettings::CellularChannel::CellularBand7;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txCellularChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_CELL_BAND38)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsCellular;
         settings.m_txCellularChannel = LimeRFESettings::CellularChannel::CellularBand38;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txCellularChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_WB_1000)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsWideband;
         settings.m_txWidebandChannel = LimeRFESettings::WidebandChannel::WidebandLow;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txWidebandChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_WB_4000)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsWideband;
         settings.m_txWidebandChannel = LimeRFESettings::WidebandChannel::WidebandHigh;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txWidebandChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0030)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_30M;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0070)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_50_70MHz;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0145)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_144_146MHz;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0220)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_220_225MHz;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0435)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_430_440MHz;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_0920)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_902_928MHz;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_1280)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_1240_1325MHz;
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_2400)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_2300_2450MHz;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
     else if (m_rfeBoardState.channelIDTX == RFE_CID_HAM_3500)
     {
         settings.m_txChannels = LimeRFESettings::ChannelGroups::ChannelsHAM;
         settings.m_txHAMChannel = LimeRFESettings::HAMChannel::HAM_3300_3500MHz;
+        settingsKeys.append("txChannels");
+        settingsKeys.append("txHAMChannel");
     }
 
     if (m_rfeBoardState.selPortTX == RFE_PORT_1) {
@@ -720,6 +792,12 @@ void LimeRFE::stateToSettings(LimeRFESettings& settings)
         settings.m_txPort = LimeRFESettings::TxPort::TxPortJ5;
     }
 
+    settingsKeys.append("txPort");
+    settingsKeys.append("attenuationFactor");
+    settingsKeys.append("amfmNotch");
+    settingsKeys.append("swrEnable");
+    settingsKeys.append("swrSource");
+
     settings.m_attenuationFactor = m_rfeBoardState.attValue;
     settings.m_amfmNotch =  m_rfeBoardState.notchOnOff == RFE_NOTCH_ON;
     settings.m_swrEnable = m_rfeBoardState.enableSWR == RFE_SWR_ENABLE;
@@ -770,13 +848,13 @@ int LimeRFE::webapiSettingsPutPatch(
     LimeRFESettings settings = m_settings;
     webapiUpdateFeatureSettings(settings, featureSettingsKeys, response);
 
-    MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(settings, force);
+    MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(settings, featureSettingsKeys, force);
     m_inputMessageQueue.push(msg);
 
     qDebug("LimeRFE::webapiSettingsPutPatch: forward to GUI: %p", m_guiMessageQueue);
     if (m_guiMessageQueue) // forward to GUI if any
     {
-        MsgConfigureLimeRFE *msgToGUI = MsgConfigureLimeRFE::create(settings, true);
+        MsgConfigureLimeRFE *msgToGUI = MsgConfigureLimeRFE::create(settings, featureSettingsKeys, true);
         m_guiMessageQueue->push(msgToGUI);
     }
 
@@ -895,12 +973,13 @@ int LimeRFE::webapiActionsPost(
 
         if (featureActionsKeys.contains("fromToSettings") && (swgLimeRFEActions->getFromToSettings() == 0))
         {
-            stateToSettings(m_settings);
+            QList<QString> settingsKeys;
+            stateToSettings(m_settings, settingsKeys);
             unknownAction = false;
 
             if (getMessageQueueToGUI())
             {
-                MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(m_settings, false);
+                MsgConfigureLimeRFE *msg = MsgConfigureLimeRFE::create(m_settings, settingsKeys, false);
                 getMessageQueueToGUI()->push(msg);
             }
         }
diff --git a/plugins/feature/limerfe/limerfe.h b/plugins/feature/limerfe/limerfe.h
index 4f8e168e6..2e9476cba 100644
--- a/plugins/feature/limerfe/limerfe.h
+++ b/plugins/feature/limerfe/limerfe.h
@@ -41,19 +41,22 @@ public:
 
     public:
         const LimeRFESettings& getSettings() const { return m_settings; }
+        const QList<QString>& getSettingsKeys() const { return m_settingsKeys; }
         bool getForce() const { return m_force; }
 
-        static MsgConfigureLimeRFE* create(const LimeRFESettings& settings, bool force) {
-            return new MsgConfigureLimeRFE(settings, force);
+        static MsgConfigureLimeRFE* create(const LimeRFESettings& settings, const QList<QString>& settingsKeys, bool force) {
+            return new MsgConfigureLimeRFE(settings, settingsKeys, force);
         }
 
     private:
         LimeRFESettings m_settings;
+        QList<QString> m_settingsKeys;
         bool m_force;
 
-        MsgConfigureLimeRFE(const LimeRFESettings& settings, bool force) :
+        MsgConfigureLimeRFE(const LimeRFESettings& settings, const QList<QString>& settingsKeys, bool force) :
             Message(),
             m_settings(settings),
+            m_settingsKeys(settingsKeys),
             m_force(force)
         { }
     };
@@ -152,7 +155,7 @@ public:
     int getRefPower(int& powerDB);
 
     void settingsToState(const LimeRFESettings& settings);
-    void stateToSettings(LimeRFESettings& settings);
+    void stateToSettings(LimeRFESettings& settings, QList<QString>& settingsKeys);
 
     static const char* const m_featureIdURI;
     static const char* const m_featureId;
@@ -174,7 +177,7 @@ private:
     void start();
     void stop();
     void listComPorts();
-    void applySettings(const LimeRFESettings& settings, bool force = false);
+    void applySettings(const LimeRFESettings& settings, const QList<QString>& settingsKeys, bool force = false);
     int webapiFormatFeatureReport(SWGSDRangel::SWGFeatureReport& response, QString& errorMessage);
 
 private slots:
diff --git a/plugins/feature/limerfe/limerfegui.cpp b/plugins/feature/limerfe/limerfegui.cpp
index 84826c2b3..dd3f6b6cb 100644
--- a/plugins/feature/limerfe/limerfegui.cpp
+++ b/plugins/feature/limerfe/limerfegui.cpp
@@ -71,6 +71,7 @@ bool LimeRFEGUI::deserialize(const QByteArray& data)
 void LimeRFEGUI::setWorkspaceIndex(int index)
 {
     m_settings.m_workspaceIndex = index;
+    m_settingsKeys.append("workspaceIndex");
     m_feature->setWorkspaceIndex(index);
 }
 
@@ -109,6 +110,14 @@ void LimeRFEGUI::onMenuDialogCalled(const QPoint &p)
         setTitle(m_settings.m_title);
         setTitleColor(m_settings.m_rgbColor);
 
+        m_settingsKeys.append("title");
+        m_settingsKeys.append("rgbColor");
+        m_settingsKeys.append("useReverseAPI");
+        m_settingsKeys.append("reverseAPIAddress");
+        m_settingsKeys.append("reverseAPIPort");
+        m_settingsKeys.append("reverseAPIFeatureSetIndex");
+        m_settingsKeys.append("reverseAPIFeatureIndex");
+
         applySettings();
     }
 
@@ -164,9 +173,11 @@ void LimeRFEGUI::applySettings(bool force)
 {
 	if (m_doApplySettings)
 	{
-	    LimeRFE::MsgConfigureLimeRFE* message = LimeRFE::MsgConfigureLimeRFE::create( m_settings, force);
+	    LimeRFE::MsgConfigureLimeRFE* message = LimeRFE::MsgConfigureLimeRFE::create( m_settings, m_settingsKeys, force);
 	    m_limeRFE->getInputMessageQueue()->push(message);
 	}
+
+    m_settingsKeys.clear();
 }
 
 void LimeRFEGUI::displaySettings()
@@ -339,6 +350,7 @@ void LimeRFEGUI::setRxChannels()
                 ui->rxPort->addItem("TX/RX (J3)");
                 ui->rxPort->setEnabled(false);
                 m_settings.m_rxPort = LimeRFESettings::RxPortJ3;
+                m_settingsKeys.append("rxPort");
                 ui->rxPort->setCurrentIndex((int) m_settings.m_rxPort);
                 break;
             default:
@@ -356,8 +368,10 @@ void LimeRFEGUI::setRxChannels()
         ui->rxPort->addItem("TX/RX (J3)");
         ui->rxPort->setEnabled(false);
         m_settings.m_rxPort = LimeRFESettings::RxPortJ3;
+        m_settingsKeys.append("rxPort");
         ui->rxPort->setCurrentIndex((int) m_settings.m_rxPort);
         m_settings.m_txRxDriven = true;
+        m_settingsKeys.append("txRxDriven");
         ui->txFollowsRx->setEnabled(false);
         ui->txFollowsRx->setChecked(m_settings.m_txRxDriven);
     }
@@ -408,6 +422,7 @@ void LimeRFEGUI::setTxChannels()
                 ui->txPort->addItem("TX/RX 30M (J5)");
                 ui->txPort->setEnabled(false);
                 m_settings.m_txPort = LimeRFESettings::TxPortJ5;
+                m_settingsKeys.append("txPort");
                 ui->txPort->setCurrentIndex((int) m_settings.m_txPort);
                 break;
             case LimeRFESettings::HAM_144_146MHz:
@@ -436,6 +451,7 @@ void LimeRFEGUI::setTxChannels()
         ui->txChannel->setCurrentIndex((int) m_settings.m_txCellularChannel);
         ui->txPort->addItem("TX/RX (J3)");
         m_settings.m_txPort = LimeRFESettings::TxPortJ3;
+        m_settingsKeys.append("txPort");
         ui->txPort->setEnabled(false);
         ui->txPort->setCurrentIndex((int) m_settings.m_txPort);
     }
@@ -665,7 +681,7 @@ void LimeRFEGUI::on_deviceToGUI_clicked()
         return;
     }
 
-    m_limeRFE->stateToSettings(m_settings);
+    m_limeRFE->stateToSettings(m_settings, m_settingsKeys);
     m_rxOn = m_limeRFE->getRx();
     m_txOn = m_limeRFE->getTx();
     displaySettings();
@@ -675,11 +691,13 @@ void LimeRFEGUI::on_deviceToGUI_clicked()
 void LimeRFEGUI::on_rxChannelGroup_currentIndexChanged(int index)
 {
     m_settings.m_rxChannels = (LimeRFESettings::ChannelGroups) index;
+    m_settingsKeys.append("rxChannels");
     setRxChannels();
 
     if (m_settings.m_txRxDriven)
     {
         m_settings.m_txChannels = m_settings.m_rxChannels;
+        m_settingsKeys.append("txChannels");
         ui->txChannelGroup->setCurrentIndex((int) m_settings.m_txChannels);
     }
 
@@ -688,12 +706,20 @@ void LimeRFEGUI::on_rxChannelGroup_currentIndexChanged(int index)
 
 void LimeRFEGUI::on_rxChannel_currentIndexChanged(int index)
 {
-    if (m_settings.m_rxChannels == LimeRFESettings::ChannelsWideband) {
+    if (m_settings.m_rxChannels == LimeRFESettings::ChannelsWideband)
+    {
         m_settings.m_rxWidebandChannel = (LimeRFESettings::WidebandChannel) index;
-    } else if (m_settings.m_rxChannels == LimeRFESettings::ChannelsHAM) {
+        m_settingsKeys.append("rxWidebandChannel");
+    }
+    else if (m_settings.m_rxChannels == LimeRFESettings::ChannelsHAM)
+    {
         m_settings.m_rxHAMChannel = (LimeRFESettings::HAMChannel) index;
-    } else if (m_settings.m_rxChannels == LimeRFESettings::ChannelsCellular) {
+        m_settingsKeys.append("rxHAMChannel");
+    }
+    else if (m_settings.m_rxChannels == LimeRFESettings::ChannelsCellular)
+    {
         m_settings.m_rxCellularChannel = (LimeRFESettings::CellularChannel) index;
+        m_settingsKeys.append("rxCellularChannel");
     }
 
     setRxChannels();
@@ -703,6 +729,9 @@ void LimeRFEGUI::on_rxChannel_currentIndexChanged(int index)
         m_settings.m_txWidebandChannel = m_settings.m_rxWidebandChannel;
         m_settings.m_txHAMChannel = m_settings.m_rxHAMChannel;
         m_settings.m_txCellularChannel = m_settings.m_rxCellularChannel;
+        m_settingsKeys.append("txWidebandChannel");
+        m_settingsKeys.append("txHAMChannel");
+        m_settingsKeys.append("txCellularChannel");
         setTxChannels();
     }
 
@@ -712,6 +741,7 @@ void LimeRFEGUI::on_rxChannel_currentIndexChanged(int index)
 void LimeRFEGUI::on_rxPort_currentIndexChanged(int index)
 {
     m_settings.m_rxPort = (LimeRFESettings::RxPort) index;
+    m_settingsKeys.append("rxPort");
     highlightApplyButton(true);
 }
 
@@ -725,6 +755,11 @@ void LimeRFEGUI::on_txFollowsRx_clicked()
     m_settings.m_txWidebandChannel = m_settings.m_rxWidebandChannel;
     m_settings.m_txHAMChannel = m_settings.m_rxHAMChannel;
     m_settings.m_txCellularChannel = m_settings.m_rxCellularChannel;
+    m_settingsKeys.append("txRxDriven");
+    m_settingsKeys.append("txChannels");
+    m_settingsKeys.append("txWidebandChannel");
+    m_settingsKeys.append("txHAMChannel");
+    m_settingsKeys.append("txCellularChannel");
     ui->txChannelGroup->setCurrentIndex((int) m_settings.m_txChannels);
 
     if (checked) {
@@ -735,18 +770,27 @@ void LimeRFEGUI::on_txFollowsRx_clicked()
 void LimeRFEGUI::on_txChannelGroup_currentIndexChanged(int index)
 {
     m_settings.m_txChannels = (LimeRFESettings::ChannelGroups) index;
+    m_settingsKeys.append("txChannels");
     setTxChannels();
     highlightApplyButton(true);
 }
 
 void LimeRFEGUI::on_txChannel_currentIndexChanged(int index)
 {
-    if (m_settings.m_txChannels == LimeRFESettings::ChannelsWideband) {
+    if (m_settings.m_txChannels == LimeRFESettings::ChannelsWideband)
+    {
         m_settings.m_txWidebandChannel = (LimeRFESettings::WidebandChannel) index;
-    } else if (m_settings.m_txChannels == LimeRFESettings::ChannelsHAM) {
+        m_settingsKeys.append("txWidebandChannel");
+    }
+    else if (m_settings.m_txChannels == LimeRFESettings::ChannelsHAM)
+    {
         m_settings.m_txHAMChannel = (LimeRFESettings::HAMChannel) index;
-    } else if (m_settings.m_txChannels == LimeRFESettings::ChannelsCellular) {
+        m_settingsKeys.append("txHAMChannel");
+    }
+    else if (m_settings.m_txChannels == LimeRFESettings::ChannelsCellular)
+    {
         m_settings.m_txCellularChannel = (LimeRFESettings::CellularChannel) index;
+        m_settingsKeys.append("txCellularChannel");
     }
 
     setTxChannels();
@@ -756,18 +800,21 @@ void LimeRFEGUI::on_txChannel_currentIndexChanged(int index)
 void LimeRFEGUI::on_txPort_currentIndexChanged(int index)
 {
     m_settings.m_txPort = (LimeRFESettings::TxPort) index;
+    m_settingsKeys.append("txPort");
     highlightApplyButton(true);
 }
 
 void LimeRFEGUI::on_powerEnable_clicked()
 {
     m_settings.m_swrEnable = ui->powerEnable->isChecked();
+    m_settingsKeys.append("swrEnable");
     highlightApplyButton(true);
 }
 
 void LimeRFEGUI::on_powerSource_currentIndexChanged(int index)
 {
     m_settings.m_swrSource = (LimeRFESettings::SWRSource) index;
+    m_settingsKeys.append("swrSource");
     highlightApplyButton(true);
 }
 
@@ -951,12 +998,14 @@ void LimeRFEGUI::on_rxTxToggle_clicked()
 void LimeRFEGUI::on_attenuation_currentIndexChanged(int index)
 {
     m_settings.m_attenuationFactor = index;
+    m_settingsKeys.append("attenuationFactor");
     highlightApplyButton(true);
 }
 
 void LimeRFEGUI::on_amFmNotchFilter_clicked()
 {
     m_settings.m_amfmNotch = ui->amFmNotchFilter->isChecked();
+    m_settingsKeys.append("amfmNotch");
     highlightApplyButton(true);
 }
 
@@ -980,7 +1029,13 @@ bool LimeRFEGUI::handleMessage(const Message& message)
     {
         qDebug("LimeRFEGUI::handleMessage: LimeRFE::MsgConfigureLimeRFE");
         const LimeRFE::MsgConfigureLimeRFE& cfg = (LimeRFE::MsgConfigureLimeRFE&) message;
-        m_settings = cfg.getSettings();
+
+        if (cfg.getForce()) {
+            m_settings = cfg.getSettings();
+        } else {
+            m_settings.applySettings(cfg.getSettingsKeys(), cfg.getSettings());
+        }
+
         displaySettings();
         highlightApplyButton(cfg.getForce());
         return true;
diff --git a/plugins/feature/limerfe/limerfegui.h b/plugins/feature/limerfe/limerfegui.h
index 0bdd66a97..89561fbd0 100644
--- a/plugins/feature/limerfe/limerfegui.h
+++ b/plugins/feature/limerfe/limerfegui.h
@@ -59,6 +59,7 @@ private:
 	PluginAPI* m_pluginAPI;
 	FeatureUISet* m_featureUISet;
 	LimeRFESettings m_settings;
+    QList<QString> m_settingsKeys;
 	RollupState m_rollupState;
     bool m_rxOn;
     bool m_txOn;
diff --git a/plugins/feature/limerfe/limerfesettings.cpp b/plugins/feature/limerfe/limerfesettings.cpp
index 98d94ffb0..c5c812ce5 100644
--- a/plugins/feature/limerfe/limerfesettings.cpp
+++ b/plugins/feature/limerfe/limerfesettings.cpp
@@ -180,3 +180,159 @@ bool LimeRFESettings::deserialize(const QByteArray& data)
         return false;
     }
 }
+
+void LimeRFESettings::applySettings(const QStringList& settingsKeys, const LimeRFESettings& settings)
+{
+    if (settingsKeys.contains("devicePath")) {
+        m_devicePath = settings.m_devicePath;
+    }
+    if (settingsKeys.contains("title")) {
+        m_title = settings.m_title;
+    }
+    if (settingsKeys.contains("rgbColor")) {
+        m_rgbColor = settings.m_rgbColor;
+    }
+    if (settingsKeys.contains("rxChannels")) {
+        m_rxChannels = settings.m_rxChannels;
+    }
+    if (settingsKeys.contains("rxWidebandChannel")) {
+        m_rxWidebandChannel = settings.m_rxWidebandChannel;
+    }
+    if (settingsKeys.contains("rxHAMChannel")) {
+        m_rxHAMChannel = settings.m_rxHAMChannel;
+    }
+    if (settingsKeys.contains("rxCellularChannel")) {
+        m_rxCellularChannel = settings.m_rxCellularChannel;
+    }
+    if (settingsKeys.contains("rxPort")) {
+        m_rxPort = settings.m_rxPort;
+    }
+    if (settingsKeys.contains("amfmNotch")) {
+        m_amfmNotch = settings.m_amfmNotch;
+    }
+    if (settingsKeys.contains("attenuationFactor")) {
+        m_attenuationFactor = settings.m_attenuationFactor;
+    }
+    if (settingsKeys.contains("txChannels")) {
+        m_txChannels = settings.m_txChannels;
+    }
+    if (settingsKeys.contains("txWidebandChannel")) {
+        m_txWidebandChannel = settings.m_txWidebandChannel;
+    }
+    if (settingsKeys.contains("txHAMChannel")) {
+        m_txHAMChannel = settings.m_txHAMChannel;
+    }
+    if (settingsKeys.contains("txCellularChannel")) {
+        m_txCellularChannel = settings.m_txCellularChannel;
+    }
+    if (settingsKeys.contains("txPort")) {
+        m_txPort = settings.m_txPort;
+    }
+    if (settingsKeys.contains("swrEnable")) {
+        m_swrEnable = settings.m_swrEnable;
+    }
+    if (settingsKeys.contains("swrSource")) {
+        m_swrSource = settings.m_swrSource;
+    }
+    if (settingsKeys.contains("txRxDriven")) {
+        m_txRxDriven = settings.m_txRxDriven;
+    }
+    if (settingsKeys.contains("useReverseAPI")) {
+        m_useReverseAPI = settings.m_useReverseAPI;
+    }
+    if (settingsKeys.contains("reverseAPIAddress")) {
+        m_reverseAPIAddress = settings.m_reverseAPIAddress;
+    }
+    if (settingsKeys.contains("reverseAPIPort")) {
+        m_reverseAPIPort = settings.m_reverseAPIPort;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureSetIndex")) {
+        m_reverseAPIFeatureSetIndex = settings.m_reverseAPIFeatureSetIndex;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureIndex")) {
+        m_reverseAPIFeatureIndex = settings.m_reverseAPIFeatureIndex;
+    }
+    if (settingsKeys.contains("workspaceIndex")) {
+        m_workspaceIndex = settings.m_workspaceIndex;
+    }
+}
+
+QString LimeRFESettings::getDebugString(const QStringList& settingsKeys, bool force) const
+{
+    std::ostringstream ostr;
+
+    if (settingsKeys.contains("devicePath") || force) {
+        ostr << " m_devicePath: " << m_devicePath.toStdString();
+    }
+    if (settingsKeys.contains("title") || force) {
+        ostr << " m_title: " << m_title.toStdString();
+    }
+    if (settingsKeys.contains("rgbColor") || force) {
+        ostr << " m_rgbColor: " << m_rgbColor;
+    }
+    if (settingsKeys.contains("rxChannels") || force) {
+        ostr << " m_rxChannels: " << m_rxChannels;
+    }
+    if (settingsKeys.contains("rxWidebandChannel") || force) {
+        ostr << " m_rxWidebandChannel: " << m_rxWidebandChannel;
+    }
+    if (settingsKeys.contains("rxHAMChannel") || force) {
+        ostr << " m_rxHAMChannel: " << m_rxHAMChannel;
+    }
+    if (settingsKeys.contains("rxCellularChannel") || force) {
+        ostr << " m_rxCellularChannel: " << m_rxCellularChannel;
+    }
+    if (settingsKeys.contains("rxPort") || force) {
+        ostr << " m_rxPort: " << m_rxPort;
+    }
+    if (settingsKeys.contains("amfmNotch") || force) {
+        ostr << " m_amfmNotch: " << m_amfmNotch;
+    }
+    if (settingsKeys.contains("attenuationFactor") || force) {
+        ostr << " m_attenuationFactor: " << m_attenuationFactor;
+    }
+    if (settingsKeys.contains("txChannels") || force) {
+        ostr << " m_txChannels: " << m_txChannels;
+    }
+    if (settingsKeys.contains("txWidebandChannel") || force) {
+        ostr << " m_txWidebandChannel: " << m_txWidebandChannel;
+    }
+    if (settingsKeys.contains("txHAMChannel") || force) {
+        ostr << " m_txHAMChannel: " << m_txHAMChannel;
+    }
+    if (settingsKeys.contains("txCellularChannel") || force) {
+        ostr << " m_txCellularChannel: " << m_txCellularChannel;
+    }
+    if (settingsKeys.contains("txPort") || force) {
+        ostr << " m_txPort: " << m_txPort;
+    }
+    if (settingsKeys.contains("swrEnable") || force) {
+        ostr << " m_swrEnable: " << m_swrEnable;
+    }
+    if (settingsKeys.contains("swrSource") || force) {
+        ostr << " m_swrSource: " << m_swrSource;
+    }
+    if (settingsKeys.contains("txRxDriven") || force) {
+        ostr << " m_txRxDriven: " << m_txRxDriven;
+    }
+    if (settingsKeys.contains("useReverseAPI") || force) {
+        ostr << " m_useReverseAPI: " << m_useReverseAPI;
+    }
+    if (settingsKeys.contains("rgbColor") || force) {
+        ostr << " m_reverseAPIAddress: " << m_reverseAPIAddress.toStdString();
+    }
+    if (settingsKeys.contains("reverseAPIPort") || force) {
+        ostr << " m_reverseAPIPort: " << m_reverseAPIPort;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureSetIndex") || force) {
+        ostr << " m_reverseAPIFeatureSetIndex: " << m_reverseAPIFeatureSetIndex;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureIndex") || force) {
+        ostr << " m_reverseAPIFeatureIndex: " << m_reverseAPIFeatureIndex;
+    }
+    if (settingsKeys.contains("workspaceIndex") || force) {
+        ostr << " m_workspaceIndex: " << m_workspaceIndex;
+    }
+
+    return QString(ostr.str().c_str());
+}
diff --git a/plugins/feature/limerfe/limerfesettings.h b/plugins/feature/limerfe/limerfesettings.h
index 8dca60c6b..00a151005 100644
--- a/plugins/feature/limerfe/limerfesettings.h
+++ b/plugins/feature/limerfe/limerfesettings.h
@@ -118,6 +118,8 @@ struct LimeRFESettings
     QByteArray serialize() const;
     bool deserialize(const QByteArray& data);
     void setRollupState(Serializable *rollupState) { m_rollupState = rollupState; }
+    void applySettings(const QStringList& settingsKeys, const LimeRFESettings& settings);
+    QString getDebugString(const QStringList& settingsKeys, bool force=false) const;
 };
 
 #endif