diff --git a/.clang-format b/.clang-format
index d43e884..28e3328 100644
--- a/.clang-format
+++ b/.clang-format
@@ -87,7 +87,7 @@
 IndentWrappedFunctionNames: true
 InsertNewlineAtEOF: true
 KeepEmptyLinesAtTheStartOfBlocks: false
-LambdaBodyIndentation: OuterScope
+LambdaBodyIndentation: Signature
 LineEnding: LF
 MacroBlockBegin: ''
 MacroBlockEnd:   ''
@@ -98,13 +98,14 @@
 ObjCSpaceBeforeProtocolList: true
 PackConstructorInitializers: BinPack
 PenaltyBreakAssignment: 25
-PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakBeforeFirstCallParameter: 50
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
-PenaltyIndentedWhitespace: 0
+PenaltyIndentedWhitespace: 1
 PointerAlignment: Left
 QualifierAlignment: Left
 ReferenceAlignment: Left
diff --git a/src/buffer.cpp b/src/buffer.cpp
index c6cec94..20427cb 100644
--- a/src/buffer.cpp
+++ b/src/buffer.cpp
@@ -21,7 +21,7 @@
 {
 
 BufferImpl::BufferImpl(std::unique_ptr<DataInterface> dataInterface) :
-    dataInterface(std::move(dataInterface)){};
+    dataInterface(std::move(dataInterface)) {};
 
 void BufferImpl::initialize(uint32_t bmcInterfaceVersion, uint16_t queueSize,
                             uint16_t ueRegionSize,
@@ -55,16 +55,16 @@
     std::transform(magicNumber.begin(), magicNumber.end(),
                    initializationHeader.magicNumber.begin(),
                    [](uint32_t number) -> little_uint32_t {
-        return boost::endian::native_to_little(number);
-    });
+                       return boost::endian::native_to_little(number);
+                   });
 
     uint8_t* initializationHeaderPtr =
         reinterpret_cast<uint8_t*>(&initializationHeader);
     size_t initializationHeaderSize = sizeof(initializationHeader);
     byteWritten = dataInterface->write(
-        0, std::span<const uint8_t>(initializationHeaderPtr,
-                                    initializationHeaderPtr +
-                                        initializationHeaderSize));
+        0, std::span<const uint8_t>(
+               initializationHeaderPtr,
+               initializationHeaderPtr + initializationHeaderSize));
     if (byteWritten != initializationHeaderSize)
     {
         throw std::runtime_error(std::format(
@@ -76,8 +76,8 @@
 void BufferImpl::readBufferHeader()
 {
     size_t headerSize = sizeof(struct CircularBufferHeader);
-    std::vector<uint8_t> bytesRead = dataInterface->read(/*offset=*/0,
-                                                         headerSize);
+    std::vector<uint8_t> bytesRead =
+        dataInterface->read(/*offset=*/0, headerSize);
 
     if (bytesRead.size() != headerSize)
     {
@@ -97,8 +97,8 @@
 
 void BufferImpl::updateReadPtr(const uint32_t newReadPtr)
 {
-    constexpr uint8_t bmcReadPtrOffset = offsetof(struct CircularBufferHeader,
-                                                  bmcReadPtr);
+    constexpr uint8_t bmcReadPtrOffset =
+        offsetof(struct CircularBufferHeader, bmcReadPtr);
 
     little_uint24_t truncatedReadPtr =
         boost::endian::native_to_little(newReadPtr & 0xffffff);
@@ -120,8 +120,8 @@
 
 void BufferImpl::updateBmcFlags(const uint32_t newBmcFlag)
 {
-    constexpr uint8_t bmcFlagsPtrOffset = offsetof(struct CircularBufferHeader,
-                                                   bmcFlags);
+    constexpr uint8_t bmcFlagsPtrOffset =
+        offsetof(struct CircularBufferHeader, bmcFlags);
 
     little_uint32_t littleNewBmcFlag =
         boost::endian::native_to_little(newBmcFlag);
diff --git a/src/pci_handler.cpp b/src/pci_handler.cpp
index 368b403..0936032 100644
--- a/src/pci_handler.cpp
+++ b/src/pci_handler.cpp
@@ -18,8 +18,7 @@
 
 PciDataHandler::PciDataHandler(uint32_t regionAddress, size_t regionSize,
                                std::unique_ptr<stdplus::fd::Fd> fd) :
-    regionSize(regionSize),
-    fd(std::move(fd)),
+    regionSize(regionSize), fd(std::move(fd)),
     mmap(stdplus::fd::MMap(
         *this->fd, regionSize, stdplus::fd::ProtFlags{PROT_READ | PROT_WRITE},
         stdplus::fd::MMapFlags{stdplus::fd::MMapAccess::Shared}, regionAddress))
@@ -38,8 +37,8 @@
     }
 
     // Read up to regionSize in case the offset + length overflowed
-    uint32_t finalLength = (offset + length < regionSize) ? length
-                                                          : regionSize - offset;
+    uint32_t finalLength =
+        (offset + length < regionSize) ? length : regionSize - offset;
     std::vector<uint8_t> results(finalLength);
 
     std::memcpy(results.data(), mmap.get().data() + offset, finalLength);
@@ -60,8 +59,8 @@
     }
 
     // Write up to regionSize in case the offset + length overflowed
-    uint16_t finalLength = (offset + length < regionSize) ? length
-                                                          : regionSize - offset;
+    uint16_t finalLength =
+        (offset + length < regionSize) ? length : regionSize - offset;
     std::memcpy(mmap.get().data() + offset, bytes.data(), finalLength);
     return finalLength;
 }
diff --git a/src/rde/external_storer_file.cpp b/src/rde/external_storer_file.cpp
index 6a162ed..5cc14cf 100644
--- a/src/rde/external_storer_file.cpp
+++ b/src/rde/external_storer_file.cpp
@@ -48,8 +48,7 @@
 ExternalStorerFileInterface::ExternalStorerFileInterface(
     sdbusplus::bus_t& bus, std::string_view rootPath,
     std::unique_ptr<FileHandlerInterface> fileHandler) :
-    rootPath(rootPath),
-    fileHandler(std::move(fileHandler)), logServiceId(""),
+    rootPath(rootPath), fileHandler(std::move(fileHandler)), logServiceId(""),
     cperNotifier(std::make_unique<CperFileNotifierHandler>(bus))
 {}
 
diff --git a/src/rde/rde_dictionary_manager.cpp b/src/rde/rde_dictionary_manager.cpp
index 0904fad..aa92c51 100644
--- a/src/rde/rde_dictionary_manager.cpp
+++ b/src/rde/rde_dictionary_manager.cpp
@@ -18,8 +18,8 @@
     auto itemIt = dictionaries.find(resourceId);
     if (itemIt == dictionaries.end())
     {
-        dictionaries[resourceId] = std::make_unique<DictionaryEntry>(false,
-                                                                     data);
+        dictionaries[resourceId] =
+            std::make_unique<DictionaryEntry>(false, data);
         return;
     }
 
diff --git a/src/rde/rde_handler.cpp b/src/rde/rde_handler.cpp
index fd8ed0a..2b8a1e4 100644
--- a/src/rde/rde_handler.cpp
+++ b/src/rde/rde_handler.cpp
@@ -26,9 +26,8 @@
     calcCrcTable();
 }
 
-RdeDecodeStatus
-    RdeCommandHandler::decodeRdeCommand(std::span<const uint8_t> rdeCommand,
-                                        RdeCommandType type)
+RdeDecodeStatus RdeCommandHandler::decodeRdeCommand(
+    std::span<const uint8_t> rdeCommand, RdeCommandType type)
 {
     if (type == RdeCommandType::RdeMultiPartReceiveResponse)
     {
@@ -98,9 +97,9 @@
 
     // Soon after header, we have bejLocator field. Then we have the encoded
     // data.
-    const uint8_t* encodedPldmBlock = rdeCommand.data() +
-                                      sizeof(RdeOperationInitReqHeader) +
-                                      header->operationLocatorLength;
+    const uint8_t* encodedPldmBlock =
+        rdeCommand.data() + sizeof(RdeOperationInitReqHeader) +
+        header->operationLocatorLength;
 
     // Decoded the data.
     if (decoder.decode(dictionaries, std::span(encodedPldmBlock,
@@ -197,9 +196,9 @@
     const MultipartReceiveResHeader* header =
         reinterpret_cast<const MultipartReceiveResHeader*>(
             multiReceiveRespCmd.data());
-    const uint8_t* checksumPtr = multiReceiveRespCmd.data() +
-                                 sizeof(MultipartReceiveResHeader) +
-                                 header->dataLengthBytes;
+    const uint8_t* checksumPtr =
+        multiReceiveRespCmd.data() + sizeof(MultipartReceiveResHeader) +
+        header->dataLengthBytes;
     uint32_t checksum = checksumPtr[0] | (checksumPtr[1] << 8) |
                         (checksumPtr[2] << 16) | (checksumPtr[3] << 24);
 
@@ -226,10 +225,9 @@
     flagState = RdeDictTransferFlagState::RdeStateStartRecvd;
 }
 
-RdeDecodeStatus
-    RdeCommandHandler::handleFlagMiddle(const MultipartReceiveResHeader* header,
-                                        const uint8_t* data,
-                                        uint32_t resourceId)
+RdeDecodeStatus RdeCommandHandler::handleFlagMiddle(
+    const MultipartReceiveResHeader* header, const uint8_t* data,
+    uint32_t resourceId)
 {
     if (flagState != RdeDictTransferFlagState::RdeStateStartRecvd)
     {
@@ -264,10 +262,10 @@
     return RdeDecodeStatus::RdeOk;
 }
 
-RdeDecodeStatus
-    RdeCommandHandler::handleFlagEnd(std::span<const uint8_t> rdeCommand,
-                                     const MultipartReceiveResHeader* header,
-                                     const uint8_t* data, uint32_t resourceId)
+RdeDecodeStatus RdeCommandHandler::handleFlagEnd(
+    std::span<const uint8_t> rdeCommand,
+    const MultipartReceiveResHeader* header, const uint8_t* data,
+    uint32_t resourceId)
 {
     if (flagState != RdeDictTransferFlagState::RdeStateStartRecvd)
     {
diff --git a/test/buffer_test.cpp b/test/buffer_test.cpp
index c09a926..3c8007a 100644
--- a/test/buffer_test.cpp
+++ b/test/buffer_test.cpp
@@ -36,8 +36,8 @@
         std::transform(testMagicNumber.begin(), testMagicNumber.end(),
                        testInitializationHeader.magicNumber.begin(),
                        [](uint32_t number) -> little_uint32_t {
-            return boost::endian::native_to_little(number);
-        });
+                           return boost::endian::native_to_little(number);
+                       });
     }
     ~BufferTest() override = default;
 
@@ -132,9 +132,9 @@
                 write(0, ElementsAreArray(testInitializationHeaderPtr,
                                           bufferHeaderSize)))
         .WillOnce(Return(bufferHeaderSize));
-    EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
-                                           testQueueSize, testUeRegionSize,
-                                           testMagicNumber));
+    EXPECT_NO_THROW(
+        bufferImpl->initialize(testBmcInterfaceVersion, testQueueSize,
+                               testUeRegionSize, testMagicNumber));
     EXPECT_EQ(bufferImpl->getCachedBufferHeader(), testInitializationHeader);
 }
 
@@ -252,9 +252,9 @@
 
     EXPECT_CALL(*dataInterfaceMockPtr, write(0, _))
         .WillOnce(Return(bufferHeaderSize));
-    EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
-                                           wrongQueueSize, testUeRegionSize,
-                                           testMagicNumber));
+    EXPECT_NO_THROW(
+        bufferImpl->initialize(testBmcInterfaceVersion, wrongQueueSize,
+                               testUeRegionSize, testMagicNumber));
     EXPECT_THROW(
         try {
             bufferImpl->getMaxOffset();
@@ -279,9 +279,9 @@
 
     EXPECT_CALL(*dataInterfaceMockPtr, write(0, _))
         .WillOnce(Return(bufferHeaderSize));
-    EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
-                                           testQueueSize, testUeRegionSize + 1,
-                                           testMagicNumber));
+    EXPECT_NO_THROW(
+        bufferImpl->initialize(testBmcInterfaceVersion, testQueueSize,
+                               testUeRegionSize + 1, testMagicNumber));
     EXPECT_THROW(
         try {
             bufferImpl->getMaxOffset();
@@ -307,9 +307,9 @@
 
     EXPECT_CALL(*dataInterfaceMockPtr, write(0, _))
         .WillOnce(Return(bufferHeaderSize));
-    EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
-                                           testQueueSize, testUeRegionSize - 1,
-                                           testMagicNumber));
+    EXPECT_NO_THROW(
+        bufferImpl->initialize(testBmcInterfaceVersion, testQueueSize,
+                               testUeRegionSize - 1, testMagicNumber));
     EXPECT_THROW(
         try {
             bufferImpl->getQueueOffset();
@@ -344,16 +344,16 @@
 
         EXPECT_CALL(*dataInterfaceMockPtr, write(0, _))
             .WillOnce(Return(bufferHeaderSize));
-        EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
-                                               testQueueSize, testUeRegionSize,
-                                               testMagicNumber));
+        EXPECT_NO_THROW(
+            bufferImpl->initialize(testBmcInterfaceVersion, testQueueSize,
+                                   testUeRegionSize, testMagicNumber));
     }
     static constexpr size_t expectedWriteSize = 3;
     static constexpr uint8_t expectedBmcReadPtrOffset = 0x21;
     static constexpr size_t expectedqueueOffset = 0x30 + testUeRegionSize;
 
-    static constexpr size_t testMaxOffset = testQueueSize - testUeRegionSize -
-                                            sizeof(struct CircularBufferHeader);
+    static constexpr size_t testMaxOffset =
+        testQueueSize - testUeRegionSize - sizeof(struct CircularBufferHeader);
     uint8_t* testInitializationHeaderPtr =
         reinterpret_cast<uint8_t*>(&testInitializationHeader);
 };
@@ -699,9 +699,9 @@
     initializeFuncMock();
 
     EXPECT_CALL(*dataInterfaceMockPtr, read(0, bufferHeaderSize))
-        .WillOnce(Return(std::vector<uint8_t>(testInitializationHeaderPtr,
-                                              testInitializationHeaderPtr +
-                                                  bufferHeaderSize)));
+        .WillOnce(Return(std::vector<uint8_t>(
+            testInitializationHeaderPtr,
+            testInitializationHeaderPtr + bufferHeaderSize)));
     EXPECT_THROW(
         try {
             bufferImpl->readErrorLogs();
@@ -721,9 +721,9 @@
     initializeFuncMock();
 
     EXPECT_CALL(*dataInterfaceMockPtr, read(0, bufferHeaderSize))
-        .WillOnce(Return(std::vector<uint8_t>(testInitializationHeaderPtr,
-                                              testInitializationHeaderPtr +
-                                                  bufferHeaderSize)));
+        .WillOnce(Return(std::vector<uint8_t>(
+            testInitializationHeaderPtr,
+            testInitializationHeaderPtr + bufferHeaderSize)));
     EXPECT_THROW(
         try {
             bufferImpl->readErrorLogs();
@@ -738,9 +738,9 @@
 TEST_F(BufferReadErrorLogsTest, IdenticalPtrsPass)
 {
     EXPECT_CALL(*dataInterfaceMockPtr, read(0, bufferHeaderSize))
-        .WillOnce(Return(std::vector<uint8_t>(testInitializationHeaderPtr,
-                                              testInitializationHeaderPtr +
-                                                  bufferHeaderSize)));
+        .WillOnce(Return(std::vector<uint8_t>(
+            testInitializationHeaderPtr,
+            testInitializationHeaderPtr + bufferHeaderSize)));
     EXPECT_NO_THROW(bufferImpl->readErrorLogs());
 }
 
@@ -752,9 +752,9 @@
         boost::endian::native_to_little((entryAndHeaderSize));
     initializeFuncMock();
     EXPECT_CALL(*dataInterfaceMockPtr, read(0, bufferHeaderSize))
-        .WillOnce(Return(std::vector<uint8_t>(testInitializationHeaderPtr,
-                                              testInitializationHeaderPtr +
-                                                  bufferHeaderSize)));
+        .WillOnce(Return(std::vector<uint8_t>(
+            testInitializationHeaderPtr,
+            testInitializationHeaderPtr + bufferHeaderSize)));
     std::vector<uint8_t> testEntryHeaderVector(
         testEntryHeaderPtr, testEntryHeaderPtr + entryHeaderSize);
     std::vector<uint8_t> testEntryVector(testEntrySize);
@@ -781,9 +781,9 @@
     testInitializationHeader.biosWritePtr = entryAndHeaderSize;
     initializeFuncMock();
     EXPECT_CALL(*dataInterfaceMockPtr, read(0, bufferHeaderSize))
-        .WillOnce(Return(std::vector<uint8_t>(testInitializationHeaderPtr,
-                                              testInitializationHeaderPtr +
-                                                  bufferHeaderSize)));
+        .WillOnce(Return(std::vector<uint8_t>(
+            testInitializationHeaderPtr,
+            testInitializationHeaderPtr + bufferHeaderSize)));
 
     std::vector<uint8_t> testEntryHeaderVector(
         testEntryHeaderPtr, testEntryHeaderPtr + entryHeaderSize);
@@ -819,9 +819,9 @@
         boost::endian::native_to_little(entryAndHeaderSize - 1);
     initializeFuncMock();
     EXPECT_CALL(*dataInterfaceMockPtr, read(0, bufferHeaderSize))
-        .WillOnce(Return(std::vector<uint8_t>(testInitializationHeaderPtr,
-                                              testInitializationHeaderPtr +
-                                                  bufferHeaderSize)));
+        .WillOnce(Return(std::vector<uint8_t>(
+            testInitializationHeaderPtr,
+            testInitializationHeaderPtr + bufferHeaderSize)));
 
     std::vector<uint8_t> testEntryHeaderVector(
         testEntryHeaderPtr, testEntryHeaderPtr + entryHeaderSize);
diff --git a/test/pci_handler_test.cpp b/test/pci_handler_test.cpp
index 817fc8f..310141b 100644
--- a/test/pci_handler_test.cpp
+++ b/test/pci_handler_test.cpp
@@ -25,9 +25,9 @@
 {
   protected:
     PciHandlerTest() :
-        testMapped({std::byte(0), std::byte(11), std::byte(22), std::byte(33),
-                    std::byte(44), std::byte(55), std::byte(66),
-                    std::byte(77)}),
+        testMapped(
+            {std::byte(0), std::byte(11), std::byte(22), std::byte(33),
+             std::byte(44), std::byte(55), std::byte(66), std::byte(77)}),
         fdMock(std::make_unique<stdplus::fd::FdMock>()), fdMockPtr(fdMock.get())
     {
         // Verify that the constructor is called as expected