diff --git a/.github/sample-roots.yaml b/.github/sample-roots.yaml
index c796b61f3..e68b94984 100644
--- a/.github/sample-roots.yaml
+++ b/.github/sample-roots.yaml
@@ -46,6 +46,9 @@ app/samples/horus:
 app/samples/compression:
   - paths:
       - "app/samples/compression/**"
+app/samples/raw_datalogger:
+    - paths:
+        - "app/samples/raw_datalogger/**"
 ALL:
   - paths:
       - "include/f_core/**"
diff --git a/app/backplane/power_module/include/c_power_module.h b/app/backplane/power_module/include/c_power_module.h
index 5cfe9374d..22e6a9b03 100644
--- a/app/backplane/power_module/include/c_power_module.h
+++ b/app/backplane/power_module/include/c_power_module.h
@@ -69,7 +69,7 @@ class CPowerModule : public CProjectConfiguration {
         "Broadcast Tenant", ipAddrStr, downlinkBroadcastPort, downlinkBroadcastPort, sensorDataDownlinkMessagePort
     };
 
-    CDataLoggerTenant<NTypes::TimestampedSensorData> dataLoggerTenant{
+    CFsDataLoggerTenant<NTypes::TimestampedSensorData> dataLoggerTenant{
         "Data Logger Tenant", "/lfs/sensor_data.bin", LogMode::Growing, 0, sensorDataLogMessagePort, K_SECONDS(60), 5
     };
     CUdpAlertTenant alertTenant{"Alert Tenant", ipAddrStr, NNetworkDefs::ALERT_PORT};
diff --git a/app/backplane/radio_module/include/c_radio_module.h b/app/backplane/radio_module/include/c_radio_module.h
index 21fd73d0e..6f69d7f5e 100644
--- a/app/backplane/radio_module/include/c_radio_module.h
+++ b/app/backplane/radio_module/include/c_radio_module.h
@@ -75,7 +75,7 @@ class CRadioModule : public CProjectConfiguration {
     CLoraTransmitTenant loraTransmitTenant{"LoRa Transmit Tenant", lora, &loraBroadcastMessagePort};
     CLoraReceiveTenant loraReceiveTenant{"LoRa Receive Tenant", loraTransmitTenant, ipAddrStr, radioModuleSourcePort};
 #endif
-    CDataLoggerTenant<NTypes::GnssData> dataLoggerTenant{"Data Logger Tenant", "/lfs/gps_data.bin", LogMode::Growing, 0, gnssDataLogMessagePort, K_SECONDS(15), 5};
+    CFsDataLoggerTenant<NTypes::GnssData> dataLoggerTenant{"Data Logger Tenant", "/lfs/gps_data.bin", LogMode::Growing, 0, gnssDataLogMessagePort, K_SECONDS(15), 5};
     CStateMachineUpdater stateMachineUpdater;
 
     // Tasks
diff --git a/app/backplane/sensor_module/.idea/editor.xml b/app/backplane/sensor_module/.idea/editor.xml
index e42167fe8..86232448b 100644
--- a/app/backplane/sensor_module/.idea/editor.xml
+++ b/app/backplane/sensor_module/.idea/editor.xml
@@ -117,6 +117,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMismatchedClassTags/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMissingIncludeGuard/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMissingKeywordThrow/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppModulePartitionWithSeveralPartitionUnits/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMsExtAddressOfClassRValue/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMsExtBindingRValueToLvalueReference/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMsExtCopyElisionInCopyInitDeclarator/@EntryIndexedValue" value="WARNING" type="string" />
diff --git a/app/backplane/sensor_module/.idea/sensor-module.iml b/app/backplane/sensor_module/.idea/sensor-module.iml
deleted file mode 100644
index f08604bb6..000000000
--- a/app/backplane/sensor_module/.idea/sensor-module.iml
+++ /dev/null
@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />
\ No newline at end of file
diff --git a/app/backplane/sensor_module/include/c_sensor_module.h b/app/backplane/sensor_module/include/c_sensor_module.h
index a7d9db5c5..cf2efbf50 100644
--- a/app/backplane/sensor_module/include/c_sensor_module.h
+++ b/app/backplane/sensor_module/include/c_sensor_module.h
@@ -71,7 +71,7 @@ class CSensorModule : public CProjectConfiguration {
     CUdpBroadcastTenant<NTypes::SensorData> broadcastTenant{"Broadcast Tenant", ipAddrStr.c_str(), telemetryBroadcastPort, telemetryBroadcastPort, sensorDataBroadcastMessagePort};
     CUdpBroadcastTenant<NTypes::LoRaBroadcastSensorData> downlinkTelemTenant{"Telemetry Downlink Tenant", ipAddrStr.c_str(), telemetryDownlinkPort, telemetryDownlinkPort, downlinkMessagePort};
     CUdpBroadcastTenant<NAlerts::AlertPacket> udpAlertTenant{"UDP Alert Tenant", ipAddrStr.c_str(), alertPort, alertPort, alertMessagePort};
-    CDataLoggerTenant<NTypes::TimestampedSensorData> dataLoggerTenant{"Data Logger Tenant", "/lfs/sensor_module_data.bin", LogMode::Growing, 0, sensorDataLogMessagePort, K_SECONDS(3), 64};
+    CFsDataLoggerTenant<NTypes::TimestampedSensorData> dataLoggerTenant{"Data Logger Tenant", "/lfs/sensor_module_data.bin", LogMode::Growing, 0, sensorDataLogMessagePort, K_SECONDS(3), 64};
 
     // Tasks
     CTask networkTask{"Networking Task", 15, 3072, 0};
diff --git a/app/backplane/sensor_module/src/c_sensor_module.cpp b/app/backplane/sensor_module/src/c_sensor_module.cpp
index 40cb8a7c2..7f5f8df9e 100644
--- a/app/backplane/sensor_module/src/c_sensor_module.cpp
+++ b/app/backplane/sensor_module/src/c_sensor_module.cpp
@@ -4,6 +4,7 @@
 #include <f_core/messaging/c_msgq_message_port.h>
 #include <f_core/os/n_rtos.h>
 #include <f_core/utils/n_time_utils.h>
+#include <f_core/os/c_raw_datalogger.h>
 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(sensor_module);
 
@@ -13,7 +14,7 @@ static auto broadcastMsgQueue = CMsgqMessagePort<NTypes::SensorData>(broadcastQu
 K_MSGQ_DEFINE(downlinkQueue, sizeof(NTypes::LoRaBroadcastSensorData), 10, 4);
 static auto downlinkMsgQueue = CMsgqMessagePort<NTypes::LoRaBroadcastSensorData>(downlinkQueue);
 
-K_MSGQ_DEFINE(dataLogQueue, sizeof(NTypes::TimestampedSensorData), 512, 4);
+K_MSGQ_DEFINE(dataLogQueue, sizeof(NTypes::TimestampedSensorData), 10, 4);
 static auto dataLogMsgQueue = CMsgqMessagePort<NTypes::TimestampedSensorData>(dataLogQueue);
 
 K_MSGQ_DEFINE(alertQueue, sizeof(NAlerts::AlertPacket), 4, 4);
diff --git a/app/other/.retired/app_potato/boards/.DELETEME b/app/other/.retired/app_potato/boards/.DELETEME
deleted file mode 100644
index e69de29bb..000000000
diff --git a/app/samples/benchmark_littlefs_datalogger/src/main.cpp b/app/samples/benchmark_littlefs_datalogger/src/main.cpp
index f8638904e..9427eac2d 100644
--- a/app/samples/benchmark_littlefs_datalogger/src/main.cpp
+++ b/app/samples/benchmark_littlefs_datalogger/src/main.cpp
@@ -73,7 +73,7 @@ template <typename T>
 void benchmarkDataloggerMode(const char *testName, const char *filePath, LogMode mode, size_t maxPackets = 1000, size_t syncFrequency = 10) {
     LOG_INF("\n\n=== %s ===", testName);
 
-    CDataLogger<T> logger(filePath, mode, maxPackets);
+    CFsDataLogger<T> logger(filePath, mode, maxPackets);
 
     uint64_t totalWriteCycles = 0;
     uint64_t totalSyncCycles = 0;
diff --git a/app/samples/datalogger/native_sim.overlay b/app/samples/datalogger/native_sim.overlay
index 88f3d9073..51733f07a 100644
--- a/app/samples/datalogger/native_sim.overlay
+++ b/app/samples/datalogger/native_sim.overlay
@@ -1,9 +1,14 @@
 / {
 	chosen {
+		flashcontroller = &flash0;
 		storage = &flash0;
 		logfs = &lfs1;
 	};
 
+	aliases {
+		storage = &flash0;
+	};
+
 
 	fstab {
 		compatible = "zephyr,fstab";
diff --git a/app/samples/datalogger/src/main.cpp b/app/samples/datalogger/src/main.cpp
index 57306627e..bcff3f61f 100644
--- a/app/samples/datalogger/src/main.cpp
+++ b/app/samples/datalogger/src/main.cpp
@@ -1,4 +1,4 @@
-#include "f_core/os/c_datalogger.h"
+#include "f_core/os/c_fs_datalogger.h"
 
 #include <zephyr/kernel.h>
 
@@ -6,9 +6,9 @@ struct Packet {
     uint8_t a;
     uint8_t b;
 };
-CDataLogger<Packet> expand_logger{"/lfs/expand.bin"};
-CDataLogger<Packet> fill_logger{"/lfs/fill.bin", LogMode::FixedSize, 10};
-CDataLogger<Packet> wrap_logger{"/lfs/wrap.bin", LogMode::Circular, 10};
+CFsDataLogger<Packet> expand_logger{"/lfs/expand.bin"};
+CFsDataLogger<Packet> fill_logger{"/lfs/fill.bin", LogMode::FixedSize, 10};
+CFsDataLogger<Packet> wrap_logger{"/lfs/wrap.bin", LogMode::Circular, 10};
 
 int main() {
     for (uint8_t i = 0; i < 100; i++) {
diff --git a/app/samples/raw_datalogger/CMakeLists.txt b/app/samples/raw_datalogger/CMakeLists.txt
new file mode 100644
index 000000000..dce9d5849
--- /dev/null
+++ b/app/samples/raw_datalogger/CMakeLists.txt
@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.20.0)
+
+set(FSW_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(raw_datalogger LANGUAGES CXX)
+
+target_compile_options(app PRIVATE -Wall -Wextra -Wno-unused-parameter -Wno-unused-function -Wno-ignored-qualifiers)
+FILE(GLOB app_sources src/*.cpp)
+target_sources(app PRIVATE ${app_sources})
diff --git a/app/samples/raw_datalogger/Kconfig b/app/samples/raw_datalogger/Kconfig
new file mode 100644
index 000000000..5ba198ca5
--- /dev/null
+++ b/app/samples/raw_datalogger/Kconfig
@@ -0,0 +1 @@
+source "Kconfig.zephyr"
diff --git a/app/samples/raw_datalogger/native_sim.overlay b/app/samples/raw_datalogger/native_sim.overlay
new file mode 100644
index 000000000..1ef2832f4
--- /dev/null
+++ b/app/samples/raw_datalogger/native_sim.overlay
@@ -0,0 +1,27 @@
+	/ {
+	chosen {
+		storage = &flash0;
+	};
+
+	aliases {
+		storage = &flash0;
+	};
+};
+
+&flashcontroller0 {
+    status = "okay";
+    compatible = "zephyr,sim-flash";
+    reg = <0x00000000 0x00100000>;
+
+    #address-cells = <1>;
+    #size-cells = <1>;
+    erase-value = <0xff>;
+
+    flash0: flash@0 {
+        status = "okay";
+        compatible = "soc-nv-flash";
+        erase-block-size = <4096>;
+        write-block-size = <1>;
+        reg = <0x00000000 0x00100000>;
+    };
+};
diff --git a/app/samples/raw_datalogger/prj.conf b/app/samples/raw_datalogger/prj.conf
new file mode 100644
index 000000000..7313e8e8a
--- /dev/null
+++ b/app/samples/raw_datalogger/prj.conf
@@ -0,0 +1,24 @@
+CONFIG_CPP=y
+CONFIG_REQUIRES_FULL_LIBCPP=y
+CONFIG_STD_CPP20=y
+
+CONFIG_F_CORE=y
+CONFIG_F_CORE_OS=y
+
+ # outputs
+CONFIG_SERIAL=y
+CONFIG_HEAP_MEM_POOL_SIZE=8192
+
+CONFIG_DEBUG=y
+CONFIG_CBPRINTF_FP_SUPPORT=y
+
+CONFIG_MAIN_STACK_SIZE=8192
+CONFIG_FLASH=y
+CONFIG_SHELL=y
+CONFIG_FLASH_SHELL=y
+CONFIG_FLASH_MAP=y
+CONFIG_FLASH_PAGE_LAYOUT=y
+CONFIG_FLASH_SIMULATOR=y
+CONFIG_STREAM_FLASH=y
+
+CONFIG_LOG=y
diff --git a/app/samples/raw_datalogger/sample.yaml b/app/samples/raw_datalogger/sample.yaml
new file mode 100644
index 000000000..ac0a7cdfe
--- /dev/null
+++ b/app/samples/raw_datalogger/sample.yaml
@@ -0,0 +1,10 @@
+sample:
+  description:
+  name: raw_datalogger
+common:
+  build_only: true
+  platform_allow:
+    - native_sim
+    - nucleo_f446re
+tests:
+  samples.template.default: {}
diff --git a/app/samples/raw_datalogger/src/main.cpp b/app/samples/raw_datalogger/src/main.cpp
new file mode 100644
index 000000000..b6b106059
--- /dev/null
+++ b/app/samples/raw_datalogger/src/main.cpp
@@ -0,0 +1,139 @@
+#include "zephyr/logging/log.h"
+
+#include <f_core/os/c_raw_datalogger.h>
+#include <zephyr/kernel.h>
+
+LOG_MODULE_REGISTER(main);
+
+struct TestData {
+    const char name[16];
+    int a;
+    int b;
+    int c;
+    int d;
+};
+
+int main() {
+    const device* flash = DEVICE_DT_GET(DT_CHOSEN(zephyr_flash_controller));
+    if (!device_is_ready(flash)) {
+        LOG_ERR("Flash device not ready!");
+        return -1;
+    } else {
+        // Print flash size
+        uint64_t flashSize = 0;
+        int ret = flash_get_size(flash, &flashSize);
+        if (ret < 0) {
+            LOG_ERR("Failed to get flash size: %d", ret);
+            return -1;
+        }
+
+        LOG_INF("Flash Size: %llu bytes", flashSize);
+    }
+    off_t start_addr = 0x00000000;
+    size_t erase_size = 0x00100000; // 1 MiB
+
+    int err = flash_erase(flash, start_addr, erase_size);
+    if (err < 0) {
+        LOG_ERR("Failed to erase flash: %d", err);
+        return -1;
+    }
+
+    // Fixed
+    off_t nextAddr = 0x00000000;
+    const int packetsInFixedFile = 5;
+    const size_t fixedFileSize = sizeof(TestData) * packetsInFixedFile + sizeof(DataloggerMetadata);
+    CRawDataLogger<TestData, 3> fixedLogger(flash, nextAddr, fixedFileSize, "test_fixed", DataloggerMode::Fixed);
+    for (int i = 0; i < packetsInFixedFile; ++i) {
+        char iter = '0' + i;
+        TestData data = { "fixed", iter, iter, iter, iter };
+        int ret = fixedLogger.Write(data);
+        if (ret < 0) {
+            LOG_ERR("Error writing data for fixed: %d", ret);
+        } else {
+            LOG_INF("Successfully wrote %d entries to fixed logger", i + 1);
+        }
+    }
+    LOG_INF("Finished writing data for fixed logger.");
+    if (fixedLogger.Write(TestData{ "fixed_overflow", 'B', 'A', 'D', '!' }) != -ENOSPC) {
+        LOG_ERR("Error: Should not have been able to write more data to fixed logger");
+    }
+
+    nextAddr += fixedFileSize;
+
+    // LinkedFixed
+    const size_t linkedFixedFileSize = (sizeof(TestData) * 5) + sizeof(DataloggerMetadata);
+    CRawDataLogger<TestData, 3> linkedFixedLogger(flash, nextAddr, linkedFixedFileSize, "test_link_fixed", DataloggerMode::LinkedFixed);
+    for (int i = 0; i < 5; ++i) {
+        char iter = '0' + i;
+        TestData data = { "linked_fixed", iter, iter, iter, iter };
+        int ret = linkedFixedLogger.Write(data);
+        if (ret < 0) {
+            LOG_ERR("Error writing data for linked fixed: %d", ret);
+        } else {
+            LOG_INF("Successfully wrote %d entries to linked fix logger", i + 1);
+        }
+    }
+
+    LOG_INF("Finished writing data for linked fixed logger.");
+
+
+    nextAddr += linkedFixedFileSize;
+    // Add a file in between to test finding next linked space using a fixed logger
+    const size_t intermediateFileSize = sizeof(TestData) + sizeof(DataloggerMetadata);
+    CRawDataLogger<TestData, 1> intermediateLogger(flash, nextAddr, intermediateFileSize, "intermediate", DataloggerMode::Fixed);
+    TestData intermediateData = { "intermediate", 'I', 'N', 'T', 'R' };
+    intermediateLogger.Write(intermediateData);
+    if (intermediateLogger.GetLastError() != 0) {
+        LOG_ERR("Error writing intermediate data: %d", intermediateLogger.GetLastError());
+    }
+
+    LOG_INF("Finished writing data for intermediate fixed logger");
+
+    // LinkedFixed should skip the intermediate file and create 2 new files consecutively
+    for (int i = 0; i < 10; ++i) {
+        char iter = '0' + i;
+
+        TestData data = { "linked_fixed2", iter, iter, iter, iter };
+        int ret = linkedFixedLogger.Write(data);
+        if (ret < 0) {
+            LOG_ERR("Error writing data for linked fixed 2: %d", ret);
+        } else {
+            LOG_INF("Successfully wrote %d entries to linked fixed logger", i + 1);
+        }
+    }
+
+    LOG_INF("Finished writing more data for linked fixed logger.");
+
+    nextAddr += intermediateFileSize + (2 * linkedFixedFileSize); // Move past the intermediate and 2 linked fixed files
+
+    // Test LinkedTruncate
+    const size_t linkedTruncateFileSize = (sizeof(TestData) * 5) + sizeof(DataloggerMetadata);
+    CRawDataLogger<TestData, 3> linkedTruncateLogger(flash, nextAddr, linkedTruncateFileSize, "test_link_trunc", DataloggerMode::LinkedTruncate);
+
+    nextAddr += ((linkedTruncateFileSize * 2) + sizeof(DataloggerMetadata)) - (sizeof(TestData) * 2); // Leave space for 2 files minus 2 entries to test truncation
+    CRawDataLogger<TestData, 1> anotherIntermediateLogger(flash, nextAddr, intermediateFileSize, "intermediate2", DataloggerMode::Fixed);
+    anotherIntermediateLogger.Write(intermediateData);
+
+    if (anotherIntermediateLogger.GetLastError() != 0) {
+        LOG_ERR("Error writing another intermediate data: %d", anotherIntermediateLogger.GetLastError());
+    }
+    LOG_INF("Finished writing data for another intermediate fixed logger");
+
+
+    for (int i = 0; i < 15; ++i) {
+        char iter = '0' + (i % 10);
+
+        TestData data = { "linked_truncate", iter, iter, iter, iter  };
+        int ret = linkedTruncateLogger.Write(data);
+
+        if (ret < 0) {
+            LOG_ERR("Error writing data for linked truncate: %d", ret);
+        } else {
+            LOG_INF("Successfully wrote %d entries to linked truncate logger", i + 1);
+        }
+    }
+
+    LOG_INF("Finished writing data for linked truncate logger");
+
+    return 0;
+}
diff --git a/include/f_core/os/c_datalogger.h b/include/f_core/os/c_fs_datalogger.h
similarity index 92%
rename from include/f_core/os/c_datalogger.h
rename to include/f_core/os/c_fs_datalogger.h
index 296dae631..dfac4eae5 100644
--- a/include/f_core/os/c_datalogger.h
+++ b/include/f_core/os/c_fs_datalogger.h
@@ -7,7 +7,7 @@
 
 enum class LogMode { Growing, Circular, FixedSize };
 
-/// @brief Internal, type-unsafe datalogger. Don't use this directly. Use CDataLogger instead
+/// @brief Internal, type-unsafe datalogger. Don't use this directly. Use CFsDataLogger instead
 namespace detail {
 class datalogger {
   public:
@@ -32,7 +32,7 @@ class datalogger {
  * This class is implemented as a type safe wrapper to detail::datalogger.
  */
 template <typename T>
-class CDataLogger {
+class CFsDataLogger {
   public:
     using PacketType = T;
     static_assert(std::is_trivially_copyable<PacketType>::value,
@@ -46,14 +46,14 @@ class CDataLogger {
      * The logger will use the "Growing" mode and will expand as you write more data until your filesystem runs out of space.
      * @param filename the name of the file to write to
      */
-    CDataLogger(const char *filename) : internal(filename, LogMode::Growing, 0) {}
+    CFsDataLogger(const char *filename) : internal(filename, LogMode::Growing, 0) {}
     /**
      * Construct a Datalogger for the specified filename, grow mode, and size
      * @param filename the name of the file to write to
      * @param mode the logging mode to use
      * @param the number of packets to log (only used if mode is Circular or FixedSize)
      */
-    CDataLogger(const char *filename, LogMode mode, std::size_t num_packets) : internal(filename, mode, num_packets) {}
+    CFsDataLogger(const char *filename, LogMode mode, std::size_t num_packets) : internal(filename, mode, num_packets) {}
 
    /**
      * Write a packet to the file
diff --git a/include/f_core/os/c_raw_datalogger.h b/include/f_core/os/c_raw_datalogger.h
new file mode 100644
index 000000000..12f91cb1d
--- /dev/null
+++ b/include/f_core/os/c_raw_datalogger.h
@@ -0,0 +1,307 @@
+#ifndef C_RAW_DATALOGGER_H
+#define C_RAW_DATALOGGER_H
+
+#include <zephyr/storage/stream_flash.h>
+#include <cstring>
+#include <string>
+#include <optional>
+#include <zephyr/kernel.h>
+#include <zephyr/sys/hash_function.h>
+
+#define RAW_DATA_LOGGER(partition_id, logname, mode) \
+CRawDataLogger(PARTITION_GET_FLASH_DEV(partition_id), PARTITION_GET_FLASH_SIZE(partition_id), PARTITION_GET_FLASH_ADDR(partition_id), logname, mode)
+
+
+enum class DataloggerMode {
+    Fixed,
+    LinkedFixed,
+    LinkedTruncate
+};
+
+static constexpr size_t LOG_NAME_SIZE = 14;
+struct DataloggerMetadata {
+    uint32_t logNameHash; // Hash logName as a way to check for metadata
+    char logName[LOG_NAME_SIZE + 1];
+    uint8_t version;
+    size_t packetSize;
+    size_t allocatedSize;
+    size_t nextLogAddress;
+};
+
+constexpr uint32_t DATALOGGER_VERSION = 1;
+
+template <typename T, size_t numPacketsInBuffer>
+class CRawDataLogger {
+public:
+    /**
+     * Constructor
+     * @param flashDev Flash device to write to.
+     *                 It is highly recommended to use the flash_area struct's device if you want partitioning
+     * @param flashAddress Starting address in flash to write log
+     * @param logSize Total size of log including metadata
+     * @param logName Name of the log (for metadata)
+     * @param mode Datalogger mode (Fixed, LinkedFixed, LinkedTruncate)
+     */
+    explicit CRawDataLogger(const device* flashDev, const off_t flashAddress, const off_t logSize, const std::string& logName, const DataloggerMode mode)
+        : flash(flashDev), mode(mode), originalLogSize(logSize), lastError(0), initialized(false), flashAddress(flashAddress),
+          currentLogSize(logSize), currentOffset(sizeof(DataloggerMetadata)), nextLogAddress(0) {
+        resetBuffers();
+
+        int ret = flash_get_size(flash, &flashSize);
+        if (ret < 0) {
+            lastError = ret;
+            initialized = false;
+        }
+
+        ret = prepMetadata(logName);
+        if (ret < 0) {
+            lastError = ret;
+            return;
+        }
+
+        initialized = true;
+        currentOffset = sizeof(metadata);
+
+        ret = stream_flash_init(&ctx, flash, buffer, sizeof(buffer), flashAddress + sizeof(metadata),
+                                logSize - sizeof(metadata), nullptr);
+        if (ret < 0) {
+            lastError = ret;
+            initialized = false;
+        }
+    }
+
+    /**
+     * Destructor ensuring any buffered data is flushed
+     * This is more for testing, since this lifetime of this class will most likely be forever in real-world applications
+     */
+    ~CRawDataLogger() {
+        if (initialized) {
+            stream_flash_buffered_write(&ctx, nullptr, 0, true);
+        }
+    }
+
+    /**
+     * Write data to the buffer which will flush to flash as needed
+     * @param data Data to write
+     * @return 0 on success, negative errno code on failure
+     */
+    int Write(const T& data) {
+        if (!initialized) return lastError ? lastError : -1;
+        size_t spaceLeft = currentLogSize - currentOffset;
+
+        if (spaceLeft < sizeof(T)) {
+            resetBuffers();
+
+            int ret = 0;
+
+            switch (mode) {
+                case DataloggerMode::Fixed:
+                    return -ENOSPC;
+                case DataloggerMode::LinkedFixed:
+                case DataloggerMode::LinkedTruncate:
+                    ret = seekAndUpdateMetadata();
+                    if (ret < 0) {
+                        lastError = ret;
+                        return ret;
+                    }
+
+                    ret = stream_flash_init(&ctx, flash, buffer, sizeof(buffer), flashAddress + sizeof(metadata),
+                                      currentLogSize - sizeof(metadata), nullptr);
+                    if (ret < 0) {
+                        lastError = ret;
+                        return ret;
+                    }
+
+                    currentOffset = sizeof(metadata);
+            }
+        }
+
+        const bool flush = (spaceLeft - sizeof(T)) < sizeof(T);
+        int ret = stream_flash_buffered_write(&ctx, reinterpret_cast<const uint8_t*>(&data), sizeof(T), flush);
+        if (ret < 0) {
+            lastError = ret;
+            return ret;
+        }
+        currentOffset += sizeof(T);
+        return 0;
+    }
+
+
+    /**
+     * Getter to check if the datalogger was initialized successfully
+     * @return true if initialized, false otherwise
+     */
+    bool IsInitialized() const { return initialized; }
+
+    /**
+     * Getter for last error code
+     * @return Last error code encountered, 0 if no error
+     */
+    int GetLastError() const { return lastError; }
+
+private:
+    const device* flash;
+    const DataloggerMode mode;
+    const size_t originalLogSize;
+    uint64_t flashSize{};
+
+    int lastError;
+    bool initialized;
+
+    uint8_t buffer[numPacketsInBuffer * sizeof(T)]{};
+    stream_flash_ctx ctx{};
+
+    DataloggerMetadata metadata{};
+    size_t flashAddress;
+    size_t currentLogSize;
+    size_t currentOffset;
+    size_t nextLogAddress;
+
+    /**
+     * Prepare and write metadata to flash
+     * @param logName Log name for metadata
+     * @return 0 on success, negative errno code on failure
+     */
+    int prepMetadata(const std::string& logName) {
+        memset(&metadata, 0, sizeof(metadata));
+        strncpy(metadata.logName, logName.c_str(), LOG_NAME_SIZE);
+        metadata.logName[LOG_NAME_SIZE + 1] = '\0';
+        metadata.allocatedSize = currentLogSize;
+        metadata.version = DATALOGGER_VERSION;
+        metadata.packetSize = sizeof(T);
+        metadata.nextLogAddress = 0;
+        metadata.logNameHash = sys_hash32_murmur3(metadata.logName, LOG_NAME_SIZE);
+
+        // DO NOT WRITE nextLogAddress IF ZERO AND MODE IS LINKED. This is so we can write nextAddr later, without an erase
+        const size_t len = sizeof(metadata) - sizeof(metadata.nextLogAddress);
+
+        return flash_write(flash, flashAddress, &metadata, len);
+    }
+
+    /**
+     * Link the current log to the next log by writing the address into the current log's metadata
+     * @param addr Address to link to as the next log
+     * @return 0 on success, negative errno code on failure, -1 if mode is not linked
+     */
+    int linkToNextLog(const size_t addr) {
+        if (mode != DataloggerMode::LinkedFixed && mode != DataloggerMode::LinkedTruncate) return -1;
+        return flash_write(flash, flashAddress + offsetof(DataloggerMetadata, nextLogAddress),
+                           &addr, sizeof(metadata.nextLogAddress));
+    }
+
+    /**
+     * Attempt to read metadata from flash and validate it
+     * @param addr Address to read metadata from
+     * @param outMeta Output metadata structure
+     * @return 0 on success, negative errno code on failure, -1 if metadata is invalid (bad hash)
+     */
+    int readMetadata(const off_t addr, DataloggerMetadata& outMeta) {
+        int ret = flash_read(flash, addr, &outMeta, sizeof(DataloggerMetadata));
+        if (ret < 0) {
+            return ret;
+        }
+
+        if (outMeta.logNameHash == sys_hash32_murmur3(outMeta.logName, LOG_NAME_SIZE)) {
+            return 0;
+        }
+
+        return -1;
+    }
+
+    /**
+     * Linear search for the next valid metadata structure in flash
+     * @param startAddr Address to start searching from
+     * @param maxAddr Address to stop searching at
+     * @return Address of next valid metadata, or maxAddr if none found
+     */
+    size_t findNextMetadata(const off_t startAddr, const off_t maxAddr) {
+        DataloggerMetadata meta{};
+        for (off_t addr = startAddr; static_cast<off_t>(addr + sizeof(DataloggerMetadata)) < maxAddr;
+            addr += sizeof(DataloggerMetadata)) {
+            if (readMetadata(addr, meta) == 0) {
+                return addr;
+            }
+        }
+        return maxAddr;
+    }
+
+    /**
+     * Reset internal buffers and context
+     */
+    void resetBuffers() {
+        memset(&ctx, 0, sizeof(ctx));
+        memset(&buffer, 0, sizeof(buffer));
+    }
+
+    /**
+     * Find the next available space for a linked log
+     * @return Optional pair of (address, size) for the next linked log space, or nullopt if none found or not in linked mode
+     */
+    std::optional<std::pair<size_t, size_t>> findLinkedSpace() {
+        if (mode != DataloggerMode::LinkedFixed && mode != DataloggerMode::LinkedTruncate) return std::nullopt;
+        size_t addr = flashAddress + currentLogSize;
+        size_t logSz = originalLogSize;
+        DataloggerMetadata meta{};
+
+        while (addr + sizeof(DataloggerMetadata) < flashSize) {
+            int ret = readMetadata(addr, meta);
+
+            if (ret == 0) {
+                // Metadata found, jump to next log boundary
+                addr += meta.allocatedSize;
+            } else {
+                // No metadata found
+                // Check if enough space for a new log
+                for (size_t testAddr = addr; testAddr < addr + logSz; testAddr += 0x10) {
+                    if (readMetadata(testAddr, meta) == 0) {
+                        if (mode == DataloggerMode::LinkedTruncate) {
+                            logSz = (testAddr - addr); // Shrink log size to fit
+                            return std::make_pair(addr, MIN(logSz, flashSize - addr));
+                        }
+
+                        // Found metadata in the range, cannot use this space
+                        addr = testAddr + meta.allocatedSize; // Move to next possible log start
+                        break;
+                    }
+                }
+                return std::make_pair(addr, logSz);
+            }
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * Seek to the next available linked log space and update metadata accordingly
+     * @return 0 on success, negative errno code on failure
+     */
+    int seekAndUpdateMetadata() {
+        auto spaceOpt = findLinkedSpace();
+        if (!spaceOpt.has_value()) {
+            lastError = -ENOSPC;
+            return -ENOSPC;
+        }
+
+        size_t newAddr = spaceOpt.value().first;
+        size_t newSize = spaceOpt.value().second;
+
+        int ret = linkToNextLog(newAddr);
+        if (ret < 0) {
+            lastError = ret;
+            return ret;
+        }
+
+        // Set up new log
+        flashAddress = newAddr; // Update flash address to new log
+        currentLogSize = newSize;
+        ret = prepMetadata(metadata.logName);
+        if (ret < 0) {
+            lastError = ret;
+            return ret;
+        }
+
+        currentOffset = sizeof(metadata);
+        return 0;
+    }
+};
+
+#endif //C_RAW_DATALOGGER_H
\ No newline at end of file
diff --git a/include/f_core/os/tenants/c_datalogger_tenant.h b/include/f_core/os/tenants/c_datalogger_tenant.h
index 7b2689643..7cfd83c8e 100644
--- a/include/f_core/os/tenants/c_datalogger_tenant.h
+++ b/include/f_core/os/tenants/c_datalogger_tenant.h
@@ -4,21 +4,22 @@
 #include "f_core/os/n_rtos.h"
 
 #include <f_core/messaging/c_message_port.h>
+#include <f_core/os/c_tenant.h>
 #include <f_core/os/c_runnable_tenant.h>
-#include <f_core/os/c_datalogger.h>
+#include <f_core/os/c_fs_datalogger.h>
 #include <f_core/utils/c_soft_timer.h>
 #include <zephyr/logging/log.h>
 
 
 template <typename T>
-class CDataLoggerTenant : public CRunnableTenant {
+class CFsDataLoggerTenant : public CRunnableTenant {
 public:
-    explicit CDataLoggerTenant(const char* name, const char* filename, LogMode mode, std::size_t numPackets,
+    explicit CFsDataLoggerTenant(const char* name, const char* filename, LogMode mode, std::size_t numPackets,
                       CMessagePort<T>& messagePort, k_timeout_t syncTimeout = K_FOREVER, int syncOnCount = 0)
         : CRunnableTenant(name), messagePort(messagePort), dataLogger(filename, mode, numPackets), filename(filename),
           syncTimeout(syncTimeout), syncOnCount(syncOnCount) {}
 
-    ~CDataLoggerTenant() override {
+    ~CFsDataLoggerTenant() override {
         Cleanup();
     }
 
@@ -55,7 +56,7 @@ class CDataLoggerTenant : public CRunnableTenant {
 
 private:
     CMessagePort<T>& messagePort;
-    CDataLogger<T> dataLogger;
+    CFsDataLogger<T> dataLogger;
     const char* filename;
 
     // FS Sync after every X time
diff --git a/lib/f_core/Kconfig b/lib/f_core/Kconfig
index 817a97786..c4edd36fd 100644
--- a/lib/f_core/Kconfig
+++ b/lib/f_core/Kconfig
@@ -35,6 +35,8 @@ config F_CORE_OS
     bool "OS"
     help
       This option enables OS functionality for F-Core
+    select SYS_HASH_FUNC32
+    select SYS_HASH_FUNC32_MURMUR3
 
 config F_CORE_UTILS
     bool "Utility"
diff --git a/lib/f_core/os/c_datalogger.cpp b/lib/f_core/os/c_fs_datalogger.cpp
similarity index 97%
rename from lib/f_core/os/c_datalogger.cpp
rename to lib/f_core/os/c_fs_datalogger.cpp
index f38a13a20..df8f293de 100644
--- a/lib/f_core/os/c_datalogger.cpp
+++ b/lib/f_core/os/c_fs_datalogger.cpp
@@ -1,4 +1,4 @@
-#include <f_core/os/c_datalogger.h>
+#include <f_core/os/c_fs_datalogger.h>
 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(datalogger);
 
diff --git a/west.yml b/west.yml
index ad88f20b1..8993a946e 100644
--- a/west.yml
+++ b/west.yml
@@ -19,9 +19,9 @@ manifest:
           - hal_st
           - hal_stm32
           - hal_nxp
+          - fatfs
           - littlefs
           - loramac-node
-          - hal_st
           - segger
           - percepio
           - lz4