diff --git a/ear-production-suite-plugins/lib/include/binaural_monitoring_audio_processor.hpp b/ear-production-suite-plugins/lib/include/binaural_monitoring_audio_processor.hpp
index 3817499b8..aa830ab50 100644
--- a/ear-production-suite-plugins/lib/include/binaural_monitoring_audio_processor.hpp
+++ b/ear-production-suite-plugins/lib/include/binaural_monitoring_audio_processor.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <vector>
+#include <string>
 #include <../src/dynamic_renderer.hpp>
 #include "variable_block_adapter.hpp"
 #include <chrono>
@@ -9,6 +10,20 @@
 namespace ear {
 namespace plugin {
 
+enum BearStatusStates {
+  NOT_ATTEMPTED = 0,
+  FAILED,
+  SUCCEEDED
+};
+
+struct BearStatus {
+  bear::Config startupConfig;
+  BearStatusStates startupSuccess{NOT_ATTEMPTED};
+  std::string startupErrorDesc;
+  BearStatusStates listenerDataSetSuccess{NOT_ATTEMPTED};
+  std::string listenerDataSetErrorDesc;
+};
+
 /**
  * @brief Binaural monitoring plugin dsp implementation
  *
@@ -47,6 +62,8 @@ class BinauralMonitoringAudioProcessor {
   BinauralMonitoringAudioProcessor& operator=(
       BinauralMonitoringAudioProcessor&&) = delete;
 
+  BearStatus getBearStatus() { return bearStatus; }
+
   template <typename InBuffer, typename OutBuffer>
   void process(const InBuffer& in, OutBuffer& out) {
     using InTraits = BufferTraits<InBuffer>;
@@ -67,7 +84,7 @@ class BinauralMonitoringAudioProcessor {
   void setListenerOrientation(float quatW, float quatX, float quatY,
                               float quatZ);
 
-  bool rendererError() { return !bearRenderer; }
+  bool rendererStarted() { return bearRenderer && bearStatus.startupSuccess == SUCCEEDED; }
 
   void setIsPlaying(bool state) { isPlaying = state; }
   bool getIsPlaying() { return isPlaying; }
@@ -84,6 +101,7 @@ class BinauralMonitoringAudioProcessor {
   std::shared_ptr<bear::DynamicRenderer> bearRenderer;  // TODO - why shared?
   std::mutex bearListenerMutex_;
   bear::Listener bearListener;
+  BearStatus bearStatus;
 
   bool listenerQuatsDirty{false};
   std::array<double, 4> listenerQuats{1.0, 0.0, 0.0, 0.0};
diff --git a/ear-production-suite-plugins/lib/src/binaural_monitoring_audio_processor.cpp b/ear-production-suite-plugins/lib/src/binaural_monitoring_audio_processor.cpp
index 9b5384ffe..e9909371b 100644
--- a/ear-production-suite-plugins/lib/src/binaural_monitoring_audio_processor.cpp
+++ b/ear-production-suite-plugins/lib/src/binaural_monitoring_audio_processor.cpp
@@ -37,19 +37,25 @@ BinauralMonitoringAudioProcessor::BinauralMonitoringAudioProcessor(
 
   bearListener.set_position_cart(std::array<double, 3>{0.0, 0.0, 0.0});
 
+  bearStatus.startupConfig = bearConfig;
   try {
     bearRenderer = std::make_shared<bear::DynamicRenderer>(
         blockSize,
         std::max(std::max(maxObjChannels, maxDsChannels), maxHoaChannels));
+    bearRenderer->set_config_blocking(bearConfig);
+    bearStatus.startupSuccess = BearStatusStates::SUCCEEDED;
     try {
       bearRenderer->set_listener(bearListener);
+      bearStatus.listenerDataSetSuccess = BearStatusStates::SUCCEEDED;
     } catch (std::exception &e) {
+      bearStatus.listenerDataSetSuccess = BearStatusStates::FAILED;
+      bearStatus.listenerDataSetErrorDesc = e.what();
       bearRenderer.reset();
-      assert(false);
     }
   } catch (std::exception &e) {
+    bearStatus.startupSuccess = BearStatusStates::FAILED;
+    bearStatus.startupErrorDesc = e.what();
     bearRenderer.reset();
-    assert(false);
   }
 }
 
@@ -218,6 +224,7 @@ bool BinauralMonitoringAudioProcessor::updateChannelCounts(
     // Do immediate update
     bearRenderer->set_config_blocking(bearConfig);
   }
+  return true;
 }
 
 }  // namespace plugin
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/CMakeLists.txt b/ear-production-suite-plugins/plugins/binaural_monitoring/CMakeLists.txt
index cbc415d01..0d949db80 100644
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/CMakeLists.txt
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/CMakeLists.txt
@@ -3,14 +3,16 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 set(SOURCES_BINAURAL_MONITORING
-    ${EPS_SHARED_DIR}/binary_data.cpp
-    ${EPS_SHARED_DIR}/components/look_and_feel/slider.cpp
-    ${EPS_SHARED_DIR}/components/ear_header.cpp
-    ${EPS_SHARED_DIR}/components/ear_slider_label.cpp
-    ${EPS_SHARED_DIR}/components/level_meter_calculator.cpp
+	${EPS_SHARED_DIR}/binary_data.cpp
+	${EPS_SHARED_DIR}/components/look_and_feel/slider.cpp
+	${EPS_SHARED_DIR}/components/ear_combo_box.cpp
+	${EPS_SHARED_DIR}/components/ear_header.cpp
+	${EPS_SHARED_DIR}/components/ear_slider_label.cpp
+	${EPS_SHARED_DIR}/components/level_meter_calculator.cpp
 	src/binaural_monitoring_frontend_connector.cpp
-    src/binaural_monitoring_plugin_editor.cpp
-    src/binaural_monitoring_plugin_processor.cpp
+	src/binaural_monitoring_plugin_editor.cpp
+	src/binaural_monitoring_plugin_processor.cpp
+	src/bear_data_files.cpp
 	src/orientation_osc.cpp
 )
 
@@ -25,6 +27,7 @@ set(HEADERS_BINAURAL_MONITORING
 	${EPS_SHARED_DIR}/binary_data.hpp
 	
 	${EPS_SHARED_DIR}/components/ear_button.hpp
+	${EPS_SHARED_DIR}/components/ear_combo_box.hpp
 	${EPS_SHARED_DIR}/components/ear_header.hpp
 	${EPS_SHARED_DIR}/components/ear_inverted_slider.hpp
 	${EPS_SHARED_DIR}/components/ear_slider.hpp
@@ -47,10 +50,11 @@ set(HEADERS_BINAURAL_MONITORING
 	src/binaural_monitoring_frontend_connector.hpp
 	src/binaural_monitoring_plugin_editor.hpp
 	src/binaural_monitoring_plugin_processor.hpp
-	src/error_overlay.hpp
+	src/bear_data_files.hpp
 	src/headphone_channel_meter.hpp
 	src/headphone_channel_meter_box.hpp
 	src/orientation_osc.hpp
+	src/value_box_data_file.hpp
 	src/value_box_orientation.hpp
 	src/value_box_osc.hpp
 )
@@ -60,7 +64,7 @@ source_group("Header Files" FILES ${HEADERS_BINAURAL_MONITORING})
 add_juce_vst3_plugin(
 	ear_binaural_monitoring
 	SOURCES ${SOURCES_BINAURAL_MONITORING} ${HEADERS_BINAURAL_MONITORING}
-    IDE_FOLDER ${IDE_FOLDER_PLUGINS}
+	IDE_FOLDER ${IDE_FOLDER_PLUGINS}
 	CODE_SUFFIX "F0" # Speaker Monitoring suffixes start from A0 and increment. For bin, lets use F0 (Note FF is scene)
 	DISPLAY_NAME "EAR Binaural Monitoring"
 	DESCRIPTION "The binaural monitoring plugin"
@@ -81,7 +85,7 @@ if(APPLE)
 	add_custom_command(TARGET ear_binaural_monitoring_VST3 POST_BUILD
 		COMMAND ${CMAKE_COMMAND} -E copy ${TENSORFILE_FULLPATH} "$<TARGET_FILE_DIR:ear_binaural_monitoring_VST3>/../Resources/${TENSORFILE_FILENAME}"
 	)
-    install(FILES ${TENSORFILE_FULLPATH} DESTINATION "${EPS_PLUGIN_INSTALL_PREFIX}ear-production-suite/EAR Binaural Monitoring.vst3/Contents/Resources")
+	install(FILES ${TENSORFILE_FULLPATH} DESTINATION "${EPS_PLUGIN_INSTALL_PREFIX}ear-production-suite/EAR Binaural Monitoring.vst3/Contents/Resources")
 else()
 	add_custom_command(TARGET ear_binaural_monitoring_VST3 POST_BUILD
 		COMMAND ${CMAKE_COMMAND} -E copy ${TENSORFILE_FULLPATH} "$<TARGET_FILE_DIR:ear_binaural_monitoring_VST3>/${TENSORFILE_FILENAME}"
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/bear_data_files.cpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/bear_data_files.cpp
new file mode 100644
index 000000000..8b280089e
--- /dev/null
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/bear_data_files.cpp
@@ -0,0 +1,151 @@
+#include "bear_data_files.hpp"
+#include <bear/api.hpp>
+
+namespace {
+bool operator==(const ear::plugin::DataFileManager::DataFile& lhs,
+                const ear::plugin::DataFileManager::DataFile& rhs) {
+  return (lhs.filename == rhs.filename) && (lhs.fullPath == rhs.fullPath) &&
+         (lhs.isBearRelease == rhs.isBearRelease) && (lhs.label == rhs.label) &&
+         (lhs.description == rhs.description);
+}
+
+juce::File getBearDataFileDirectory() {
+  auto vstPath = juce::File::getSpecialLocation(
+      juce::File::SpecialLocationType::currentExecutableFile);
+  vstPath = vstPath.getParentDirectory();
+#ifdef __APPLE__
+  vstPath = vstPath.getParentDirectory();
+  vstPath = vstPath.getChildFile("Resources");
+#endif
+  return vstPath;
+};
+
+juce::File getCustomDataFileDirectory() {
+  auto vstPath = juce::File::getSpecialLocation(
+      juce::File::SpecialLocationType::currentExecutableFile);
+  vstPath = vstPath.getParentDirectory();
+#ifdef __APPLE__
+  // vstPath is `EAR Binaural Monitoring.vst3/Contents/MacOS` - traverse up x3 to get to dir containing vst3 bundle
+  vstPath = vstPath.getParentDirectory();
+  vstPath = vstPath.getParentDirectory();
+  vstPath = vstPath.getParentDirectory();
+#endif
+  return vstPath;
+};
+
+}
+
+namespace ear {
+namespace plugin {
+
+DataFileManager::DataFileManager() {
+  bearReleaseFiles_.add(
+      getBearDataFileDirectory().getChildFile(BEAR_DATA_FILE));
+  updateAvailableFiles();
+}
+
+void DataFileManager::updateAvailableFiles() {
+  // Start a new vec and copy existing shared_ptrs of unchanged files 
+  // This retains shared_ptrs unlike clear() and rebuild
+  std::vector<std::shared_ptr<DataFileManager::DataFile>> dfs;
+  // Lookup tfs where we expect to find custom files
+  auto files = getCustomDataFileDirectory().findChildFiles(
+      juce::File::TypesOfFileToFind::findFiles,
+                                    false, "*.tf");
+  // add our expected released files
+  for(auto const& bearReleaseFile : bearReleaseFiles_) {
+    if (bearReleaseFile.existsAsFile()) {
+      // note that in win, the released bear dir is the same as the custom
+      // dir, so we might have already found this with findChildFiles
+      files.addIfNotAlreadyThere(bearReleaseFile);
+    }
+  }
+  for (const auto& file : files) {
+    auto newDf = std::make_shared<DataFile>();
+    newDf->fullPath = file;
+    newDf->filename = file.getFileName();
+    try {
+      auto md = bear::DataFileMetadata::read_from_file(
+          file.getFullPathName().toStdString());
+      if (md.has_metadata()) {
+        newDf->label = md.get_label();
+        newDf->description = md.get_description();
+        newDf->isBearRelease = md.is_released();
+      }
+    } catch (std::exception) {
+    }
+    // Use the existing struct where possible (exists and is identical)
+    // -- this retains the same inst and shared_ptr
+    auto existingDf = getDataFileInfo(file.getFileName());
+    if (existingDf && *existingDf == *newDf) {
+      dfs.push_back(existingDf);
+    } else {
+      dfs.push_back(newDf);
+    }
+  }
+  availableDataFiles_ = dfs;
+}
+
+std::shared_ptr<DataFileManager::DataFile>
+DataFileManager::getSelectedDataFileInfo() {
+  return selectedDataFile_;
+}
+
+std::vector<std::shared_ptr<DataFileManager::DataFile>>
+DataFileManager::getAvailableDataFiles() {
+  return availableDataFiles_;
+}
+
+int DataFileManager::getAvailableDataFilesCount() {
+  return availableDataFiles_.size();
+}
+
+bool DataFileManager::setSelectedDataFile(const juce::String& fullPath) {
+  return setSelectedDataFile(juce::File(fullPath));
+}
+
+bool DataFileManager::setSelectedDataFile(const juce::File& fullPath) {
+  auto found = getDataFileInfo(fullPath);
+  if (found == nullptr) return false;
+  if (found != selectedDataFile_) {
+    selectedDataFile_ = found;
+    if (selectedDataFileChangeCallback_) {
+      selectedDataFileChangeCallback_(selectedDataFile_);
+    }
+  }
+  return true;
+}
+
+bool DataFileManager::setSelectedDataFileDefault() { 
+  updateAvailableFiles();
+  // look for any released by order
+  for (auto const& bearReleaseFile : bearReleaseFiles_) {
+    if (setSelectedDataFile(bearReleaseFile)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+std::shared_ptr<DataFileManager::DataFile> DataFileManager::getDataFileInfo(
+    const juce::String& fullPath) {
+  return getDataFileInfo(juce::File(fullPath));
+}
+
+std::shared_ptr<DataFileManager::DataFile> DataFileManager::getDataFileInfo(
+    const juce::File& fullPath) {
+  auto it = std::find_if(availableDataFiles_.begin(), availableDataFiles_.end(),
+                         [&fullPath](const std::shared_ptr<DataFile>& elm) {
+                           return elm->fullPath == fullPath;
+                         });
+
+  return it == availableDataFiles_.end() ? nullptr : *it;
+}
+
+void DataFileManager::onSelectedDataFileChange(
+    std::function<void(std::shared_ptr<DataFile>)> callback) {
+  selectedDataFileChangeCallback_ = callback;
+}
+
+}  // namespace plugin
+}  // namespace ear
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/bear_data_files.hpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/bear_data_files.hpp
new file mode 100644
index 000000000..9528a4340
--- /dev/null
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/bear_data_files.hpp
@@ -0,0 +1,43 @@
+#pragma once
+#include "JuceHeader.h"
+#include <memory>
+#include <vector>
+#include <functional>
+
+namespace ear {
+namespace plugin {
+
+class DataFileManager {
+ public:
+  DataFileManager();
+
+  struct DataFile {
+    juce::String filename;
+    juce::File fullPath;
+    juce::String label;
+    juce::String description;
+    bool isBearRelease{false};
+  };
+
+  void updateAvailableFiles();
+  std::shared_ptr<DataFile> getSelectedDataFileInfo();
+  std::vector<std::shared_ptr<DataFile>> getAvailableDataFiles();
+  int getAvailableDataFilesCount();
+  bool setSelectedDataFile(const juce::String& fullPath);
+  bool setSelectedDataFile(const juce::File& fullPath);
+  bool setSelectedDataFileDefault();
+  std::shared_ptr<DataFile> getDataFileInfo(const juce::String& fullPath);
+  std::shared_ptr<DataFile> getDataFileInfo(const juce::File& fullPath);
+  void onSelectedDataFileChange(
+      std::function<void(std::shared_ptr<DataFile>)> callback);
+
+ private:
+  juce::Array<juce::File> bearReleaseFiles_;
+  std::shared_ptr<DataFile> selectedDataFile_;
+  std::vector<std::shared_ptr<DataFile>> availableDataFiles_;
+  std::function<void(std::shared_ptr<DataFile>)> selectedDataFileChangeCallback_;
+};
+
+}  // namespace plugin
+}
+
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.cpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.cpp
index 662f835a8..381f50685 100644
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.cpp
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.cpp
@@ -4,6 +4,18 @@
 #include "components/ear_inverted_slider.hpp"
 #include "detail/weak_ptr_helpers.hpp"
 
+#include <algorithm>
+#include <cassert>
+
+namespace {
+void removePath(std::string& filePath) {
+  // Find the last occurrence of forward slash or backslash
+  size_t lastSlash = filePath.find_last_of("/\\");
+  if (lastSlash != std::string::npos) {
+    filePath = filePath.substr(lastSlash + 1);
+  }
+}
+}
 
 namespace ear {
 namespace plugin {
@@ -172,6 +184,68 @@ void BinauralMonitoringJuceFrontendConnector::setOscInvertQuatZButton(
   setOscInvertQuatZ(cachedOscInvertQuatZ_);
 }
 
+void BinauralMonitoringJuceFrontendConnector::setDataFileComponent(
+    std::shared_ptr<Component> comp) {
+  dataFileComponent_ = comp;
+  p_->dataFileManager.updateAvailableFiles();
+  auto dfs = p_->dataFileManager.getAvailableDataFiles();
+  auto df = p_->dataFileManager.getSelectedDataFileInfo();
+  if (dfs.size() == 1 && df && dfs[0] == df && df->isBearRelease) {
+    // Only 1 data file and it is a bear release. Don't show options.
+    comp->setVisible(false);
+  } else {
+    comp->setVisible(true);
+  }
+}
+
+void BinauralMonitoringJuceFrontendConnector::setDataFileComboBox(
+    std::shared_ptr<EarComboBox> comboBox) {
+  comboBox->addListener(this);
+  dataFileComboBox_ = comboBox;
+  p_->dataFileManager.updateAvailableFiles();
+  comboBox->clearEntries();
+  auto dfs = p_->dataFileManager.getAvailableDataFiles();
+  std::sort(
+      dfs.begin(), dfs.end(),
+      [](const std::shared_ptr<ear::plugin::DataFileManager::DataFile>& a,
+         const std::shared_ptr<ear::plugin::DataFileManager::DataFile>& b) {
+        if (a->isBearRelease != b->isBearRelease) {
+          return a->isBearRelease;
+        }
+        return a->filename.compareIgnoreCase(b->filename) < 0;
+      });
+  for (const auto& df : dfs) {
+    juce::String txt;
+    if (!df->isBearRelease) {
+      txt = "[CUSTOM]   ";
+    }
+    if (df->label.isEmpty()) {
+      // use filename - will be an unusual case in future
+      txt += df->filename;
+    } else {
+      txt += df->label;
+      txt += "   (" + df->filename + ")";
+    }
+    juce::StringArray subtexts;
+    if (!df->description.isEmpty()) {
+      subtexts.add(df->description);
+    }
+    subtexts.add(juce::String(df->fullPath.getFullPathName()));
+    auto entry = comboBox->addTextWithSubtextEntry(txt, subtexts, df->fullPath.getFullPathName());
+    entry->setLightFont(!df->isBearRelease);
+  }
+  if (auto df = p_->dataFileManager.getSelectedDataFileInfo()) {
+    comboBox->setSelectedId(df->fullPath.getFullPathName(),
+                            juce::NotificationType::dontSendNotification);
+  }
+}
+
+void BinauralMonitoringJuceFrontendConnector::setRendererStatusLabel(
+    std::shared_ptr<Label> label) {
+  rendererStatusLabel_ = label;
+  setRendererStatus(cachedBearStatusText_, cachedBearStatusColour_);
+}
+
 void BinauralMonitoringJuceFrontendConnector::setListenerOrientationInstance(
     std::shared_ptr<ListenerOrientation> lo) {
   listenerOrientation = lo;
@@ -280,6 +354,66 @@ void BinauralMonitoringJuceFrontendConnector::setOscInvertQuatZ(bool invert) {
   cachedOscInvertQuatZ_ = invert;
 }
 
+void BinauralMonitoringJuceFrontendConnector::setRendererStatus(
+    const ear::plugin::BearStatus& bearStatus) {
+
+  if (bearStatus.startupSuccess == BearStatusStates::SUCCEEDED) {
+    // Is running. See if accepting listener position data
+    if (bearStatus.listenerDataSetSuccess == BearStatusStates::FAILED) {
+      juce::String msg("Renderer did not accept listener orientation data: ");
+      msg += juce::String(bearStatus.listenerDataSetErrorDesc);
+      setRendererStatus(msg, ear::plugin::ui::EarColours::StatusWarning);
+    } else {
+      // Other states (good or insignificant) for listener data - BEAR is running
+      setRendererStatus("Running...", ear::plugin::ui::EarColours::Label);
+    }
+
+  } else if (bearStatus.startupSuccess == BearStatusStates::FAILED) {
+    juce::String msg("Renderer startup failed: ");
+    msg += juce::String(bearStatus.startupErrorDesc) + " (";
+    auto dataFile = bearStatus.startupConfig.get_data_path();
+    removePath(dataFile);
+    msg += juce::String(dataFile) + ").";
+    setRendererStatus(msg, ear::plugin::ui::EarColours::StatusBad);
+
+  } else if (bearStatus.startupSuccess == BearStatusStates::NOT_ATTEMPTED) {
+    // Unusual case - we should always expect a start attempt (class init)
+    assert(false);
+    setRendererStatus("Renderer not started.",
+                      ear::plugin::ui::EarColours::StatusWarning);
+
+  } else {
+    // Unimplemented case
+    assert(false);
+  }
+}
+
+void BinauralMonitoringJuceFrontendConnector::setRendererStatus(
+    const juce::String& statusText, const juce::Colour& statusColour) {
+  if (auto rendererStatusLabelLocked = rendererStatusLabel_.lock()) {
+    rendererStatusLabelLocked->setColour(juce::Label::textColourId,
+                                         statusColour);
+    rendererStatusLabelLocked->setText(
+        statusText, juce::NotificationType::dontSendNotification);
+  }
+
+  cachedBearStatusText_ = statusText;
+  cachedBearStatusColour_ = statusColour;
+}
+
+void BinauralMonitoringJuceFrontendConnector::setRendererStatusRestarting() {
+  setRendererStatus(juce::String("Renderer starting..."),
+                    ear::plugin::ui::EarColours::Label);
+}
+
+void BinauralMonitoringJuceFrontendConnector::setDataFile(
+    const juce::String& dataFile) {
+  if (auto cbLocked = dataFileComboBox_.lock()) {
+    cbLocked->setSelectedId(dataFile, dontSendNotification);
+  }
+  p_->dataFileManager.setSelectedDataFile(dataFile); // fires callback to restart bear
+}
+
 void BinauralMonitoringJuceFrontendConnector::orientationChange(
     ear::plugin::ListenerOrientation::Euler euler) {
   // ListenerOrientation callback from backend
@@ -306,6 +440,14 @@ void BinauralMonitoringJuceFrontendConnector::orientationChange(
   });
 }
 
+void BinauralMonitoringJuceFrontendConnector::comboBoxChanged(
+    EarComboBox* comboBoxThatHasChanged) {
+  if (auto comboBox =
+          lockIfSame(dataFileComboBox_, comboBoxThatHasChanged)) {
+    setDataFile(comboBox->getSelectedId());
+  }
+}
+
 void BinauralMonitoringJuceFrontendConnector::parameterValueChanged(
     int parameterIndex, float newValue) {
   // Parameter change callback from JUCE Processor
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.hpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.hpp
index e5ceb4316..95519cf0d 100644
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.hpp
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_frontend_connector.hpp
@@ -5,10 +5,12 @@
 
 #include "components/orientation.hpp"
 #include "components/ear_button.hpp"
+#include "components/ear_combo_box.hpp"
 #include "components/ear_slider.hpp"
 #include "helper/multi_async_updater.h"
 
 #include "binaural_monitoring_plugin_processor.hpp"
+#include "binaural_monitoring_audio_processor.hpp"
 #include <memory>
 
 namespace ear {
@@ -20,6 +22,7 @@ class BinauralMonitoringJuceFrontendConnector
       private AudioProcessorParameter::Listener,
       Slider::Listener,
       Button::Listener,
+      ear::plugin::ui::EarComboBox::Listener,
       ear::plugin::ui::OrientationView::Listener,
       ear::plugin::ListenerOrientation::EulerListener {
  public:
@@ -52,6 +55,11 @@ class BinauralMonitoringJuceFrontendConnector
   void setOscInvertQuatYButton(std::shared_ptr<ToggleButton> button);
   void setOscInvertQuatZButton(std::shared_ptr<ToggleButton> button);
 
+  // Renderer status and Data File selection controls
+  void setDataFileComponent(std::shared_ptr<Component> comp);
+  void setDataFileComboBox(std::shared_ptr<EarComboBox> comboBox);
+  void setRendererStatusLabel(std::shared_ptr<Label> label);
+
   // Listener Orientation Object
   void setListenerOrientationInstance(std::shared_ptr<ListenerOrientation> lo);
 
@@ -72,6 +80,13 @@ class BinauralMonitoringJuceFrontendConnector
   void setOscInvertQuatY(bool invert);
   void setOscInvertQuatZ(bool invert);
 
+  // Renderer status and Data File setters
+  void setRendererStatus(const ear::plugin::BearStatus& bearStatus);
+  void setRendererStatus(const juce::String& statusText,
+                         const juce::Colour& statusColour);
+  void setRendererStatusRestarting();
+  void setDataFile(const juce::String& dataFile);
+
  protected:
   // Orientation::Listener
   void orientationValueChanged(ear::plugin::ui::OrientationView* view) override;
@@ -90,6 +105,9 @@ class BinauralMonitoringJuceFrontendConnector
   void orientationChange(
       ear::plugin::ListenerOrientation::Euler euler) override;
 
+  // EarComboBox::Listener
+  void comboBoxChanged(EarComboBox* comboBoxThatHasChanged) override;
+
  private:
   EarBinauralMonitoringAudioProcessor* p_;
   std::map<int, RangedAudioParameter*> parameters_;
@@ -112,6 +130,11 @@ class BinauralMonitoringJuceFrontendConnector
   std::weak_ptr<ToggleButton> oscInvertQuatYButton_;
   std::weak_ptr<ToggleButton> oscInvertQuatZButton_;
 
+  // Renderer status and Data File UI components
+  std::weak_ptr<Component> dataFileComponent_;
+  std::weak_ptr<EarComboBox> dataFileComboBox_;
+  std::weak_ptr<Label> rendererStatusLabel_;
+
   // Values
   bool cachedOscEnable_;
   int cachedOscPort_;
@@ -122,6 +145,8 @@ class BinauralMonitoringJuceFrontendConnector
   bool cachedOscInvertQuatX_;
   bool cachedOscInvertQuatY_;
   bool cachedOscInvertQuatZ_;
+  juce::String cachedBearStatusText_;
+  juce::Colour cachedBearStatusColour_;
 
   /// Listener Orientation Object
   std::shared_ptr<ListenerOrientation> listenerOrientation;
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.cpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.cpp
index b1b295d26..a84f55707 100644
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.cpp
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.cpp
@@ -19,13 +19,13 @@ EarBinauralMonitoringAudioProcessorEditor::
         EarBinauralMonitoringAudioProcessor* p)
     : AudioProcessorEditor(p),
       p_(p),
+      dataFileValueBox(std::make_shared<ValueBoxDataFile>()),
       oscValueBox(std::make_unique<ValueBoxOsc>()),
       orientationValueBox(std::make_unique<ValueBoxOrientation>()),
       header_(std::make_unique<EarHeader>()),
       onBoardingButton_(std::make_unique<EarButton>()),
       onBoardingOverlay_(std::make_unique<Overlay>()),
       onBoardingContent_(std::make_unique<Onboarding>()),
-      errorOverlay_(std::make_shared<BinauralRendererErrorOverlay>()),
       headphoneMeterBox_(std::make_unique<HeadphoneChannelMeterBox>(
           String::fromUTF8("Output"))),
       propertiesFileLock_(
@@ -68,7 +68,19 @@ EarBinauralMonitoringAudioProcessorEditor::
   configureVersionLabel(versionLabel);
   addAndMakeVisible(versionLabel);
 
+  statusLabel = std::make_shared<Label>();
+  statusLabel->setColour(juce::Label::textColourId, ear::plugin::ui::EarColours::Version);
+  statusLabel->setText("Status", juce::NotificationType::dontSendNotification);
+  statusLabel->setFont(ear::plugin::ui::EarFontsSingleton::instance().Version);
+  statusLabel->setJustificationType(juce::Justification::left);
+  statusLabel->setEditable(false);
+  addAndMakeVisible(statusLabel.get());
+  addChildComponent(dataFileValueBox.get());
+
   /* clang-format off */
+  p->getFrontendConnector()->setRendererStatusLabel(statusLabel);
+  p->getFrontendConnector()->setDataFileComponent(dataFileValueBox);
+  p->getFrontendConnector()->setDataFileComboBox(dataFileValueBox->getDataFileComboBox());
   p->getFrontendConnector()->setYawView(orientationValueBox->getYawControl());
   p->getFrontendConnector()->setPitchView(orientationValueBox->getPitchControl());
   p->getFrontendConnector()->setRollView(orientationValueBox->getRollControl());
@@ -85,7 +97,6 @@ EarBinauralMonitoringAudioProcessorEditor::
 
   addAndMakeVisible(orientationValueBox.get());
   addAndMakeVisible(oscValueBox.get());
-  addChildComponent(errorOverlay_.get());
 
   oscValueBox->getPortControl()->setValue(p->getOscPort()->get(),
                                           dontSendNotification);
@@ -132,9 +143,7 @@ void EarBinauralMonitoringAudioProcessorEditor::paint(Graphics& g) {
 void EarBinauralMonitoringAudioProcessorEditor::resized() {
   auto area = getLocalBounds();
   onBoardingOverlay_->setBounds(area);
-  errorOverlay_->setBounds(area);
-  auto p = static_cast<EarBinauralMonitoringAudioProcessor*>(p_);
-  errorOverlay_->setVisible(p->rendererError());
+
   area.reduce(5, 5);
   auto headingArea = area.removeFromTop(55);
   onBoardingButton_->setBounds(
@@ -143,6 +152,10 @@ void EarBinauralMonitoringAudioProcessorEditor::resized() {
 
   area.removeFromTop(10);  // Padding between header and content
 
+  if(dataFileValueBox->isVisible()){ 
+    dataFileValueBox->setBounds(area.removeFromTop(60).reduced(5, 5));
+  }
+
   auto body = area.removeFromTop(390);
   // All content to go below and to be fitted within `area`
   auto leftColumn = body.removeFromLeft(145);
@@ -161,8 +174,9 @@ void EarBinauralMonitoringAudioProcessorEditor::resized() {
   orientationValueBox->setBounds(rightColumn.removeFromTop(300).reduced(5, 5));
   oscValueBox->setBounds(rightColumn.reduced(5, 5));
 
-  auto bottomLabelsArea = area.removeFromTop(30);
-  versionLabel.setBounds(bottomLabelsArea);
+  auto footerArea = area.removeFromTop(30);
+  versionLabel.setBounds(footerArea.removeFromRight(150));
+  statusLabel->setBounds(footerArea);
 }
 
 void EarBinauralMonitoringAudioProcessorEditor::endButtonClicked(
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.hpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.hpp
index ccde9958b..13b55f86a 100644
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.hpp
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_editor.hpp
@@ -12,7 +12,7 @@
 #include "headphone_channel_meter_box.hpp"
 #include "value_box_orientation.hpp"
 #include "value_box_osc.hpp"
-#include "error_overlay.hpp"
+#include "value_box_data_file.hpp"
 
 class EarBinauralMonitoringAudioProcessorEditor
     : public AudioProcessorEditor,
@@ -27,6 +27,7 @@ class EarBinauralMonitoringAudioProcessorEditor
 
   std::unique_ptr<ear::plugin::ui::ValueBoxOrientation> orientationValueBox;
   std::unique_ptr<ear::plugin::ui::ValueBoxOsc> oscValueBox;
+  std::shared_ptr<ear::plugin::ui::ValueBoxDataFile> dataFileValueBox;
 
  private:
   EarBinauralMonitoringAudioProcessor* p_;
@@ -35,7 +36,7 @@ class EarBinauralMonitoringAudioProcessorEditor
   std::unique_ptr<ear::plugin::ui::EarButton> onBoardingButton_;
   std::unique_ptr<ear::plugin::ui::Overlay> onBoardingOverlay_;
   std::unique_ptr<ear::plugin::ui::Onboarding> onBoardingContent_;
-  std::shared_ptr<ear::plugin::ui::BinauralRendererErrorOverlay> errorOverlay_;
+  std::shared_ptr<Label> statusLabel;
 
   std::unique_ptr<ear::plugin::ui::HeadphoneChannelMeterBox> headphoneMeterBox_;
   std::vector<std::unique_ptr<ear::plugin::ui::HeadphoneChannelMeter>>
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.cpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.cpp
index 429e61026..68d02e014 100644
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.cpp
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.cpp
@@ -46,6 +46,12 @@ using namespace ear::plugin;
 //==============================================================================
 EarBinauralMonitoringAudioProcessor::EarBinauralMonitoringAudioProcessor()
     : AudioProcessor(_getBusProperties()) {
+
+  dataFileManager.onSelectedDataFileChange(
+      [this](std::shared_ptr<ear::plugin::DataFileManager::DataFile> df) {
+        writeConfigFile();
+        restartBearProcessor();
+      });
   levelMeter_ = std::make_shared<ear::plugin::LevelMeterCalculator>(0, 0);
 
   /* clang-format off */
@@ -128,16 +134,6 @@ EarBinauralMonitoringAudioProcessor::EarBinauralMonitoringAudioProcessor()
   connector_->parameterValueChanged(11, oscInvertQuatY_->get());
   connector_->parameterValueChanged(12, oscInvertQuatZ_->get());
 
-  auto vstPath = juce::File::getSpecialLocation(
-      juce::File::SpecialLocationType::currentExecutableFile);
-  vstPath = vstPath.getParentDirectory();
-#ifdef __APPLE__
-  vstPath = vstPath.getParentDirectory();
-  vstPath = vstPath.getChildFile("Resources");
-#endif
-  vstPath = vstPath.getChildFile(BEAR_DATA_FILE);
-  bearDataFilePath = vstPath.getFullPathName().toStdString();
-
   oscReceiver.onReceiveEuler = [this](ListenerOrientation::Euler euler) {
     connector_->setEuler(euler);
   };
@@ -157,28 +153,15 @@ EarBinauralMonitoringAudioProcessor::EarBinauralMonitoringAudioProcessor()
   oscInvertQuatY_->addListener(this);
   oscInvertQuatZ_->addListener(this);
 
-  std::lock_guard<std::mutex> lock(processorMutex_);
-  processor_ = std::make_unique<ear::plugin::BinauralMonitoringAudioProcessor>(
-      MAX_DAW_CHANNELS, MAX_DAW_CHANNELS, MAX_DAW_CHANNELS, 48000, 512,
-      bearDataFilePath);  // Used to verify if BEAR can be initialised - can't
-                          // get SR and block size in ctor. Made assumption -
-                          // prepareToPlay will be called with correct values
-                          // when required
-
   configFileOptions.applicationName = ProjectInfo::projectName;
   configFileOptions.filenameSuffix = ".settings";
   configFileOptions.folderName = ResourcePaths::getSettingsDirectory(true).getFullPathName();
   configFileOptions.storageFormat = PropertiesFile::storeAsXML;
-  readConfigFile();
+  readConfigFile(); // This will fire up the processor too because of data file change.
 }
 
 EarBinauralMonitoringAudioProcessor::~EarBinauralMonitoringAudioProcessor() {}
 
-bool EarBinauralMonitoringAudioProcessor::rendererError() {
-  std::lock_guard<std::mutex> lock(processorMutex_);
-  return (!processor_ || processor_->rendererError());
-}
-
 void EarBinauralMonitoringAudioProcessor::parameterValueChanged(
   int parameterIndex, float newValue) {
   if(parameterIndex >= 4 && parameterIndex <= 12) {
@@ -222,12 +205,34 @@ EarBinauralMonitoringAudioProcessor::_getBusProperties() {
       "Input", AudioChannelSet::discreteChannels(MAX_DAW_CHANNELS), true);
   ret = ret.withOutput("Left Ear", AudioChannelSet::mono(), true);
   ret = ret.withOutput("Right Ear", AudioChannelSet::mono(), true);
-  ret = ret.withOutput("(Unused)", AudioChannelSet::discreteChannels(62), true);
+  ret = ret.withOutput("(Unused)", AudioChannelSet::discreteChannels(MAX_DAW_CHANNELS-2), true);
   return ret;
 }
 
-bool EarBinauralMonitoringAudioProcessor::readConfigFile()
-{
+void EarBinauralMonitoringAudioProcessor::restartBearProcessor(
+    bool onlyOnConfigChange) {
+  std::lock_guard<std::mutex> lock(processorMutex_);
+  if (!onlyOnConfigChange || !processor_ ||
+      !processor_->configMatches(samplerate_, blocksize_)) {
+    auto bearDataFile = dataFileManager.getSelectedDataFileInfo();
+    std::string dataFilePath;
+    if (bearDataFile) {
+      dataFilePath = bearDataFile->fullPath.getFullPathName().toStdString();
+    }
+    if (connector_) {
+      connector_->setRendererStatusRestarting();
+    }
+    processor_ =
+        std::make_unique<ear::plugin::BinauralMonitoringAudioProcessor>(
+            MAX_DAW_CHANNELS, MAX_DAW_CHANNELS, MAX_DAW_CHANNELS, samplerate_,
+            blocksize_, dataFilePath);
+    if (connector_) {
+      connector_->setRendererStatus(processor_->getBearStatus());
+    }
+  }
+}
+
+bool EarBinauralMonitoringAudioProcessor::readConfigFile() {
   configRestoreState = ConfigRestoreState::IN_PROGRESS;
   PropertiesFile props(configFileOptions);
   // reload() check alone isn't sufficient - returns true if file didn't exist
@@ -241,8 +246,15 @@ bool EarBinauralMonitoringAudioProcessor::readConfigFile()
     *oscInvertQuatX_ = props.getBoolValue("oscInvertQuatX", false);
     *oscInvertQuatY_ = props.getBoolValue("oscInvertQuatY", false);
     *oscInvertQuatZ_ = props.getBoolValue("oscInvertQuatZ", false);
+    auto selectedDataFile = props.getValue("bearPreferredDataFile");
+    if (selectedDataFile.isEmpty() ||
+        !dataFileManager.setSelectedDataFile(selectedDataFile)) {
+      dataFileManager.setSelectedDataFileDefault();
+    }
     configRestoreState = ConfigRestoreState::RESTORED;
     return true;
+  } else {
+      dataFileManager.setSelectedDataFileDefault();
   }
   configRestoreState = ConfigRestoreState::NOT_RESTORED;
   return false;
@@ -262,6 +274,9 @@ bool EarBinauralMonitoringAudioProcessor::writeConfigFile()
   props.setValue("oscInvertQuatX", (bool)*oscInvertQuatX_);
   props.setValue("oscInvertQuatY", (bool)*oscInvertQuatY_);
   props.setValue("oscInvertQuatZ", (bool)*oscInvertQuatZ_);
+  if (auto selectedDataFile = dataFileManager.getSelectedDataFileInfo()) {
+    props.setValue("bearPreferredDataFile", selectedDataFile->fullPath.getFullPathName());
+  }
   return props.save();
 }
 
@@ -301,17 +316,8 @@ void EarBinauralMonitoringAudioProcessor::prepareToPlay(double sampleRate,
                                                         int samplesPerBlock) {
   samplerate_ = sampleRate;
   blocksize_ = samplesPerBlock;
-
   levelMeter_->setup(2, sampleRate);
-
-  std::lock_guard<std::mutex> lock(processorMutex_);
-  if (!processor_ || !processor_->configMatches(sampleRate, samplesPerBlock)) {
-    processor_ =
-        std::make_unique<ear::plugin::BinauralMonitoringAudioProcessor>(
-            MAX_DAW_CHANNELS, MAX_DAW_CHANNELS, MAX_DAW_CHANNELS, 
-            sampleRate, samplesPerBlock,
-            bearDataFilePath);
-  }
+  restartBearProcessor(true);
 }
 
 void EarBinauralMonitoringAudioProcessor::releaseResources() {
@@ -336,7 +342,8 @@ bool EarBinauralMonitoringAudioProcessor::isBusesLayoutSupported(
     return false;
   if(layouts.outputBuses[1] != AudioChannelSet::mono())
     return false;
-  if(layouts.outputBuses[2] != AudioChannelSet::discreteChannels(62))
+  if (layouts.outputBuses[2] !=
+      AudioChannelSet::discreteChannels(MAX_DAW_CHANNELS - 2))
     return false;
 
   return true;
@@ -370,6 +377,13 @@ void EarBinauralMonitoringAudioProcessor::processBlock(
 
   {
     std::lock_guard<std::mutex> lock(processorMutex_);
+
+    // Check BEAR has started - if not, we still want to zero output to make problem obvious
+    if (!processor_ || !processor_->rendererStarted()) {
+      buffer.clear();
+      return;
+    }
+
     processor_->setIsPlaying(true);
 
     auto objIds = backend_->getActiveObjectIds();
@@ -380,15 +394,13 @@ void EarBinauralMonitoringAudioProcessor::processBlock(
     size_t numObj = backend_->getTotalObjectChannels();
     size_t numDs = backend_->getTotalDirectSpeakersChannels();
 
-    // Ensure BEAR has enough channels configured and is not erroring
-    if(!processor_ || processor_->rendererError()) return;
+    // Check BEAR has enough channels configured
     if(!processor_->updateChannelCounts(numObj, numDs, numHoa)) {
       assert(false);
       return;
     }
 
     // Listener Position
-
     auto latestQuat = backend_->listenerOrientation->getQuaternion();
     processor_->setListenerOrientation(latestQuat.w, latestQuat.x, latestQuat.y,
                                        latestQuat.z);
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.hpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.hpp
index 8b17f928b..311b042ee 100644
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.hpp
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/binaural_monitoring_plugin_processor.hpp
@@ -9,6 +9,7 @@
 
 #include "components/level_meter_calculator.hpp"
 
+#include "bear_data_files.hpp"
 #include "orientation_osc.hpp"
 
 namespace ear {
@@ -83,7 +84,7 @@ class EarBinauralMonitoringAudioProcessor
     return connector_.get();
   }
 
-  bool rendererError();
+  ear::plugin::DataFileManager dataFileManager;
 
  protected:
   void parameterValueChanged(int parameterIndex, float newValue) override;
@@ -114,10 +115,10 @@ class EarBinauralMonitoringAudioProcessor
   std::unique_ptr<ear::plugin::BinauralMonitoringBackend> backend_;
   std::mutex processorMutex_;  // used to prevent access during (re)construction
   std::unique_ptr<ear::plugin::BinauralMonitoringAudioProcessor> processor_;
-  std::string bearDataFilePath;
+  void restartBearProcessor(bool onlyOnConfigChange = false);
 
-  int samplerate_;
-  int blocksize_;
+  int samplerate_{48000};
+  int blocksize_{512};
 
   std::shared_ptr<ear::plugin::LevelMeterCalculator> levelMeter_;
 
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/error_overlay.hpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/error_overlay.hpp
deleted file mode 100644
index 8532ba97d..000000000
--- a/ear-production-suite-plugins/plugins/binaural_monitoring/src/error_overlay.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "JuceHeader.h"
-
-#include "../../shared/components/look_and_feel/colours.hpp"
-#include "../../shared/components/look_and_feel/fonts.hpp"
-#include "../../shared/components/look_and_feel/shadows.hpp"
-
-#include <memory>
-
-namespace ear {
-namespace plugin {
-namespace ui {
-
-class BinauralRendererErrorOverlay : public Component {
- public:
-   BinauralRendererErrorOverlay() {}
-
-  void paint(Graphics& g) override {
-    auto area = getLocalBounds();
-
-    g.fillAll(EarColours::Background);
-    Shadows::elevation01dp.drawForRectangle(g, area.reduced(100, 100));
-    g.setColour(EarColours::Background.overlaidWith(EarColours::Area01dp));
-    g.fillRect(area.reduced(100, 100));
-    g.setColour(EarColours::Error.withAlpha(Emphasis::high));
-    g.drawRect(area.reduced(100, 100), 2.f);
-
-    g.setColour(EarColours::Text.withAlpha(Emphasis::high));
-    g.setFont(font::RobotoSingleton::instance().getMedium(35.f));
-    g.drawText(String::fromUTF8("Failed to initialize Binaural Renderer."),
-               area, Justification::centred);
-  }
-
- private:
-  JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(BinauralRendererErrorOverlay)
-};
-
-}  // namespace ui
-}  // namespace plugin
-}  // namespace ear
diff --git a/ear-production-suite-plugins/plugins/binaural_monitoring/src/value_box_data_file.hpp b/ear-production-suite-plugins/plugins/binaural_monitoring/src/value_box_data_file.hpp
new file mode 100644
index 000000000..c8a74feb6
--- /dev/null
+++ b/ear-production-suite-plugins/plugins/binaural_monitoring/src/value_box_data_file.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "JuceHeader.h"
+
+#include "components/ear_combo_box.hpp"
+#include "components/look_and_feel/colours.hpp"
+#include "components/look_and_feel/fonts.hpp"
+
+#include <memory>
+
+namespace ear {
+namespace plugin {
+namespace ui {
+
+class ValueBoxDataFile : public Component {
+ public:
+  ValueBoxDataFile(){
+    label_.setFont(EarFontsSingleton::instance().Label);
+    label_.setColour(Label::textColourId, EarColours::Label);
+    label_.setText("HRTF Set:",
+                   juce::NotificationType::dontSendNotification);
+    label_.setJustificationType(Justification::left);
+    addAndMakeVisible(label_);
+
+    comboBox_ = std::make_shared<EarComboBox>();
+    comboBox_->setDefaultText("Select file...");
+    comboBox_->setCanClearSelection(false);
+    addAndMakeVisible(comboBox_.get());
+  }
+
+  void paint(Graphics& g) override { g.fillAll(EarColours::Area01dp); } 
+  
+  void resized() override {
+    auto area = getLocalBounds();
+    auto vPad = (area.getHeight() - rowHeight_) / 2;
+    if (vPad < 0) vPad = 0;
+    area.reduce(margin_, vPad);
+    label_.setBounds(area.removeFromLeft(labelWidth_));
+    comboBox_->setBounds(area);
+  }
+
+  std::shared_ptr<EarComboBox> getDataFileComboBox() { return comboBox_; }
+
+ private:
+  const float labelWidth_ = 85.f;
+  const float rowHeight_ = 30.f;
+  const float margin_ = 10.f;
+
+  Label label_;
+  std::shared_ptr<EarComboBox> comboBox_;
+
+  JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ValueBoxDataFile)
+};
+
+}  // namespace ui
+}  // namespace plugin
+}  // namespace ear
diff --git a/ear-production-suite-plugins/plugins/direct_speakers/src/direct_speakers_frontend_connector.cpp b/ear-production-suite-plugins/plugins/direct_speakers/src/direct_speakers_frontend_connector.cpp
index 277c15e40..1d82740d1 100644
--- a/ear-production-suite-plugins/plugins/direct_speakers/src/direct_speakers_frontend_connector.cpp
+++ b/ear-production-suite-plugins/plugins/direct_speakers/src/direct_speakers_frontend_connector.cpp
@@ -287,7 +287,8 @@ void DirectSpeakersJuceFrontendConnector::comboBoxChanged(
     EarComboBox* comboBox) {
   if (auto speakerSetupsComboBox = lockIfSame(speakerSetupsComboBox_, comboBox)) {
     if (speakerSetupsComboBox->hasSelection()) {
-      *(p_->getPackFormatIdValue()) = speakerSetupsComboBox->getSelectedId();
+      juce::var id = speakerSetupsComboBox->getSelectedId();
+      *(p_->getPackFormatIdValue()) = static_cast<int>(id);
     } else {
       *(p_->getPackFormatIdValue()) = 0;
     }
diff --git a/ear-production-suite-plugins/plugins/hoa/src/hoa_frontend_connector.cpp b/ear-production-suite-plugins/plugins/hoa/src/hoa_frontend_connector.cpp
index 7b4f47cdf..7cd9e0d94 100644
--- a/ear-production-suite-plugins/plugins/hoa/src/hoa_frontend_connector.cpp
+++ b/ear-production-suite-plugins/plugins/hoa/src/hoa_frontend_connector.cpp
@@ -245,7 +245,8 @@ void HoaJuceFrontendConnector::trackPropertiesChanged(
 void HoaJuceFrontendConnector::comboBoxChanged(EarComboBox* comboBox) {
   if(auto hoaTypeComboBox = lockIfSame(hoaTypeComboBox_, comboBox)) {
     if(hoaTypeComboBox->hasSelection()) {
-      *(p_->getPackFormatIdValue()) = hoaTypeComboBox->getSelectedId();
+      juce::var id = hoaTypeComboBox->getSelectedId();
+      *(p_->getPackFormatIdValue()) = static_cast<int>(id);
     } else {
       *(p_->getPackFormatIdValue()) = 0;
     }
diff --git a/ear-production-suite-plugins/plugins/scene/src/programmes_container.cpp b/ear-production-suite-plugins/plugins/scene/src/programmes_container.cpp
index 2c53ff794..c7bbb0037 100644
--- a/ear-production-suite-plugins/plugins/scene/src/programmes_container.cpp
+++ b/ear-production-suite-plugins/plugins/scene/src/programmes_container.cpp
@@ -220,7 +220,7 @@ void ProgrammesContainer::setProgrammeViewLanguage(const ProgrammeInternalId& pr
                                                    const std::optional<std::string>& language) {
   for(auto programme : programmes_) {
     if(programme->getProgrammeId() == progId) {
-      auto languageIndex = language? getLanguageIndex(*language) : -1;
+      int languageIndex = language? getLanguageIndex(*language) : -1;
       programme->getLanguageComboBox()->setSelectedId(languageIndex, NotificationType::dontSendNotification);
     }
   }
diff --git a/shared/components/ear_combo_box.cpp b/shared/components/ear_combo_box.cpp
index af64dd868..f00a351c5 100644
--- a/shared/components/ear_combo_box.cpp
+++ b/shared/components/ear_combo_box.cpp
@@ -7,11 +7,59 @@
 
 #include <vector>
 
+namespace {
+	void addWordwrappedLines(const juce::StringArray& srcArr, StringArray& dstArr, int width, const juce::Font& font) {
+		StringArray temp;
+		// Split array elms by existing new lines
+		for (auto const& str : srcArr) {
+			temp.addLines(str);
+		}
+		// For each line (elm in temp) iteratively find spaces and measure text size up to there.
+		// As soon as it exceeds "width", push the line before the word was added and begin again.
+		for (auto line : temp) {
+			int sp = 0;
+			while (sp < line.length()) {
+
+				int nextSp = line.indexOfChar(sp + 1, ' ');
+				if (nextSp < 0) {
+					// No more words - add what's left of the line.
+					dstArr.add(line);
+					break;
+				}
+
+				if (sp == 0) {
+					// Always allow the first word through, even if it is too long
+					// (JUCE will render it with trailing ellipsis anyway if it doesn't 
+					// fit given area, which is already a nice compromise)
+					sp = nextSp;
+					continue;
+				}
+
+				auto w = font.getStringWidth(line.substring(0, nextSp));
+				// If the line up to the next space would exceed the allowable width,
+				// take and store the section of line up to the last found space.
+				if (w > width) {
+					dstArr.add(line.substring(0, sp));
+					// Remove the stored section from the line being processed, inc 
+					// spaces at wrapping point. Reset space position and rerun. 
+					line = line.substring(sp).trimStart();
+					sp = 0;
+				}
+				else {
+					// Didn't exceed width up to nextSp
+					// Start from there next iteration
+					sp = nextSp;
+				}
+			}
+		}
+	}
+}
+
 namespace ear {
 namespace plugin {
 namespace ui {
 
-EarComboBoxEntry::EarComboBoxEntry(int id) : id_{ id } {
+EarComboBoxEntry::EarComboBoxEntry(const juce::var& id) : id_{ id } {
 	setColour(backgroundColourId, EarColours::Transparent);
 	setColour(selectedColourId, EarColours::ComboBoxPopupBackground);
 	setColour(highlightColourId, EarColours::Area04dp);
@@ -32,7 +80,7 @@ void EarComboBoxEntry::setHighlighted(bool highlighted) {
 	highlighted_ = highlighted;
 }
 
-int EarComboBoxEntry::getId() { return id_; }
+juce::var EarComboBoxEntry::getId() { return id_; }
 
 void EarComboBoxEntry::paint(Graphics& g) {
 	EarComboBoxPopup* popup = findParentComponentOfClass<EarComboBoxPopup>();
@@ -50,7 +98,15 @@ void EarComboBoxEntry::paint(Graphics& g) {
 	}
 }
 
-EarComboBoxTextEntry::EarComboBoxTextEntry(const String& text, int id)
+void EarComboBoxEntry::resizeForWidth(int width)
+{
+	// Default behaviour is default height unaffected by drawable width
+	// ... Do Nothing
+	// Inheritors can override this if (for example) multiline text is used
+	// and required height in a popup entry is affected by available width
+}
+
+EarComboBoxTextEntry::EarComboBoxTextEntry(const String& text, const juce::var& id)
 	: EarComboBoxEntry(id), text_(text) {
 	setColour(textColourId, EarColours::ComboBoxText);
 	// only necessary to set height -> width will be overwritten
@@ -81,7 +137,7 @@ void EarComboBoxTextEntry::drawEntryInList(Graphics& g,
 	else {
 		g.setFont(EarFontsSingleton::instance().Items);
 	}
-	g.drawText(text_, area.withTrimmedLeft(14).withTrimmedRight(14),
+	g.drawText(text_, area.withTrimmedLeft(padEntryText_).withTrimmedRight(padEntryText_),
 		Justification::left);
 }
 
@@ -89,11 +145,62 @@ void EarComboBoxTextEntry::drawEntryInButton(Graphics& g,
 	juce::Rectangle<int> area) {
 	g.setColour(findColour(textColourId));
 	g.setFont(EarFontsSingleton::instance().Items);
-	g.drawText(text_, area.withTrimmedLeft(14).withTrimmedRight(28),
+	g.drawText(text_, area.withTrimmedLeft(padEntryText_).withTrimmedRight(padEntryText_ * 2),
 		Justification::left);
 }
 
-EarComboBoxSectionEntry::EarComboBoxSectionEntry(const String& text, int id)
+EarComboBoxTextWithSubtextEntry::EarComboBoxTextWithSubtextEntry(const String& text, const StringArray& subtext, const juce::var& id)
+	: EarComboBoxTextEntry(text, id), originalSubtext_(subtext), structuredSubtext_(subtext){
+	resizeForWidth(getWidth());
+}
+
+EarComboBoxTextWithSubtextEntry::EarComboBoxTextWithSubtextEntry(const String& text, const String& subtext, const juce::var& id)
+	: EarComboBoxTextWithSubtextEntry(text, StringArray{ subtext }, id) {
+}
+
+void EarComboBoxTextWithSubtextEntry::setSubtext(const StringArray& text) {
+	originalSubtext_ = text; 
+	structuredSubtext_ = text;
+	structuredSubtextWidth_ = 0;
+	resizeForWidth(getWidth());
+}
+StringArray EarComboBoxTextWithSubtextEntry::getSubtext() const { return originalSubtext_; }
+
+void EarComboBoxTextWithSubtextEntry::resizeForWidth(int width)
+{
+	// Subtract expected line padding to get true available width
+	width -= padLeftListEntrySubtext_;
+	width -= padRightListEntrySubtext_;
+
+	// Calc req height
+	auto h = heightListEntryText_;
+	if (width != structuredSubtextWidth_) {
+		// structuredSubtext_ is for wrong width... 
+		// Regenerate from originalSubtext_ to fit `width`
+		structuredSubtext_.clear();
+		addWordwrappedLines(originalSubtext_, structuredSubtext_, width, EarFontsSingleton::instance().ItemsSubtext);
+		structuredSubtextWidth_ = width;
+	}
+	// Add height of all lines and set component height and width
+	h += structuredSubtext_.size() * heightListEntrySubtextLine_;
+	h += heightFinalPad_;
+	this->setSize(width, h);
+}
+
+void EarComboBoxTextWithSubtextEntry::drawEntryInList(Graphics& g, juce::Rectangle<int> area)
+{
+	auto textArea = area.removeFromTop(heightListEntryText_);
+	EarComboBoxTextEntry::drawEntryInList(g, textArea);
+	g.setColour(findColour(textColourId).withBrightness(0.75));
+	g.setFont(EarFontsSingleton::instance().ItemsSubtext);
+	for (auto const& line : structuredSubtext_) {
+		auto lineArea = area.removeFromTop(heightListEntrySubtextLine_);
+		g.drawText(line, lineArea.withTrimmedLeft(padLeftListEntrySubtext_).withTrimmedRight(padRightListEntrySubtext_),
+			Justification::left);
+	}
+}
+
+EarComboBoxSectionEntry::EarComboBoxSectionEntry(const String& text, const juce::var& id)
 	: EarComboBoxEntry(id), text_(text) {
 	setColour(textColourId, EarColours::ComboBoxText);
 	isSelectable_ = false;
@@ -119,7 +226,7 @@ void EarComboBoxSectionEntry::drawEntryInButton(Graphics& g,
 	drawEntryInList(g, area);
 }
 
-EarComboBoxColourEntry::EarComboBoxColourEntry(Colour colour, int id)
+EarComboBoxColourEntry::EarComboBoxColourEntry(Colour colour, const juce::var& id)
 	: EarComboBoxEntry(id), colour_(colour) {
 	setColour(backgroundColourId, EarColours::Transparent);
 	setColour(highlightColourId, EarColours::Area04dp);
@@ -222,6 +329,9 @@ void EarComboBoxPopup::show() {
 	}
 	parent_->addChildComponent(this);
 
+	for (std::unique_ptr<EarComboBoxEntry>& entry : entries_) {
+		entry->resizeForWidth(comboBox_->getWidth());
+	}
 	listView_->setSize(comboBox_->getWidth(), getHeightOfAllEntries());
 	auto listViewBounds = listView_->getLocalBounds();
 	listViewBounds.removeFromTop(padding_);
@@ -519,21 +629,34 @@ EarComboBoxEntry* EarComboBox::addEntry(std::unique_ptr<EarComboBoxEntry> entry)
 	return rawptr;
 }
 
-EarComboBoxTextEntry* EarComboBox::addTextEntry(const String& text, int id) {
+EarComboBoxTextEntry* EarComboBox::addTextEntry(const String& text, const juce::var& id) {
 	auto uptr = std::make_unique<EarComboBoxTextEntry>(text, id);
 	auto rawptr = uptr.get();
 	addEntry(std::move(uptr));
 	return rawptr;
 }
 
-EarComboBoxColourEntry* EarComboBox::addColourEntry(const Colour& colour, int id) {
+EarComboBoxTextEntry* EarComboBox::addTextWithSubtextEntry(const String& text, const String& subtext, const juce::var& id)
+{
+	return addTextWithSubtextEntry(text, juce::StringArray{ subtext }, id);
+}
+
+EarComboBoxTextEntry* EarComboBox::addTextWithSubtextEntry(const String& text, const StringArray& subtext, const juce::var& id)
+{
+	auto uptr = std::make_unique<EarComboBoxTextWithSubtextEntry>(text, subtext, id);
+	auto rawptr = uptr.get();
+	addEntry(std::move(uptr));
+	return rawptr;
+}
+
+EarComboBoxColourEntry* EarComboBox::addColourEntry(const Colour& colour, const juce::var& id) {
 	auto uptr = std::make_unique<EarComboBoxColourEntry>(colour, id);
 	auto rawptr = uptr.get();
 	addEntry(std::move(uptr));
 	return rawptr;
 }
 
-EarComboBoxSectionEntry* EarComboBox::addSectionEntry(const String& text, int id) {
+EarComboBoxSectionEntry* EarComboBox::addSectionEntry(const String& text, const juce::var& id) {
 	auto uptr = std::make_unique<EarComboBoxSectionEntry>(text, id);
 	auto rawptr = uptr.get();
 	addEntry(std::move(uptr));
diff --git a/shared/components/ear_combo_box.hpp b/shared/components/ear_combo_box.hpp
index 3490b9a5b..ecf8eeb48 100644
--- a/shared/components/ear_combo_box.hpp
+++ b/shared/components/ear_combo_box.hpp
@@ -15,7 +15,7 @@ class EarComboBox;
 
 class EarComboBoxEntry : public Component {
 public:
-	EarComboBoxEntry(int id = 0);
+	EarComboBoxEntry(const juce::var& id = 0);
 
 	bool isSelected() const;
 	void setSelected(bool selected);
@@ -24,12 +24,13 @@ class EarComboBoxEntry : public Component {
 	bool isHighlighted() const;
 	void setHighlighted(bool highlighted);
 
-	int getId();
+	juce::var getId();
 
 	String getSearchString() { return searchString_; }
 
 	void paint(Graphics& g) override;
 
+	virtual void resizeForWidth(int width);
 	virtual void drawEntryInList(Graphics& g, juce::Rectangle<int> area) = 0;
 	virtual void drawEntryInButton(Graphics& g, juce::Rectangle<int> area) = 0;
 
@@ -42,7 +43,7 @@ class EarComboBoxEntry : public Component {
 protected:
 	bool isSelectable_ = true;
 	String searchString_ = "";
-	int id_;
+	juce::var id_;
 
 private:
 	juce::Point<int> mouseXyRelative_;
@@ -52,7 +53,7 @@ class EarComboBoxEntry : public Component {
 
 class EarComboBoxTextEntry : public EarComboBoxEntry {
 public:
-	EarComboBoxTextEntry(const String& text = "", int id = 0);
+	EarComboBoxTextEntry(const String& text = "", const juce::var& id = juce::var());
 
 	void setText(const String& text);
 	String getText() const;
@@ -69,11 +70,34 @@ class EarComboBoxTextEntry : public EarComboBoxEntry {
 private:
 	String text_;
 	bool lightFont{ false };
+	const int padEntryText_{ 14 };
+};
+
+class EarComboBoxTextWithSubtextEntry : public EarComboBoxTextEntry {
+public:
+	EarComboBoxTextWithSubtextEntry(const String& text = "", const StringArray& subtext = {}, const juce::var& id = juce::var());
+	EarComboBoxTextWithSubtextEntry(const String& text = "", const String& subtext = "", const juce::var& id = juce::var());
+
+	void setSubtext(const StringArray& text);
+	StringArray getSubtext() const;
+
+	virtual void resizeForWidth(int width) override;
+	virtual void drawEntryInList(Graphics& g, juce::Rectangle<int> area) override;
+
+private:
+	StringArray originalSubtext_;
+	StringArray structuredSubtext_;
+	int structuredSubtextWidth_{ 0 };
+	const int heightListEntryText_{ 30 };
+	const int heightListEntrySubtextLine_{ 16 };
+	const int heightFinalPad_{ 4 };
+	const int padLeftListEntrySubtext_{ 28 };
+	const int padRightListEntrySubtext_{ 14 };
 };
 
 class EarComboBoxColourEntry : public EarComboBoxEntry {
 public:
-	EarComboBoxColourEntry(Colour colour = Colour{}, int id = 0);
+	EarComboBoxColourEntry(Colour colour = Colour{}, const juce::var& id = juce::var());
 
 	void setEntryColour(const Colour& colour);
 	Colour getEntryColour() const;
@@ -88,7 +112,7 @@ class EarComboBoxColourEntry : public EarComboBoxEntry {
 
 class EarComboBoxSectionEntry : public EarComboBoxEntry {
 public:
-	EarComboBoxSectionEntry(const String& text = "", int id = 0);
+	EarComboBoxSectionEntry(const String& text = "", const juce::var& id = juce::var());
 
 	void setText(const String& text);
 	String getText() const;
@@ -161,19 +185,23 @@ class EarComboBoxPopup : public Component {
 		return -1;
 	}
 
-	int getEntryIndexById(int id) {
-		for (int i = 0; i < entries_.size(); ++i) {
-			if (entries_.at(i)->getId() == id) {
-				return i;
+	int getEntryIndexById(const juce::var& id) {
+		if (!id.isVoid()) {
+			for (int i = 0; i < entries_.size(); ++i) {
+				if (entries_.at(i)->getId().equalsWithSameType(id)) {
+					return i;
+				}
 			}
 		}
 		return -1;
 	}
 
-	EarComboBoxEntry* getEntryById(int id) {
-		for (int i = 0; i < entries_.size(); ++i) {
-			if (entries_.at(i)->getId() == id) {
-				return entries_.at(i).get();
+	EarComboBoxEntry* getEntryById(const juce::var& id) {
+		if (!id.isVoid()) {
+			for (int i = 0; i < entries_.size(); ++i) {
+				if (entries_.at(i)->getId().equalsWithSameType(id)) {
+					return entries_.at(i).get();
+				}
 			}
 		}
 		return nullptr;
@@ -325,9 +353,11 @@ class EarComboBox : public Component,
 	String getDefaultText() const;
 
 	EarComboBoxEntry* addEntry(std::unique_ptr<EarComboBoxEntry> entry);
-	EarComboBoxTextEntry* addTextEntry(const String& text, int id = 0);
-	EarComboBoxColourEntry* addColourEntry(const Colour& colour, int id = 0);
-	EarComboBoxSectionEntry* addSectionEntry(const String& text, int id = 0);
+	EarComboBoxTextEntry* addTextEntry(const String& text, const juce::var& id = juce::var());
+	EarComboBoxTextEntry* addTextWithSubtextEntry(const String& text, const String& subtext, const juce::var& id = juce::var());
+	EarComboBoxTextEntry* addTextWithSubtextEntry(const String& text, const StringArray& subtext, const juce::var& id = juce::var());
+	EarComboBoxColourEntry* addColourEntry(const Colour& colour, const juce::var& id = juce::var());
+	EarComboBoxSectionEntry* addSectionEntry(const String& text, const juce::var& id = juce::var());
 
 	void selectEntry(int newIndex, NotificationType notification) {
 		if (newIndex != currentSelectedIndex_) {
@@ -349,13 +379,13 @@ class EarComboBox : public Component,
 
 	bool hasSelection() { return getSelectedEntryIndex() >= 0; }
 
-	bool setSelectedId(int id, NotificationType notification) {
+	bool setSelectedId(const juce::var& id, NotificationType notification) {
 		auto index = popup_->getEntryIndexById(id);
 		if (index < 0) return false;
 		selectEntry(index, notification);
 		return true;
 	}
-	int getSelectedId() {
+	juce::var getSelectedId() {
 		auto selectedEntry = getSelectedEntry();
 		assert(selectedEntry);
 		return selectedEntry->getId();
@@ -366,11 +396,17 @@ class EarComboBox : public Component,
 	void openPopup();
 	void closePopup();
 
+	void setCanClearSelection(bool opt) {
+		canClearSelection = opt;
+	}
+
 	virtual bool keyPressed(const KeyPress& key) override {
-		if (key == KeyPress::deleteKey || key == KeyPress::backspaceKey) {
-			selectEntry(-1, sendNotificationAsync);
-			repaint();
-			return true;
+		if (canClearSelection) {
+			if (key == KeyPress::deleteKey || key == KeyPress::backspaceKey) {
+				selectEntry(-1, sendNotificationAsync);
+				repaint();
+				return true;
+			}
 		}
 		return false;
 	}
@@ -438,6 +474,7 @@ class EarComboBox : public Component,
 	String defaultText_;
 	ListenerList<Listener> listeners_;
 	std::unique_ptr<EarComboBoxPopup> popup_;
+	bool canClearSelection{ true };
 
 	JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(EarComboBox)
 };  // namespace ui
diff --git a/shared/components/look_and_feel/colours.hpp b/shared/components/look_and_feel/colours.hpp
index 6b88c1d2a..02c26c6ac 100644
--- a/shared/components/look_and_feel/colours.hpp
+++ b/shared/components/look_and_feel/colours.hpp
@@ -24,6 +24,9 @@ static const Colour Primary = Colour(26, 93, 159);
 static const Colour PrimaryVariant = Colour(0, 128, 255);
 static const Colour PrimaryHighlight = Colour(207, 102, 121);
 static const Colour Error = Colour(207, 102, 121);
+static const Colour StatusBad = Colour(207, 102, 121);
+static const Colour StatusWarning = Colour(222, 139, 31);
+static const Colour StatusGood = Colour(102, 207, 121);
 
 static const Colour Area01dp = Colour(255, 255, 255).withAlpha(0.05f);
 static const Colour Area02dp = Colour(255, 255, 255).withAlpha(0.07f);
diff --git a/shared/components/look_and_feel/fonts.hpp b/shared/components/look_and_feel/fonts.hpp
index b95fa67d0..5e02462f4 100644
--- a/shared/components/look_and_feel/fonts.hpp
+++ b/shared/components/look_and_feel/fonts.hpp
@@ -15,6 +15,7 @@ struct EarFonts {
         Label(font::RobotoSingleton::instance().getRegular(14.f)),
         Items(font::RobotoSingleton::instance().getMedium(14.f)),
         ItemsLight(font::RobotoSingleton::instance().getLight(14.f)),
+        ItemsSubtext(font::RobotoSingleton::instance().getLight(10.f)),
         Values(font::RobotoSingleton::instance().getMedium(12.f)),
         Description(font::RobotoSingleton::instance().getLight(12.f)),
         Units(font::RobotoSingleton::instance().getMedium(10.f)),
@@ -27,6 +28,7 @@ struct EarFonts {
   const Font Label;
   const Font Items;
   const Font ItemsLight;
+  const Font ItemsSubtext;
   const Font Values;
   const Font Description;
   const Font Units;
diff --git a/submodules/bear b/submodules/bear
index ea197670a..aeed72b80 160000
--- a/submodules/bear
+++ b/submodules/bear
@@ -1 +1 @@
-Subproject commit ea197670a53743e9fc81c59cf502d400ae8034a7
+Subproject commit aeed72b80381e1f6839ce32f7cfcd30c0a6fbf2d