diff --git a/Source/Devices/Neuropixels1e.cpp b/Source/Devices/Neuropixels1e.cpp
index 9bad29b..b26d9a3 100644
--- a/Source/Devices/Neuropixels1e.cpp
+++ b/Source/Devices/Neuropixels1e.cpp
@@ -65,8 +65,7 @@ void NeuropixelsV1eBackgroundUpdater::run()
 	}
 	catch (const error_str& e)
 	{
-		LOGE(e.what());
-		AlertWindow::showMessageBox(MessageBoxIconType::WarningIcon, "Error Writing Shift Registers", e.what());
+		Onix1::showWarningMessageBoxAsync("Error Writing Shift Registers", e.what());
 		result = false;
 		return;
 	}
diff --git a/Source/OnixSource.cpp b/Source/OnixSource.cpp
index bb62c20..739099e 100644
--- a/Source/OnixSource.cpp
+++ b/Source/OnixSource.cpp
@@ -159,8 +159,7 @@ bool OnixSource::configureDevice(OnixDeviceVector& sources,
 	}
 	catch (const error_str& e)
 	{
-		LOGE(e.what());
-		AlertWindow::showMessageBox(MessageBoxIconType::WarningIcon, "Configuration Error", e.what());
+		Onix1::showWarningMessageBoxAsync("Configuration Error", e.what());
 
 		return false;
 	}
@@ -285,7 +284,7 @@ bool OnixSource::checkHubFirmwareCompatibility(std::shared_ptr<Onix1> context, d
 			auto majorVersion = (firmwareVersion & 0xFF00) >> 8;
 			auto minorVersion = firmwareVersion & 0xFF;
 
-			LOGD("Breakout board firmware version: v", majorVersion, ".", minorVersion);
+			LOGC("Breakout board firmware version: v", majorVersion, ".", minorVersion);
 
 			if (majorVersion != RequiredMajorVersion)
 			{
@@ -410,7 +409,7 @@ bool OnixSource::initializeDevices(device_map_t deviceTable, bool updateStreamIn
 
 			auto EEPROM = std::make_unique<HeadStageEEPROM>(index, context);
 			uint32_t hsid = EEPROM->GetHeadStageID();
-			LOGD("Detected headstage ", onix_hub_str(hsid));
+			LOGC("Detected headstage ", onix_hub_str(hsid));
 
 			if (hsid == ONIX_HUB_HSNP2E)
 			{
diff --git a/Source/UI/NeuropixelsV1Interface.cpp b/Source/UI/NeuropixelsV1Interface.cpp
index 47678e1..fb46674 100644
--- a/Source/UI/NeuropixelsV1Interface.cpp
+++ b/Source/UI/NeuropixelsV1Interface.cpp
@@ -77,8 +77,35 @@ NeuropixelsV1Interface::NeuropixelsV1Interface(std::shared_ptr<Neuropixels1> d,
 		infoLabel->setJustificationType(Justification::topLeft);
 		addAndMakeVisible(infoLabel.get());
 
+		searchForCalibrationFilesButton = std::make_unique<ToggleButton>("Search for calibration files automatically");
+		searchForCalibrationFilesButton->setBounds(infoLabel->getX() + 2, infoLabel->getBottom() + 5, 350, 20);
+		searchForCalibrationFilesButton->addListener(this);
+		searchForCalibrationFilesButton->setTooltip("Open a file dialog to choose a folder that contains all calibration files. The calibration file(s) that matches your probe will automatically be selected if it exists in this folder.");
+		addAndMakeVisible(searchForCalibrationFilesButton.get());
+
+		calibrationFolderLabel = std::make_unique<Label>("calibrationFolderLabel", "Calibration Folder");
+		calibrationFolderLabel->setBounds(searchForCalibrationFilesButton->getX(), searchForCalibrationFilesButton->getBottom() + 5, 240, 16);
+		calibrationFolderLabel->setColour(Label::textColourId, Colours::black);
+		addAndMakeVisible(calibrationFolderLabel.get());
+
+		calibrationFolder = std::make_unique<TextEditor>("CALIBRATION FOLDER");
+		calibrationFolder->setEnabled(false);
+		calibrationFolder->setBounds(calibrationFolderLabel->getX(), calibrationFolderLabel->getBottom() + 2, calibrationFolderLabel->getWidth(), 20);
+		calibrationFolder->setColour(Label::textColourId, Colours::black);
+		calibrationFolder->addListener(this);
+		addAndMakeVisible(calibrationFolder.get());
+
+		calibrationFolderButton = std::make_unique<UtilityButton>("...");
+		calibrationFolderButton->setBounds(calibrationFolder->getRight() + 3, calibrationFolder->getY(), 26, calibrationFolder->getHeight() + 2);
+		calibrationFolderButton->setRadius(1.0f);
+		calibrationFolderButton->addListener(this);
+		calibrationFolderButton->setTooltip("Open a file dialog to choose the calibration folder path to automatically search for probe calibration files.");
+		addAndMakeVisible(calibrationFolderButton.get());
+
+		calibrationFolderChooser = std::make_unique<FileChooser>("Select Gain Calibration Folder.", File());
+
 		adcCalibrationFileLabel = std::make_unique<Label>("adcCalibrationFileLabel", "ADC Calibration File");
-		adcCalibrationFileLabel->setBounds(infoLabel->getX(), infoLabel->getBottom() + 15, 240, 16);
+		adcCalibrationFileLabel->setBounds(calibrationFolder->getX(), calibrationFolder->getBottom() + 15, calibrationFolderLabel->getWidth(), calibrationFolderLabel->getHeight());
 		adcCalibrationFileLabel->setColour(Label::textColourId, Colours::black);
 		addAndMakeVisible(adcCalibrationFileLabel.get());
 
@@ -96,7 +123,7 @@ NeuropixelsV1Interface::NeuropixelsV1Interface(std::shared_ptr<Neuropixels1> d,
 		adcCalibrationFileButton->setTooltip("Open a file dialog to choose the ADC calibration file for this probe.");
 		addAndMakeVisible(adcCalibrationFileButton.get());
 
-		adcCalibrationFileChooser = std::make_unique<FileChooser>("Select ADC Calibration file.", File(), "*_ADCCalibration.csv");
+		adcCalibrationFileChooser = std::make_unique<FileChooser>("Select ADC Calibration file.", File(), std::string("*") + AdcCalibrationFilename);
 
 		gainCalibrationFileLabel = std::make_unique<Label>("gainCalibrationFileLabel", "Gain Calibration File");
 		gainCalibrationFileLabel->setBounds(adcCalibrationFile->getX(), adcCalibrationFile->getBottom() + 3, adcCalibrationFile->getWidth(), adcCalibrationFile->getHeight());
@@ -117,7 +144,7 @@ NeuropixelsV1Interface::NeuropixelsV1Interface(std::shared_ptr<Neuropixels1> d,
 		gainCalibrationFileButton->setTooltip("Open a file dialog to choose the Gain calibration file for this probe.");
 		addAndMakeVisible(gainCalibrationFileButton.get());
 
-		gainCalibrationFileChooser = std::make_unique<FileChooser>("Select Gain Calibration file.", File(), "*_gainCalValues.csv");
+		gainCalibrationFileChooser = std::make_unique<FileChooser>("Select Gain Calibration file.", File(), std::string("*") + GainCalibrationFilename);
 
 		probeInterfaceRectangle = std::make_unique<DrawableRectangle>();
 		probeInterfaceRectangle->setFill(Colours::darkgrey);
@@ -507,6 +534,8 @@ NeuropixelsV1Interface::NeuropixelsV1Interface(std::shared_ptr<Neuropixels1> d,
 		addAndMakeVisible(activityViewComponent.get());
 
 		updateSettings();
+
+		setCalibrationFolderEnabledState(false);
 	}
 
 	drawLegend();
@@ -534,6 +563,7 @@ void NeuropixelsV1Interface::updateInfoString()
 	std::string deviceString, infoString;
 
 	auto npx = std::static_pointer_cast<Neuropixels1>(device);
+	auto sn = npx->getProbeSerialNumber();
 
 	if (device != nullptr)
 	{
@@ -541,13 +571,18 @@ void NeuropixelsV1Interface::updateInfoString()
 
 		infoString += "\n";
 		infoString += "Probe Number: ";
-		infoString += std::to_string(npx->getProbeSerialNumber());
+		infoString += std::to_string(sn);
 		infoString += "\n";
 		infoString += "\n";
 	}
 
 	deviceLabel->setText(deviceString, dontSendNotification);
 	infoLabel->setText(infoString, dontSendNotification);
+
+	if (searchForCalibrationFilesButton->getToggleState())
+	{
+		searchForCalibrationFiles(calibrationFolder->getText().toStdString(), sn);
+	}
 }
 
 void NeuropixelsV1Interface::comboBoxChanged(ComboBox* comboBox)
@@ -556,7 +591,6 @@ void NeuropixelsV1Interface::comboBoxChanged(ComboBox* comboBox)
 
 	if (!editor->acquisitionIsActive)
 	{
-		auto npx = std::static_pointer_cast<Neuropixels1>(device);
 		auto settings = npx->settings[0].get();
 
 		if (comboBox == electrodeConfigurationComboBox.get())
@@ -686,7 +720,6 @@ void NeuropixelsV1Interface::buttonClicked(Button* button)
 			deviceEnableButton->setLabel(disabledButtonText);
 		}
 
-		updateInfoString();
 		repaint();
 
 		CoreServices::updateSignalChain(editor);
@@ -801,10 +834,6 @@ void NeuropixelsV1Interface::buttonClicked(Button* button)
 		{
 			adcCalibrationFile->setText(adcCalibrationFileChooser->getResult().getFullPathName());
 		}
-		else
-		{
-			adcCalibrationFile->setText("");
-		}
 
 		std::static_pointer_cast<Neuropixels1>(device)->setAdcCalibrationFilePath(adcCalibrationFile->getText().toStdString());
 	}
@@ -814,15 +843,128 @@ void NeuropixelsV1Interface::buttonClicked(Button* button)
 		{
 			gainCalibrationFile->setText(gainCalibrationFileChooser->getResult().getFullPathName());
 		}
-		else
+
+		std::static_pointer_cast<Neuropixels1>(device)->setGainCalibrationFilePath(gainCalibrationFile->getText().toStdString());
+	}
+	else if (button == searchForCalibrationFilesButton.get())
+	{
+		setCalibrationFolderEnabledState(button->getToggleState());
+
+		if (button->getToggleState())
 		{
-			gainCalibrationFile->setText("");
+			searchForCalibrationFiles(calibrationFolder->getText().toStdString(), std::static_pointer_cast<Neuropixels1>(device)->getProbeSerialNumber());
 		}
+	}
+	else if (button == calibrationFolderButton.get())
+	{
+		if (calibrationFolderChooser->browseForDirectory())
+		{
+			calibrationFolder->setText(calibrationFolderChooser->getResult().getFullPathName());
+			searchForCalibrationFiles(calibrationFolder->getText().toStdString(), std::static_pointer_cast<Neuropixels1>(device)->getProbeSerialNumber());
+		}
+	}
+}
 
-		std::static_pointer_cast<Neuropixels1>(device)->setGainCalibrationFilePath(gainCalibrationFile->getText().toStdString());
+void NeuropixelsV1Interface::textEditorTextChanged(TextEditor& editor)
+{
+	if (editor.getName() == gainCalibrationFile->getName())
+	{
+		std::static_pointer_cast<Neuropixels1>(device)->setGainCalibrationFilePath(editor.getText().toStdString());
+	}
+	else if (editor.getName() == adcCalibrationFile->getName())
+	{
+		std::static_pointer_cast<Neuropixels1>(device)->setAdcCalibrationFilePath(editor.getText().toStdString());
+	}
+}
+
+std::string NeuropixelsV1Interface::searchDirectoryForAdcCalibrationFile(std::string folder, uint64_t sn)
+{
+	return searchDirectoryForCalibrationFile(folder, std::to_string(sn) + AdcCalibrationFilename, sn);
+}
+
+std::string NeuropixelsV1Interface::searchDirectoryForGainCalibrationFile(std::string folder, uint64_t sn)
+{
+	return searchDirectoryForCalibrationFile(folder, std::to_string(sn) + GainCalibrationFilename, sn);
+}
+
+std::string NeuropixelsV1Interface::searchDirectoryForCalibrationFile(std::string folder, std::string filename, uint64_t sn)
+{
+	if (folder == "" || sn == 0)
+		return "";
+
+	File rootDirectory = File(folder);
+
+	if (!rootDirectory.isDirectory())
+	{
+		Onix1::showWarningMessageBoxAsync("Invalid Directory", "The path given for the calibration files directory is invalid. Please try setting it again.");
+		return "";
+	}
+
+	auto calibrationFiles = searchDirectoryForFile(rootDirectory, filename, NeuropixelsCalibrationFileRecursiveLevels);
+
+	if (calibrationFiles.size() != 1)
+	{
+		std::string msg = "Expected to find 1 file matching '" + filename +
+			"', but found " + std::to_string(calibrationFiles.size()) + " instead.";
+
+		if (calibrationFiles.size() > 1)
+		{
+			msg += " Check console for all files discovered.";
+		}
+
+		Onix1::showWarningMessageBoxAsync("Wrong Number of Calibration Files", msg);
+		return "";
+	}
+
+	return calibrationFiles[0].getFullPathName().toStdString();
+}
+
+void NeuropixelsV1Interface::setCalibrationFolderEnabledState(bool enabledState)
+{
+	float alphaEnabled = 1.0, alphaDisabled = 0.25;
+
+	if (!enabledState)
+	{
+		calibrationFolder->setAlpha(alphaDisabled);
+		calibrationFolderButton->setEnabled(false);
+
+		adcCalibrationFile->setAlpha(alphaEnabled);
+		adcCalibrationFileButton->setEnabled(true);
+
+		gainCalibrationFile->setAlpha(alphaEnabled);
+		gainCalibrationFileButton->setEnabled(true);
+	}
+	else
+	{
+		calibrationFolder->setAlpha(alphaEnabled);
+		calibrationFolderButton->setEnabled(true);
+
+		adcCalibrationFile->setAlpha(alphaDisabled);
+		adcCalibrationFileButton->setEnabled(false);
+
+		gainCalibrationFile->setAlpha(alphaDisabled);
+		gainCalibrationFileButton->setEnabled(false);
 	}
 }
 
+void NeuropixelsV1Interface::searchForCalibrationFiles(std::string folder, uint64_t sn)
+{
+	if (!device->isEnabled())
+		return;
+
+	auto file = searchDirectoryForGainCalibrationFile(folder, sn);
+
+	if (file != "")
+		gainCalibrationFile->setText(file);
+	else
+		return;
+
+	file = searchDirectoryForAdcCalibrationFile(folder, sn);
+
+	if (file != "")
+		adcCalibrationFile->setText(file);
+}
+
 std::vector<int> NeuropixelsV1Interface::getSelectedElectrodes() const
 {
 	std::vector<int> electrodeIndices;
@@ -898,6 +1040,12 @@ void NeuropixelsV1Interface::setInterfaceEnabledState(bool enabledState)
 
 	if (loadSettingsButton != nullptr)
 		loadSettingsButton->setEnabled(enabledState);
+
+	if (searchForCalibrationFilesButton != nullptr)
+		searchForCalibrationFilesButton->setEnabled(enabledState);
+
+	if (calibrationFolderButton != nullptr)
+		calibrationFolderButton->setEnabled(enabledState);
 }
 
 void NeuropixelsV1Interface::startAcquisition()
@@ -1020,6 +1168,10 @@ void NeuropixelsV1Interface::saveParameters(XmlElement* xml)
 
 	xmlNode->setAttribute("isEnabled", bool(device->isEnabled()));
 
+	xmlNode->setAttribute("searchForCalibrationFiles", searchForCalibrationFilesButton->getToggleState());
+
+	xmlNode->setAttribute("calibrationFolder", calibrationFolder->getText());
+
 	xmlNode->setAttribute("adcCalibrationFile", npx->getAdcCalibrationFilePath());
 	xmlNode->setAttribute("gainCalibrationFile", npx->getGainCalibrationFilePath());
 
@@ -1088,6 +1240,10 @@ void NeuropixelsV1Interface::loadParameters(XmlElement* xml)
 
 	npx->setEnabled(xmlNode->getBoolAttribute("isEnabled"));
 
+	searchForCalibrationFilesButton->setToggleState(xmlNode->getBoolAttribute("searchForCalibrationFiles", false), sendNotification);
+
+	calibrationFolder->setText(xmlNode->getStringAttribute("calibrationFolder", ""));
+
 	npx->setAdcCalibrationFilePath(xmlNode->getStringAttribute("adcCalibrationFile").toStdString());
 	npx->setGainCalibrationFilePath(xmlNode->getStringAttribute("gainCalibrationFile").toStdString());
 
diff --git a/Source/UI/NeuropixelsV1Interface.h b/Source/UI/NeuropixelsV1Interface.h
index b53b97b..2dee6e3 100644
--- a/Source/UI/NeuropixelsV1Interface.h
+++ b/Source/UI/NeuropixelsV1Interface.h
@@ -51,6 +51,7 @@ namespace OnixSourcePlugin
 
 		void buttonClicked(Button*) override;
 		void comboBoxChanged(ComboBox*) override;
+		void textEditorTextChanged(TextEditor&) override;
 
 		void startAcquisition() override;
 
@@ -77,6 +78,9 @@ namespace OnixSourcePlugin
 
 		bool acquisitionIsActive = false;
 
+		static constexpr char* GainCalibrationFilename = "_gainCalValues.csv";
+		static constexpr char* AdcCalibrationFilename = "_ADCCalibration.csv";
+
 		std::unique_ptr<ComboBox> electrodeConfigurationComboBox;
 		std::unique_ptr<ComboBox> lfpGainComboBox;
 		std::unique_ptr<ComboBox> apGainComboBox;
@@ -94,6 +98,20 @@ namespace OnixSourcePlugin
 		std::unique_ptr<Label> filterLabel;
 		std::unique_ptr<Label> activityViewLabel;
 
+		std::unique_ptr<Label> calibrationFolderLabel;
+		std::unique_ptr<ToggleButton> searchForCalibrationFilesButton;
+		std::unique_ptr<FileChooser> calibrationFolderChooser;
+		std::unique_ptr<TextEditor> calibrationFolder;
+		std::unique_ptr<UtilityButton> calibrationFolderButton;
+
+		void setCalibrationFolderEnabledState(bool enabledState);
+
+		static std::string searchDirectoryForGainCalibrationFile(std::string folder, uint64_t sn);
+		static std::string searchDirectoryForAdcCalibrationFile(std::string folder, uint64_t sn);
+		static std::string searchDirectoryForCalibrationFile(std::string folder, std::string filename, uint64_t sn);
+
+		void searchForCalibrationFiles(std::string, uint64_t);
+
 		std::unique_ptr<Label> adcCalibrationFileLabel;
 		std::unique_ptr<Label> gainCalibrationFileLabel;
 
diff --git a/Source/UI/NeuropixelsV2eInterface.cpp b/Source/UI/NeuropixelsV2eInterface.cpp
index ad4416e..960a2d1 100644
--- a/Source/UI/NeuropixelsV2eInterface.cpp
+++ b/Source/UI/NeuropixelsV2eInterface.cpp
@@ -102,7 +102,6 @@ void NeuropixelsV2eInterface::buttonClicked(Button* button)
 			deviceEnableButton->setLabel(disabledButtonText);
 		}
 
-		updateInfoString();
 		repaint();
 
 		CoreServices::updateSignalChain(editor);
diff --git a/Source/UI/NeuropixelsV2eProbeInterface.cpp b/Source/UI/NeuropixelsV2eProbeInterface.cpp
index 43403fa..af3539a 100644
--- a/Source/UI/NeuropixelsV2eProbeInterface.cpp
+++ b/Source/UI/NeuropixelsV2eProbeInterface.cpp
@@ -65,8 +65,35 @@ NeuropixelsV2eProbeInterface::NeuropixelsV2eProbeInterface(std::shared_ptr<Neuro
 		infoLabel->setJustificationType(Justification::topLeft);
 		addAndMakeVisible(infoLabel.get());
 
+		searchForCorrectionFilesButton = std::make_unique<ToggleButton>("Search for calibration files automatically");
+		searchForCorrectionFilesButton->setBounds(infoLabel->getX() + 2, infoLabel->getBottom() + 5, 350, 20);
+		searchForCorrectionFilesButton->addListener(this);
+		searchForCorrectionFilesButton->setTooltip("Open a file dialog to choose a folder that contains all calibration files. The calibration file that matches your probe will automatically be selected if it exists in this folder.");
+		addAndMakeVisible(searchForCorrectionFilesButton.get());
+
+		gainCorrectionFolderLabel = std::make_unique<Label>("gainCorrectionFolderLabel", "Calibration Folder");
+		gainCorrectionFolderLabel->setBounds(searchForCorrectionFilesButton->getX(), searchForCorrectionFilesButton->getBottom() + 5, 240, 16);
+		gainCorrectionFolderLabel->setColour(Label::textColourId, Colours::black);
+		addAndMakeVisible(gainCorrectionFolderLabel.get());
+
+		gainCorrectionFolder = std::make_unique<TextEditor>("GAIN CORRECTION FOLDER");
+		gainCorrectionFolder->setEnabled(false);
+		gainCorrectionFolder->setBounds(gainCorrectionFolderLabel->getX(), gainCorrectionFolderLabel->getBottom() + 2, gainCorrectionFolderLabel->getWidth(), 20);
+		gainCorrectionFolder->setColour(Label::textColourId, Colours::black);
+		gainCorrectionFolder->addListener(this);
+		addAndMakeVisible(gainCorrectionFolder.get());
+
+		gainCorrectionFolderButton = std::make_unique<UtilityButton>("...");
+		gainCorrectionFolderButton->setBounds(gainCorrectionFolder->getRight() + 3, gainCorrectionFolder->getY(), 26, gainCorrectionFolder->getHeight() + 2);
+		gainCorrectionFolderButton->setRadius(1.0f);
+		gainCorrectionFolderButton->addListener(this);
+		gainCorrectionFolderButton->setTooltip("Open a file dialog to choose the gain correction folder path to automatically search for probe calibration files.");
+		addAndMakeVisible(gainCorrectionFolderButton.get());
+
+		gainCorrectionFolderChooser = std::make_unique<FileChooser>("Select Gain Correction Folder.", File());
+
 		gainCorrectionFileLabel = std::make_unique<Label>("gainCorrectionFileLabel", "Gain Correction File");
-		gainCorrectionFileLabel->setBounds(infoLabel->getX() + 2, infoLabel->getBottom() + 5, 240, 16);
+		gainCorrectionFileLabel->setBounds(gainCorrectionFolder->getX(), gainCorrectionFolder->getBottom() + 15, gainCorrectionFolderLabel->getWidth(), gainCorrectionFolderLabel->getHeight());
 		gainCorrectionFileLabel->setColour(Label::textColourId, Colours::black);
 		addAndMakeVisible(gainCorrectionFileLabel.get());
 
@@ -84,7 +111,7 @@ NeuropixelsV2eProbeInterface::NeuropixelsV2eProbeInterface(std::shared_ptr<Neuro
 		gainCorrectionFileButton->setTooltip("Open a file dialog to choose the gain correction file for this probe.");
 		addAndMakeVisible(gainCorrectionFileButton.get());
 
-		gainCorrectionFileChooser = std::make_unique<FileChooser>("Select Gain Correction file.", File(), "*_gainCalValues.csv");
+		gainCorrectionFileChooser = std::make_unique<FileChooser>("Select Gain Correction file.", File(), std::string("*") + GainCalibrationFilename);
 
 		probeInterfaceRectangle = std::make_unique<DrawableRectangle>();
 		probeInterfaceRectangle->setFill(Colours::darkgrey);
@@ -323,6 +350,8 @@ NeuropixelsV2eProbeInterface::NeuropixelsV2eProbeInterface(std::shared_ptr<Neuro
 		addAndMakeVisible(activityViewComponent.get());
 
 #pragma endregion
+
+		setGainCorrectionFolderEnabledState(false);
 	}
 
 	drawLegend();
@@ -335,6 +364,7 @@ void NeuropixelsV2eProbeInterface::updateInfoString()
 	std::string deviceString, infoString;
 
 	auto npx = std::static_pointer_cast<Neuropixels2e>(device);
+	auto sn = npx->getProbeSerialNumber(probeIndex);
 
 	if (device != nullptr)
 	{
@@ -342,13 +372,21 @@ void NeuropixelsV2eProbeInterface::updateInfoString()
 
 		infoString += "\n";
 		infoString += "Probe Number: ";
-		infoString += std::to_string(npx->getProbeSerialNumber(probeIndex));
+		infoString += std::to_string(sn);
 		infoString += "\n";
 		infoString += "\n";
 	}
 
 	deviceLabel->setText(deviceString, dontSendNotification);
 	infoLabel->setText(infoString, dontSendNotification);
+
+	if (searchForCorrectionFilesButton->getToggleState() && device->isEnabled())
+	{
+		auto file = searchDirectoryForCalibrationFile(gainCorrectionFolder->getText().toStdString(), sn);
+
+		if (file != "")
+			gainCorrectionFile->setText(file);
+	}
 }
 
 void NeuropixelsV2eProbeInterface::comboBoxChanged(ComboBox* comboBox)
@@ -432,8 +470,6 @@ void NeuropixelsV2eProbeInterface::buttonClicked(Button* button)
 
 		if (fileChooser.browseForFileToOpen())
 		{
-			auto npx = std::static_pointer_cast<Neuropixels2e>(device);
-
 			if (ProbeInterfaceJson::readProbeSettingsFromJson(fileChooser.getResult(), npx->settings[probeIndex].get()))
 			{
 				applyProbeSettings(npx->settings[probeIndex].get());
@@ -447,8 +483,6 @@ void NeuropixelsV2eProbeInterface::buttonClicked(Button* button)
 
 		if (fileChooser.browseForFileToSave(true))
 		{
-			auto npx = std::static_pointer_cast<Neuropixels2e>(device);
-
 			if (!ProbeInterfaceJson::writeProbeSettingsToJson(fileChooser.getResult(), npx->settings[probeIndex].get()))
 				CoreServices::sendStatusMessage("Failed to write probe channel map.");
 			else
@@ -487,12 +521,97 @@ void NeuropixelsV2eProbeInterface::buttonClicked(Button* button)
 		{
 			gainCorrectionFile->setText(gainCorrectionFileChooser->getResult().getFullPathName());
 		}
-		else
+	}
+	else if (button == searchForCorrectionFilesButton.get())
+	{
+		setGainCorrectionFolderEnabledState(button->getToggleState());
+
+		if (button->getToggleState() && device->isEnabled())
 		{
-			gainCorrectionFile->setText("");
+			auto calibrationFile = searchDirectoryForCalibrationFile(gainCorrectionFolder->getText().toStdString(), npx->getProbeSerialNumber(probeIndex));
+
+			if (calibrationFile != "")
+				gainCorrectionFile->setText(calibrationFile);
 		}
+	}
+	else if (button == gainCorrectionFolderButton.get())
+	{
+		if (gainCorrectionFolderChooser->browseForDirectory())
+		{
+			gainCorrectionFolder->setText(gainCorrectionFolderChooser->getResult().getFullPathName());
 
-		std::static_pointer_cast<Neuropixels2e>(device)->setGainCorrectionFile(probeIndex, gainCorrectionFile->getText().toStdString());
+			if (device->isEnabled())
+			{
+				auto calibrationFile = searchDirectoryForCalibrationFile(gainCorrectionFolder->getText().toStdString(), npx->getProbeSerialNumber(probeIndex));
+
+				if (calibrationFile != "")
+					gainCorrectionFile->setText(calibrationFile);
+			}
+		}
+	}
+}
+
+void NeuropixelsV2eProbeInterface::textEditorTextChanged(TextEditor& editor)
+{
+	if (editor.getName() == gainCorrectionFile->getName())
+	{
+		std::static_pointer_cast<Neuropixels2e>(device)->setGainCorrectionFile(probeIndex, editor.getText().toStdString());
+	}
+}
+
+std::string NeuropixelsV2eProbeInterface::searchDirectoryForCalibrationFile(std::string directory, uint64_t sn)
+{
+	if (directory == "" || sn == 0)
+		return "";
+
+	auto rootDirectory = File(directory);
+
+	if (!rootDirectory.isDirectory())
+	{
+		Onix1::showWarningMessageBoxAsync("Invalid Directory", "The path given for the calibration files directory is invalid. Please try setting it again.");
+		return "";
+	}
+
+	std::string filename = std::to_string(sn) + GainCalibrationFilename;
+
+	auto calibrationFiles = searchDirectoryForFile(rootDirectory, filename, NeuropixelsCalibrationFileRecursiveLevels);
+
+	if (calibrationFiles.size() != 1)
+	{
+		std::string msg = "Expected to find 1 file matching '" + filename +
+			"', but found " + std::to_string(calibrationFiles.size()) + " instead.";
+
+		if (calibrationFiles.size() > 1)
+		{
+			msg += " Check logs for all files discovered.";
+		}
+
+		Onix1::showWarningMessageBoxAsync("Wrong Number of Calibration Files", msg);
+		return "";
+	}
+
+	return calibrationFiles[0].getFullPathName().toStdString();
+}
+
+void NeuropixelsV2eProbeInterface::setGainCorrectionFolderEnabledState(bool enabledState)
+{
+	float alphaEnabled = 1.0, alphaDisabled = 0.25;
+
+	if (!enabledState)
+	{
+		gainCorrectionFolder->setAlpha(alphaDisabled);
+		gainCorrectionFolderButton->setEnabled(false);
+
+		gainCorrectionFile->setAlpha(alphaEnabled);
+		gainCorrectionFileButton->setEnabled(true);
+	}
+	else
+	{
+		gainCorrectionFolder->setAlpha(alphaEnabled);
+		gainCorrectionFolderButton->setEnabled(true);
+
+		gainCorrectionFile->setAlpha(alphaDisabled);
+		gainCorrectionFileButton->setEnabled(false);
 	}
 }
 
@@ -550,6 +669,12 @@ void NeuropixelsV2eProbeInterface::setInterfaceEnabledState(bool enabledState)
 
 	if (loadSettingsButton != nullptr)
 		loadSettingsButton->setEnabled(enabledState);
+
+	if (gainCorrectionFolderButton != nullptr)
+		gainCorrectionFolderButton->setEnabled(enabledState);
+
+	if (searchForCorrectionFilesButton != nullptr)
+		searchForCorrectionFilesButton->setEnabled(enabledState);
 }
 
 void NeuropixelsV2eProbeInterface::startAcquisition()
@@ -603,7 +728,7 @@ void NeuropixelsV2eProbeInterface::updateSettings()
 	gainCorrectionFile->setText(npx->getGainCorrectionFile(probeIndex) == "None" ? "" : npx->getGainCorrectionFile(probeIndex), dontSendNotification);
 }
 
-bool NeuropixelsV2eProbeInterface::applyProbeSettings(ProbeSettings<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>* p, bool shouldUpdateProbe)
+bool NeuropixelsV2eProbeInterface::applyProbeSettings(ProbeSettings<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>* p)
 {
 	if (electrodeConfigurationComboBox != 0)
 		electrodeConfigurationComboBox->setSelectedId(p->electrodeConfigurationIndex + 2, dontSendNotification);
@@ -634,11 +759,6 @@ bool NeuropixelsV2eProbeInterface::applyProbeSettings(ProbeSettings<Neuropixels2
 		}
 	}
 
-	if (shouldUpdateProbe)
-	{
-		CoreServices::saveRecoveryConfig();
-	}
-
 	drawLegend();
 	repaint();
 
@@ -669,6 +789,10 @@ void NeuropixelsV2eProbeInterface::saveParameters(XmlElement* xml)
 
 	xmlNode->setAttribute("probeSerialNumber", std::to_string(npx->getProbeSerialNumber(probeIndex)));
 
+	xmlNode->setAttribute("searchForCorrectionFiles", searchForCorrectionFilesButton->getToggleState());
+
+	xmlNode->setAttribute("gainCorrectionFolder", gainCorrectionFolder->getText());
+
 	xmlNode->setAttribute("gainCorrectionFile", npx->getGainCorrectionFile(probeIndex));
 
 	XmlElement* probeViewerNode = xmlNode->createNewChildElement("PROBE_VIEWER");
@@ -719,6 +843,10 @@ void NeuropixelsV2eProbeInterface::loadParameters(XmlElement* xml)
 		LOGC("Different serial numbers found. Current serial number is " + std::to_string(npx->getProbeSerialNumber(probeIndex)) + ", while the saved serial number is " + std::to_string(xmlNode->getIntAttribute("probeSerialNumber")) + ". Updating settings...");
 	}
 
+	searchForCorrectionFilesButton->setToggleState(xmlNode->getBoolAttribute("searchForCorrectionFiles", false), sendNotification);
+
+	gainCorrectionFolder->setText(xmlNode->getStringAttribute("gainCorrectionFolder", ""));
+
 	npx->setGainCorrectionFile(probeIndex, xmlNode->getStringAttribute("gainCorrectionFile").toStdString());
 
 	XmlElement* probeViewerNode = xmlNode->getChildByName("PROBE_VIEWER");
diff --git a/Source/UI/NeuropixelsV2eProbeInterface.h b/Source/UI/NeuropixelsV2eProbeInterface.h
index e8dd1ec..867b75b 100644
--- a/Source/UI/NeuropixelsV2eProbeInterface.h
+++ b/Source/UI/NeuropixelsV2eProbeInterface.h
@@ -52,12 +52,13 @@ namespace OnixSourcePlugin
 
 		void buttonClicked(Button*) override;
 		void comboBoxChanged(ComboBox*) override;
+		void textEditorTextChanged(TextEditor&) override;
 
 		void startAcquisition() override;
 
 		void stopAcquisition() override;
 
-		bool applyProbeSettings(ProbeSettings<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>* p, bool shouldUpdateProbe = true);
+		bool applyProbeSettings(ProbeSettings<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>* p);
 
 		void saveParameters(XmlElement* xml) override;
 
@@ -77,6 +78,8 @@ namespace OnixSourcePlugin
 
 		const int probeIndex;
 
+		static constexpr char* GainCalibrationFilename = "_gainCalValues.csv";
+
 		std::unique_ptr<ComboBox> electrodeConfigurationComboBox;
 		std::unique_ptr<ComboBox> referenceComboBox;
 
@@ -86,6 +89,12 @@ namespace OnixSourcePlugin
 		std::unique_ptr<Label> electrodePresetLabel;
 		std::unique_ptr<Label> referenceLabel;
 
+		std::unique_ptr<Label> gainCorrectionFolderLabel;
+		std::unique_ptr<ToggleButton> searchForCorrectionFilesButton;
+		std::unique_ptr<FileChooser> gainCorrectionFolderChooser;
+		std::unique_ptr<TextEditor> gainCorrectionFolder;
+		std::unique_ptr<UtilityButton> gainCorrectionFolderButton;
+
 		std::unique_ptr<Label> gainCorrectionFileLabel;
 		std::unique_ptr<UtilityButton> gainCorrectionFileButton;
 		std::unique_ptr<FileChooser> gainCorrectionFileChooser;
@@ -128,6 +137,10 @@ namespace OnixSourcePlugin
 
 		int getIndexOfComboBoxItem(ComboBox* cb, std::string item);
 
+		void setGainCorrectionFolderEnabledState(bool enabledState);
+
+		static std::string searchDirectoryForCalibrationFile(std::string folder, uint64_t sn);
+
 		JUCE_LEAK_DETECTOR(NeuropixelsV2eProbeInterface);
 	};
 }
diff --git a/Source/UI/SettingsInterface.h b/Source/UI/SettingsInterface.h
index 5a663ff..bd80c10 100644
--- a/Source/UI/SettingsInterface.h
+++ b/Source/UI/SettingsInterface.h
@@ -150,5 +150,36 @@ namespace OnixSourcePlugin
 
 			return rootElement.release();
 		}
+
+    static constexpr int NeuropixelsCalibrationFileRecursiveLevels = 2;
+
+		// Given a File object defining the path to a directory, a filename to search for, and (optionally) the number of recursive levels to
+		// iterate through, return a list of all files that match the given filename in the directory (or directories for recursive searches)
+		static std::vector<File> searchDirectoryForFile(File directory, std::string filename, int recursiveLevels = 0)
+		{
+			std::vector<File> matchingFiles;
+
+			if (!directory.isDirectory())
+				return matchingFiles;
+
+			if (recursiveLevels > 0)
+			{
+				for (DirectoryEntry entry : RangedDirectoryIterator(directory, false, "*", File::findDirectories, File::FollowSymlinks::no))
+				{
+					auto files = searchDirectoryForFile(entry.getFile(), filename, recursiveLevels - 1);
+
+					if (files.size() > 0)
+						matchingFiles.insert(matchingFiles.end(), files.begin(), files.end());
+				}
+			}
+
+			for (DirectoryEntry entry : RangedDirectoryIterator(directory, false, filename, File::findFiles, File::FollowSymlinks::no))
+			{
+				matchingFiles.emplace_back(entry.getFile());
+				LOGC("Discovered file: ", entry.getFile().getFullPathName());
+			}
+
+			return matchingFiles;
+		}
 	};
 }