diff --git a/oscar/Resources.qrc b/oscar/Resources.qrc
index e2807622..07a1980a 100644
--- a/oscar/Resources.qrc
+++ b/oscar/Resources.qrc
@@ -68,5 +68,6 @@
         <file>icons/question_mark.png</file>
         <file>icons/checkmark.png</file>
         <file>icons/empty_box.png</file>
+        <file>icons/resvent.png</file>
     </qresource>
 </RCC>
diff --git a/oscar/SleepLib/loader_plugins/resvent_loader.cpp b/oscar/SleepLib/loader_plugins/resvent_loader.cpp
new file mode 100644
index 00000000..364e814a
--- /dev/null
+++ b/oscar/SleepLib/loader_plugins/resvent_loader.cpp
@@ -0,0 +1,636 @@
+/* SleepLib Resvent Loader Implementation
+ *
+ * Copyright (c) 2019-2023 The OSCAR Team
+ * Copyright (c) 2011-2018 Mark Watkins <mark@jedimark.net>
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of the source code
+ * for more details. */
+
+//********************************************************************************************
+// Please only INCREMENT the resvent_data_version in resvent_loader.h when making changes
+// that change loader behaviour or modify channels in a manner that fixes old data imports.
+// Note that changing the data version will require a reimport of existing data for which OSCAR
+// does not keep a backup - so it should be avoided if possible.
+// i.e. there is no need to change the version when adding support for new devices
+//********************************************************************************************
+
+#include <QString>
+#include <QDateTime>
+#include <QDir>
+#include <QDirIterator>
+#include <QFile>
+#include <QDebug>
+#include <QStringList>
+#include <cmath>
+#include <array>
+#include <unordered_map>
+
+#include "resvent_loader.h"
+
+#ifdef DEBUG_EFFICIENCY
+#include <QElapsedTimer>  // only available in 4.8
+#endif
+
+// Files WXX_XX contain flow rate and pressure and PXX_XX contain Pressure, IPAP, EPAP, Leak, Vt, MV, RR, Ti, IE, Spo2, PR
+// Both files contain a little header of size 0x24 bytes. In offset 0x12 contain the total number of different records in
+// the different files of the same type. And later contain the previous describe quantity of description header of size 0x20
+// containing the details for every type of record (e.g. sample chunk size).
+
+ResventLoader::ResventLoader()
+{
+    const QString RESVENT_ICON = ":/icons/resvent.png";
+
+    QString s = newInfo().series;
+    m_pixmap_paths[s] = RESVENT_ICON;
+    m_pixmaps[s] = QPixmap(RESVENT_ICON);
+
+    m_type = MT_CPAP;
+}
+ResventLoader::~ResventLoader()
+{
+}
+
+const QString kResventTherapyFolder = "THERAPY";
+const QString kResventConfigFolder = "CONFIG";
+const QString kResventRecordFolder = "RECORD";
+const QString kResventSysConfigFilename = "SYSCFG";
+constexpr qint64 kDateTimeOffset = 7 * 60 * 60 * 1000;
+constexpr int kMainHeaderSize = 0x24;
+constexpr int kDescriptionHeaderSize = 0x20;
+constexpr int kChunkDurationInSecOffset = 0x10;
+constexpr int kDescriptionCountOffset = 0x12;
+constexpr int kDescriptionSamplesByChunk = 0x1e;
+
+bool ResventLoader::Detect(const QString & givenpath)
+{
+    QDir dir(givenpath);
+
+    if (!dir.exists()) {
+        return false;
+    }
+
+    if (!dir.exists(kResventTherapyFolder)) {
+        return false;
+    }
+
+    dir.cd(kResventTherapyFolder);
+    if (!dir.exists(kResventConfigFolder)) {
+        return false;
+    }
+
+    if (!dir.exists(kResventRecordFolder)) {
+        return false;
+    }
+
+    return true;
+}
+
+
+MachineInfo ResventLoader::PeekInfo(const QString & path)
+{
+    if (!Detect(path)) {
+        return MachineInfo();
+    }
+
+    MachineInfo info = newInfo();
+
+    const auto sys_config_path = path + QDir::separator() + kResventTherapyFolder + QDir::separator() + kResventConfigFolder + QDir::separator() + kResventSysConfigFilename;
+    if (!QFile::exists(sys_config_path)) {
+        qDebug() << "Resvent Data card has no" << kResventSysConfigFilename << "file in " << sys_config_path;
+        return MachineInfo();
+    }
+    QFile f(sys_config_path);
+    f.open(QIODevice::ReadOnly | QIODevice::Text);
+    f.seek(4);
+    while (!f.atEnd()) {
+        QString line = f.readLine().trimmed();
+
+        const auto elems = line.split("=");
+        assert(elems.size() == 2);
+
+        if (elems[0] == "models") {
+            info.model = elems[1];
+        }
+        else if (elems[0] == "sn") {
+            info.serial = elems[1];
+        }
+        else if (elems[0] == "num") {
+            info.version = elems[1].toInt();
+        }
+        else if (elems[0] == "num") {
+            info.type = MachineType::MT_CPAP;
+        }
+    }
+
+    if (info.model.contains("Point", Qt::CaseInsensitive)) {
+        info.brand = "Hoffrichter";
+    } else {
+        info.brand = "Resvent";
+    }
+
+    return info;
+}
+
+std::vector<QDate> GetSessionsDate(const QString& dirpath) {
+    std::vector<QDate> sessions_date;
+
+    const auto records_path = dirpath + QDir::separator() + kResventTherapyFolder + QDir::separator() + kResventRecordFolder;
+    QDir records_folder(records_path);
+    const auto year_month_folders = records_folder.entryList(QStringList(), QDir::Dirs|QDir::NoDotAndDotDot, QDir::Name);
+    std::for_each(year_month_folders.cbegin(), year_month_folders.cend(), [&](const QString& year_month_folder_name){
+        if (year_month_folder_name.length() != 6) {
+            return;
+        }
+
+        const int year = std::stoi(year_month_folder_name.left(4).toStdString());
+        const int month = std::stoi(year_month_folder_name.right(2).toStdString());
+
+        const auto year_month_folder_path = records_path + QDir::separator() + year_month_folder_name;
+        QDir year_month_folder(year_month_folder_path);
+        const auto session_folders = year_month_folder.entryList(QStringList(), QDir::Dirs|QDir::NoDotAndDotDot, QDir::Name);
+        std::for_each(session_folders.cbegin(), session_folders.cend(), [&](const QString& day_folder){
+            const auto day = std::stoi(day_folder.toStdString());
+
+            sessions_date.push_back(QDate(year, month, day));
+        });
+    });
+    return sessions_date;
+}
+
+enum class EventType {
+    UsageSec= 1,
+    UnixStart = 2,
+    ObstructiveApnea = 17,
+    CentralApnea = 18,
+    Hypopnea = 19,
+    FlowLimitation = 20,
+    RERA = 21,
+    PeriodicBreathing = 22,
+    Snore = 23
+};
+
+struct EventData {
+    EventType type;
+    QDateTime date_time;
+    int duration;
+};
+
+struct UsageData {
+    QString number{};
+    QDateTime start_time{};
+    QDateTime end_time{};
+    qint32 countAHI = 0;
+    qint32 countOAI = 0;
+    qint32 countCAI = 0;
+    qint32 countAI = 0;
+    qint32 countHI = 0;
+    qint32 countRERA = 0;
+    qint32 countSNI = 0;
+    qint32 countBreath = 0;
+};
+
+void UpdateEvents(EventType event_type, const std::unordered_map<EventType, std::vector<EventData>>& events, Session* session) {
+    static std::unordered_map<EventType, unsigned int> mapping {{EventType::ObstructiveApnea, CPAP_Obstructive},
+                                                               {EventType::CentralApnea, CPAP_Apnea},
+                                                               {EventType::Hypopnea, CPAP_Hypopnea},
+                                                               {EventType::FlowLimitation, CPAP_FlowLimit},
+                                                               {EventType::RERA, CPAP_RERA},
+                                                               {EventType::PeriodicBreathing, CPAP_PB},
+                                                               {EventType::Snore, CPAP_Snore}};
+    const auto it_events = events.find(event_type);
+    const auto it_mapping = mapping.find(event_type);
+    if (it_events == events.cend() || it_mapping == mapping.cend()) {
+        return;
+    }
+
+    EventList* event_list  = session->AddEventList(it_mapping->second, EVL_Event);
+    std::for_each(it_events->second.cbegin(), it_events->second.cend(), [&](const EventData& event_data){
+        event_list->AddEvent(event_data.date_time.toMSecsSinceEpoch() + kDateTimeOffset, event_data.duration);
+    });
+}
+
+QString GetSessionFolder(const QString& dirpath, const QDate& session_date) {
+    const auto year_month_folder = QString::number(session_date.year()) + (session_date.month() > 10 ? "" : "0") + QString::number(session_date.month());
+    const auto day_folder = (session_date.day() > 10 ? "" : "0") + QString::number(session_date.day());
+    const auto session_folder_path = dirpath + QDir::separator() + kResventTherapyFolder + QDir::separator() + kResventRecordFolder + QDir::separator() + year_month_folder + QDir::separator() + day_folder;
+    return session_folder_path;
+}
+
+void LoadEvents(const QString& session_folder_path, Session* session, const UsageData& usage) {
+    const auto event_file_path = session_folder_path + QDir::separator() + "EV" + usage.number;
+
+    std::unordered_map<EventType, std::vector<EventData>> events;
+    QFile f(event_file_path);
+    f.open(QIODevice::ReadOnly | QIODevice::Text);
+    f.seek(4);
+    while (!f.atEnd()) {
+        QString line = f.readLine().trimmed();
+
+        const auto elems = line.split(",", Qt::SkipEmptyParts);
+        if (elems.size() != 4) {
+            continue;
+        }
+
+        const auto event_type_elems = elems.at(0).split("=");
+        const auto date_time_elems = elems.at(1).split("=");
+        const auto duration_elems = elems.at(2).split("=");
+
+        assert(event_type_elems.size() == 2);
+        assert(date_time_elems.size() == 2);
+        const auto event_type = static_cast<EventType>(std::stoi(event_type_elems[1].toStdString()));
+        const auto date_time = QDateTime::fromTime_t(std::stoi(date_time_elems[1].toStdString()));
+        const auto duration = std::stoi(duration_elems[1].toStdString());
+
+        events[event_type].push_back(EventData{event_type, date_time, duration});
+    }
+
+    static std::vector<EventType> mapping {EventType::ObstructiveApnea,
+                                          EventType::CentralApnea,
+                                          EventType::Hypopnea,
+                                          EventType::FlowLimitation,
+                                          EventType::RERA,
+                                          EventType::PeriodicBreathing,
+                                          EventType::Snore};
+
+    std::for_each(mapping.cbegin(), mapping.cend(), [&](EventType event_type){
+        UpdateEvents(event_type, events, session);
+    });
+}
+
+template <typename T>
+T read_from_file(QFile& f) {
+    T data{};
+    f.read(reinterpret_cast<char*>(&data), sizeof(T));
+    return data;
+}
+
+struct WaveFileData {
+    unsigned int wave_event_id;
+    QString file_base_name;
+    unsigned int sample_rate_offset;
+    unsigned int start_offset;
+};
+
+EventList* GetEventList(const QString& name, Session* session, float sample_rate = 0.0) {
+    if (name == "Press") {
+        return session->AddEventList(CPAP_Pressure, EVL_Event);
+    }
+    else if (name == "IPAP") {
+        return session->AddEventList(CPAP_IPAP, EVL_Event);
+    }
+    else if (name == "EPAP") {
+        return session->AddEventList(CPAP_EPAP, EVL_Event);
+    }
+    else if (name == "Leak") {
+        return session->AddEventList(CPAP_Leak, EVL_Event);
+    }
+    else if (name == "Vt") {
+        return session->AddEventList(CPAP_TidalVolume, EVL_Event);
+    }
+    else if (name == "MV") {
+        return session->AddEventList(CPAP_MinuteVent, EVL_Event);
+    }
+    else if (name == "RR") {
+        return session->AddEventList(CPAP_RespRate, EVL_Event);
+    }
+    else if (name == "Ti") {
+        return session->AddEventList(CPAP_Ti, EVL_Event);
+    }
+    else if (name == "I:E") {
+        return session->AddEventList(CPAP_IE, EVL_Event);
+    }
+    else if (name == "SpO2" || name == "PR") {
+        // Not present
+        return nullptr;
+    }
+    else if (name == "Pressure") {
+        return session->AddEventList(CPAP_MaskPressure, EVL_Waveform, 0.01, 0.0, 0.0, 0.0, 1000.0 / sample_rate);
+    }
+    else if (name == "Flow") {
+        return session->AddEventList(CPAP_FlowRate, EVL_Waveform, 0.01, 0.0, 0.0, 0.0, 1000.0 / sample_rate);
+    }
+    else {
+        // Not supported
+        assert(false);
+        return nullptr;
+    }
+}
+
+struct ChunkData {
+    EventList* event_list;
+    uint16_t samples_by_chunk;
+    qint64 start_time;
+    int total_samples_by_chunk;
+    float sample_rate;
+};
+
+QString ReadDescriptionName(QFile& f) {
+    constexpr int kNameSize = 9;
+    std::array<char, kNameSize> name;
+    const auto readed = f.read(name.data(), kNameSize - 1);
+    assert(readed == kNameSize - 1);
+
+    return QString(name.data());
+}
+
+void ReadWaveFormsHeaders(QFile& f, std::vector<ChunkData>& wave_forms, Session* session, const UsageData& usage) {
+    f.seek(kChunkDurationInSecOffset);
+    const auto chunk_duration_in_sec = read_from_file<uint16_t>(f);
+    f.seek(kDescriptionCountOffset);
+    const auto description_count = read_from_file<uint16_t>(f);
+    wave_forms.resize(description_count);
+
+    for (unsigned int i = 0; i < description_count; i++) {
+        const auto description_header_offset = kMainHeaderSize + i * kDescriptionHeaderSize;
+        f.seek(description_header_offset);
+        const auto name = ReadDescriptionName(f);
+        f.seek(description_header_offset + kDescriptionSamplesByChunk);
+        const auto samples_by_chunk = read_from_file<uint16_t>(f);
+
+        wave_forms[i].sample_rate = 1.0 * samples_by_chunk / chunk_duration_in_sec;
+        wave_forms[i].event_list = GetEventList(name, session, wave_forms[i].sample_rate);
+        wave_forms[i].samples_by_chunk = samples_by_chunk;
+        wave_forms[i].start_time = usage.start_time.toMSecsSinceEpoch();
+    }
+}
+
+void LoadOtherWaveForms(const QString& session_folder_path, Session* session, const UsageData& usage) {
+    QDir session_folder(session_folder_path);
+
+    const auto wave_files = session_folder.entryList(QStringList() << "P" + usage.number + "_*", QDir::Files, QDir::Name);
+
+    std::vector<ChunkData> wave_forms;
+    bool initialized = false;
+    std::for_each(wave_files.cbegin(), wave_files.cend(), [&](const QString& wave_file){
+        // W01_ file
+        QFile f(session_folder_path + QDir::separator() + wave_file);
+        f.open(QIODevice::ReadOnly);
+
+        if (!initialized) {
+            ReadWaveFormsHeaders(f, wave_forms, session, usage);
+            initialized = true;
+        }
+        f.seek(kMainHeaderSize + wave_forms.size() * kDescriptionHeaderSize);
+
+        std::vector<qint16> chunk(std::max_element(wave_forms.cbegin(), wave_forms.cend(), [](const ChunkData& lhs, const ChunkData& rhs){
+                                      return lhs.samples_by_chunk < rhs.samples_by_chunk;
+                                  })->samples_by_chunk);
+        while (!f.atEnd()) {
+            for (unsigned int i = 0; i < wave_forms.size(); i++) {
+                const auto& wave_form = wave_forms[i].event_list;
+                const auto samples_by_chunk_actual = wave_forms[i].samples_by_chunk;
+                auto& start_time_current = wave_forms[i].start_time;
+                auto& total_samples_by_chunk = wave_forms[i].total_samples_by_chunk;
+                const auto sample_rate = wave_forms[i].sample_rate;
+
+                const auto readed = f.read(reinterpret_cast<char*>(chunk.data()), chunk.size() * sizeof(qint16));
+                if (wave_form) {
+                    const auto readed_elements = readed / sizeof(qint16);
+                    if (readed_elements != samples_by_chunk_actual) {
+                        std::fill(std::begin(chunk) + readed_elements, std::end(chunk), 0);
+                    }
+
+                    int offset = 0;
+                    std::for_each(chunk.cbegin(), chunk.cend(), [&](const qint16& value){
+                        wave_form->AddEvent(start_time_current + offset + kDateTimeOffset, value);
+                        offset += 1000.0 / sample_rate;
+                    });
+                }
+
+                start_time_current += samples_by_chunk_actual * 1000.0 / sample_rate;
+                total_samples_by_chunk += samples_by_chunk_actual;
+            }
+        }
+    });
+
+    std::vector<qint16> chunk;
+    for (unsigned int i = 0; i < wave_forms.size(); i++) {
+        const auto& wave_form = wave_forms[i];
+        const auto expected_samples = usage.start_time.msecsTo(usage.end_time) / 1000.0 * wave_form.sample_rate;
+        if (wave_form.total_samples_by_chunk < expected_samples) {
+            chunk.resize(expected_samples - wave_form.total_samples_by_chunk);
+            if (wave_form.event_list) {
+                int offset = 0;
+                std::for_each(chunk.cbegin(), chunk.cend(), [&](const qint16& value){
+                    wave_form.event_list->AddEvent(wave_form.start_time + offset + kDateTimeOffset, value);
+                    offset += 1000.0 / wave_form.sample_rate;
+                });
+            }
+        }
+    }
+}
+
+void LoadWaveForms(const QString& session_folder_path, Session* session, const UsageData& usage) {
+    QDir session_folder(session_folder_path);
+
+    const auto wave_files = session_folder.entryList(QStringList() << "W" + usage.number + "_*", QDir::Files, QDir::Name);
+
+    std::vector<ChunkData> wave_forms;
+    bool initialized = false;
+
+    std::for_each(wave_files.cbegin(), wave_files.cend(), [&](const QString& wave_file){
+        // W01_ file
+        QFile f(session_folder_path + QDir::separator() + wave_file);
+        f.open(QIODevice::ReadOnly);
+
+        if (!initialized) {
+            ReadWaveFormsHeaders(f, wave_forms, session, usage);
+            initialized = true;
+        }
+        f.seek(kMainHeaderSize + wave_forms.size() * kDescriptionHeaderSize);
+
+        std::vector<qint16> chunk(std::max_element(wave_forms.cbegin(), wave_forms.cend(), [](const ChunkData& lhs, const ChunkData& rhs){
+                                      return lhs.samples_by_chunk < rhs.samples_by_chunk;
+                                  })->samples_by_chunk);
+        while (!f.atEnd()) {
+            for (unsigned int i = 0; i < wave_forms.size(); i++) {
+                const auto& wave_form = wave_forms[i].event_list;
+                const auto samples_by_chunk_actual = wave_forms[i].samples_by_chunk;
+                auto& start_time_current = wave_forms[i].start_time;
+                auto& total_samples_by_chunk = wave_forms[i].total_samples_by_chunk;
+                const auto sample_rate = wave_forms[i].sample_rate;
+
+                const auto duration = samples_by_chunk_actual * 1000.0 / sample_rate;
+                const auto readed = f.read(reinterpret_cast<char*>(chunk.data()), chunk.size() * sizeof(qint16));
+                if (wave_form) {
+                    const auto readed_elements = readed / sizeof(qint16);
+                    if (readed_elements != samples_by_chunk_actual) {
+                        std::fill(std::begin(chunk) + readed_elements, std::end(chunk), 0);
+                    }
+                    wave_form->AddWaveform(start_time_current + kDateTimeOffset, chunk.data(), samples_by_chunk_actual, duration);
+                }
+
+                start_time_current += duration;
+                total_samples_by_chunk += samples_by_chunk_actual;
+            }
+        }
+    });
+
+    std::vector<qint16> chunk;
+    for (unsigned int i = 0; i < wave_forms.size(); i++) {
+        const auto& wave_form = wave_forms[i];
+        const auto expected_samples = usage.start_time.msecsTo(usage.end_time) / 1000.0 * wave_form.sample_rate;
+        if (wave_form.total_samples_by_chunk < expected_samples) {
+            chunk.resize(expected_samples - wave_form.total_samples_by_chunk);
+            if (wave_form.event_list) {
+                const auto duration = chunk.size() * 1000.0 / wave_form.sample_rate;
+                wave_form.event_list->AddWaveform(wave_form.start_time + kDateTimeOffset, chunk.data(), chunk.size(), duration);
+            }
+        }
+    }
+}
+
+void LoadStats(const UsageData& /*usage_data*/, Session* session) {
+    //    session->settings[CPAP_AHI] = usage_data.countAHI;
+    //    session->setCount(CPAP_AI, usage_data.countAI);
+    //    session->setCount(CPAP_CAI, usage_data.countCAI);
+    //    session->setCount(CPAP_HI, usage_data.countHI);
+    //    session->setCount(CPAP_Obstructive, usage_data.countOAI);
+    //    session->settings[CPAP_RERA] = usage_data.countRERA;
+    //    session->settings[CPAP_Snore] = usage_data.countSNI;
+    session->settings[CPAP_Mode] = MODE_APAP;
+}
+
+UsageData ReadUsage(const QString& session_folder_path, const QString& usage_number) {
+    UsageData usage_data;
+    usage_data.number = usage_number;
+
+    const auto session_stat_path = session_folder_path + QDir::separator() + "STAT" + usage_number;
+    if (!QFile::exists(session_stat_path)) {
+        qDebug() << "Resvent Data card has no " << session_stat_path;
+        return usage_data;
+    }
+    QFile f(session_stat_path);
+    f.open(QIODevice::ReadOnly | QIODevice::Text);
+    f.seek(4);
+    while (!f.atEnd()) {
+        QString line = f.readLine().trimmed();
+
+        const auto elems = line.split("=");
+        assert(elems.size() == 2);
+
+        if (elems[0] == "secStart") {
+            usage_data.start_time = QDateTime::fromTime_t(std::stoi(elems[1].toStdString()));
+        }
+        else if (elems[0] == "secUsed") {
+            usage_data.end_time = QDateTime::fromTime_t(usage_data.start_time.toTime_t() + std::stoi(elems[1].toStdString()));
+        }
+        else if (elems[0] == "cntAHI") {
+            usage_data.countAHI = std::stoi(elems[1].toStdString());
+        }
+        else if (elems[0] == "cntOAI") {
+            usage_data.countOAI = std::stoi(elems[1].toStdString());
+        }
+        else if (elems[0] == "cntCAI") {
+            usage_data.countCAI = std::stoi(elems[1].toStdString());
+        }
+        else if (elems[0] == "cntAI") {
+            usage_data.countAI = std::stoi(elems[1].toStdString());
+        }
+        else if (elems[0] == "cntHI") {
+            usage_data.countHI = std::stoi(elems[1].toStdString());
+        }
+        else if (elems[0] == "cntRERA") {
+            usage_data.countRERA = std::stoi(elems[1].toStdString());
+        }
+        else if (elems[0] == "cntSNI") {
+            usage_data.countSNI = std::stoi(elems[1].toStdString());
+        }
+        else if (elems[0] == "cntBreath") {
+            usage_data.countBreath = std::stoi(elems[1].toStdString());
+        }
+    }
+
+    return usage_data;
+}
+
+std::vector<UsageData> GetDifferentUsage(const QString& session_folder_path) {
+    QDir session_folder(session_folder_path);
+
+    const auto stat_files = session_folder.entryList(QStringList() << "STAT*", QDir::Files, QDir::Name);
+    std::vector<UsageData> usage_data;
+    std::for_each(stat_files.cbegin(), stat_files.cend(), [&](const QString& stat_file){
+        if (stat_file.size() != 6) {
+            return;
+        }
+
+        auto usageData = ReadUsage(session_folder_path, stat_file.right(2));
+
+        usage_data.push_back(usageData);
+    });
+    return usage_data;
+}
+
+int LoadSession(const QString& dirpath, const QDate& session_date, Machine* machine) {
+    const auto session_folder_path = GetSessionFolder(dirpath, session_date);
+
+    const auto different_usage = GetDifferentUsage(session_folder_path);
+
+    return std::accumulate(different_usage.cbegin(), different_usage.cend(), 0, [&](int base, const UsageData& usage){
+        if (machine->SessionExists(usage.start_time.toMSecsSinceEpoch() + kDateTimeOffset)) {
+            return base;
+        }
+        Session* session = new Session(machine, usage.start_time.toMSecsSinceEpoch() + kDateTimeOffset);
+        session->SetChanged(true);
+        session->really_set_first(usage.start_time.toMSecsSinceEpoch() + kDateTimeOffset);
+        session->really_set_last(usage.end_time.toMSecsSinceEpoch() + kDateTimeOffset);
+
+        LoadStats(usage, session);
+        LoadWaveForms(session_folder_path, session, usage);
+        LoadOtherWaveForms(session_folder_path, session, usage);
+        LoadEvents(session_folder_path, session, usage);
+
+        session->UpdateSummaries();
+        session->Store(machine->getDataPath());
+        machine->AddSession(session);
+        return base + 1;
+    });
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// Sorted EDF files that need processing into date records according to ResMed noon split
+///////////////////////////////////////////////////////////////////////////////////////////
+int ResventLoader::Open(const QString & dirpath)
+{
+    const auto machine_info = PeekInfo(dirpath);
+
+    // Abort if no serial number
+    if (machine_info.serial.isEmpty()) {
+        qDebug() << "Resvent Data card has no valid serial number in " << kResventSysConfigFilename;
+        return -1;
+    }
+
+    const auto sessions_date = GetSessionsDate(dirpath);
+
+    Machine *machine = p_profile->CreateMachine(machine_info);
+
+    int new_sessions = 0;
+    std::for_each(sessions_date.cbegin(), sessions_date.cend(), [&](const QDate& session_date){
+        new_sessions += LoadSession(dirpath, session_date, machine);
+    });
+
+    machine->Save();
+
+    return new_sessions;
+}
+
+void ResventLoader::initChannels()
+{
+}
+
+ChannelID ResventLoader::PresReliefMode() { return 0; }
+ChannelID ResventLoader::PresReliefLevel() { return 0; }
+ChannelID ResventLoader::CPAPModeChannel() { return 0; }
+
+bool resvent_initialized = false;
+void ResventLoader::Register()
+{
+    if (resvent_initialized) { return; }
+
+    qDebug() << "Registering ResventLoader";
+    RegisterLoader(new ResventLoader());
+
+    resvent_initialized = true;
+}
diff --git a/oscar/SleepLib/loader_plugins/resvent_loader.h b/oscar/SleepLib/loader_plugins/resvent_loader.h
new file mode 100644
index 00000000..0ccfc73f
--- /dev/null
+++ b/oscar/SleepLib/loader_plugins/resvent_loader.h
@@ -0,0 +1,76 @@
+/* SleepLib Resvent Loader Implementation
+ *
+ * Copyright (c) 2019-2023 The OSCAR Team
+ * Copyright (C) 2011-2018 Mark Watkins <mark@jedimark.net>
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of the source code
+ * for more details. */
+
+#ifndef RESVENT_LOADER_H
+#define RESVENT_LOADER_H
+
+#include <QVector>
+#include "SleepLib/machine.h" // Base class: MachineLoader
+#include "SleepLib/machine_loader.h"
+#include "SleepLib/profiles.h"
+
+//********************************************************************************************
+/// IMPORTANT!!!
+//********************************************************************************************
+// Please INCREMENT the following value when making changes to this loaders implementation.
+//
+const int resvent_data_version = 1;
+//
+//********************************************************************************************
+
+const QString resvent_class_name = "Resvent/Hoffrichter";
+
+/*! \class ResventLoader
+    \brief Importer for Resvent iBreezer and Hoffrichter Point 3
+    */
+class ResventLoader : public CPAPLoader
+{
+    Q_OBJECT
+public:
+    ResventLoader();
+    virtual ~ResventLoader();
+
+    //! \brief Detect if the given path contains a valid Folder structure
+    virtual bool Detect(const QString & path);
+
+    //! \brief Look up machine model information of ResMed file structure stored at path
+    virtual MachineInfo PeekInfo(const QString & path);
+
+    //! \brief Scans for ResMed SD folder structure signature, and loads any new data if found
+    virtual int Open(const QString &);
+
+    //! \brief Returns the version number of this Resvent loader
+    virtual int Version() { return resvent_data_version; }
+
+    //! \brief Returns the Machine class name of this loader. ("Resvent")
+    virtual const QString &loaderName() { return resvent_class_name; }
+
+    //! \brief Register the ResmedLoader with the list of other machine loaders
+    static void Register();
+
+    virtual MachineInfo newInfo() {
+        return MachineInfo(MT_CPAP, 0, resvent_class_name, QObject::tr("Resvent/Hoffrichter"), QString(), QString(), QString(), QObject::tr("iBreeze/Point3"), QDateTime::currentDateTime(), resvent_data_version);
+    }
+
+    virtual void initChannels();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Now for some CPAPLoader overrides
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    virtual QString PresReliefLabel() { return QObject::tr("EPR: "); }
+
+    virtual ChannelID PresReliefMode();
+    virtual ChannelID PresReliefLevel();
+    virtual ChannelID CPAPModeChannel();
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+};
+
+#endif // RESVENT_LOADER_H
diff --git a/oscar/icons/resvent.png b/oscar/icons/resvent.png
new file mode 100644
index 00000000..7e859d56
Binary files /dev/null and b/oscar/icons/resvent.png differ
diff --git a/oscar/main.cpp b/oscar/main.cpp
index ba2bc454..805b0858 100644
--- a/oscar/main.cpp
+++ b/oscar/main.cpp
@@ -47,6 +47,7 @@
 #include "SleepLib/loader_plugins/weinmann_loader.h"
 #include "SleepLib/loader_plugins/viatom_loader.h"
 #include "SleepLib/loader_plugins/prisma_loader.h"
+#include "SleepLib/loader_plugins/resvent_loader.h"
 
 MainWindow *mainwin = nullptr;
 
@@ -693,6 +694,7 @@ int main(int argc, char *argv[]) {
     MD300W1Loader::Register();
     ViatomLoader::Register();
     PrismaLoader::Register();
+    ResventLoader::Register();
 
     // Begin logging device connection activity.
     QString connectionsLogDir = GetLogDir() + "/connections";
diff --git a/oscar/oscar.pro b/oscar/oscar.pro
index 7ddf0687..a8aa8eae 100644
--- a/oscar/oscar.pro
+++ b/oscar/oscar.pro
@@ -320,6 +320,7 @@ SOURCES += \
     SleepLib/loader_plugins/somnopose_loader.cpp \
     SleepLib/loader_plugins/viatom_loader.cpp \
     SleepLib/loader_plugins/zeo_loader.cpp \
+    SleepLib/loader_plugins/resvent_loader.cpp \
     zip.cpp \
     SleepLib/thirdparty/miniz.c \
     csv.cpp \
@@ -426,6 +427,7 @@ HEADERS  += \
     SleepLib/loader_plugins/somnopose_loader.h \
     SleepLib/loader_plugins/viatom_loader.h \
     SleepLib/loader_plugins/zeo_loader.h \
+    SleepLib/loader_plugins/resvent_loader.h \
     SleepLib/thirdparty/botan_all.h \
     SleepLib/thirdparty/botan_windows.h \
     SleepLib/thirdparty/botan_linux.h \