From 9d063d8c9ced0c769385bf252f610577abb8acd9 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Tue, 6 Oct 2026 06:28:05 -0700
Subject: [PATCH 01/38] Bump version to 0.85.0-dev.1

---
 ASWLog/ASWLog_Version.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ASWLog/ASWLog_Version.h b/ASWLog/ASWLog_Version.h
index 298c254..663dddc 100644
--- a/ASWLog/ASWLog_Version.h
+++ b/ASWLog/ASWLog_Version.h
@@ -34,10 +34,10 @@ limitations under the License.
 // ASWLOG_VERSION_STRING is "MAJOR.MINOR.PATCH", followed by "-PRERELEASE" if the pre-release isn't empty; change
 // them together (a unit test checks that they match).
 #define ASWLOG_VERSION_MAJOR 0
-#define ASWLOG_VERSION_MINOR 75
+#define ASWLOG_VERSION_MINOR 85
 #define ASWLOG_VERSION_PATCH 0
-#define ASWLOG_VERSION_PRERELEASE ""
-#define ASWLOG_VERSION_STRING "0.75.0"
+#define ASWLOG_VERSION_PRERELEASE "dev.1"
+#define ASWLOG_VERSION_STRING "0.85.0-dev.1"
 
 namespace ASWLog
 {

From 275e0e118b06829a0a4a25488c46eddd6683d1a2 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Tue, 6 Oct 2026 07:21:23 -0700
Subject: [PATCH 02/38] Format the default line's fields without std::format

Tests showed a ~60% improved meta-data line build speed
---
 ASWLog/ASWLog_CrashHandler.cpp        | 23 ++-----
 ASWLog/ASWLog_Formatter.cpp           | 50 +++++++++++++--
 ASWLog/ASWLog_Utils.cpp               | 92 +++++++++++++++++----------
 ASWLog/ASWLog_Utils.h                 | 15 +++++
 CHANGELOG.md                          | 14 ++++
 tests/tests/Test_ASWLog_Formatter.cpp | 37 +++++++++++
 tests/tests/Test_ASWLog_Formatter.h   |  1 +
 tests/tests/Test_ASWLog_Utils.cpp     | 38 +++++++++++
 tests/tests/Test_ASWLog_Utils.h       |  1 +
 9 files changed, 213 insertions(+), 58 deletions(-)

diff --git a/ASWLog/ASWLog_CrashHandler.cpp b/ASWLog/ASWLog_CrashHandler.cpp
index e6c2217..5adae5a 100644
--- a/ASWLog/ASWLog_CrashHandler.cpp
+++ b/ASWLog/ASWLog_CrashHandler.cpp
@@ -47,6 +47,7 @@ limitations under the License.
 #endif
 //---------------------------------------------------------------------------
 #include "ASWLog_TextLogBase.h"
+#include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
 
 namespace ASWLog
@@ -592,25 +593,9 @@ void TCrashText::AppendHex(std::uint64_t value, int minDigits) noexcept
 //---------------------------------------------------------------------------
 void TCrashText::AppendISO8601(std::chrono::system_clock::time_point time) noexcept
 {
-    // Calendar arithmetic only, which doesn't allocate (unlike Time::ToISO8601String())
-    const auto day = std::chrono::floor<std::chrono::days>(time);
-    const std::chrono::year_month_day date{ day };
-    const auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(time - day).count();
-
-    AppendDecimal(static_cast<std::uint64_t>(static_cast<int>(date.year())), 4);
-    Append("-");
-    AppendDecimal(static_cast<unsigned>(date.month()), 2);
-    Append("-");
-    AppendDecimal(static_cast<unsigned>(date.day()), 2);
-    Append("T");
-    AppendDecimal(static_cast<std::uint64_t>(milliseconds / 3600000), 2);
-    Append(":");
-    AppendDecimal(static_cast<std::uint64_t>(milliseconds / 60000 % 60), 2);
-    Append(":");
-    AppendDecimal(static_cast<std::uint64_t>(milliseconds / 1000 % 60), 2);
-    Append(".");
-    AppendDecimal(static_cast<std::uint64_t>(milliseconds % 1000), 3);
-    Append("Z");
+    // Doesn't allocate (unlike Time::ToISO8601String())
+    char buffer[Time::ISO8601BufferSize];
+    Append(std::string_view(buffer, Time::WriteISO8601(buffer, time)));
 }
 
 //---------------------------------------------------------------------------
diff --git a/ASWLog/ASWLog_Formatter.cpp b/ASWLog/ASWLog_Formatter.cpp
index af97730..731fcb5 100644
--- a/ASWLog/ASWLog_Formatter.cpp
+++ b/ASWLog/ASWLog_Formatter.cpp
@@ -25,9 +25,12 @@ limitations under the License.
 #include "ASWLog_Formatter.h"
 //---------------------------------------------------------------------------
 // System includes here
+#include <charconv>
+#include <cstdint>
 #include <filesystem>
 #include <format>
 #include <iterator>
+#include <string_view>
 //---------------------------------------------------------------------------
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
@@ -35,6 +38,31 @@ limitations under the License.
 namespace ASWLog
 {
 
+namespace
+{
+
+void AppendNumberField(std::string& line, std::string_view label, std::uint64_t value);
+
+//---------------------------------------------------------------------------
+
+/*
+  AppendNumberField
+
+  Appends "[<label><value>]", the value in decimal
+*/
+void AppendNumberField(std::string& line, std::string_view label, std::uint64_t value)
+{
+    char digits[20];
+    const auto result = std::to_chars(digits, digits + sizeof(digits), value);
+
+    line += '[';
+    line.append(label);
+    line.append(digits, result.ptr);
+    line += ']';
+}
+
+} // namespace
+
 //---------------------------------------------------------------------------
 
 /////////////////////////////////////////////////////////////////////////////
@@ -53,26 +81,36 @@ std::string TASWTextFormatter::FormatLine(const TASWLogRecord& record, const TAS
     std::string line;
     line.reserve(record.Message.size() + 256);
 
+    // The fixed fields are written directly, which is several times faster than std::format here
     if (config.Line.ShowTimestamp)
-        std::format_to(std::back_inserter(line), "[{}]", Time::ToISO8601String(record.Timestamp));
+    {
+        char timestamp[Time::ISO8601BufferSize];
+        line += '[';
+        line.append(timestamp, Time::WriteISO8601(timestamp, record.Timestamp));
+        line += ']';
+    }
 
     if (config.Line.ShowLevel)
-        std::format_to(std::back_inserter(line), "[{}]", Level_ToString(record.LogLevel));
+    {
+        line += '[';
+        line.append(Level_ToString(record.LogLevel));
+        line += ']';
+    }
 
     if (config.Line.ShowProcessId)
-        std::format_to(std::back_inserter(line), "[P:{}]", record.ProcessId);
+        AppendNumberField(line, "P:", record.ProcessId);
 
     if (config.Line.ShowThreadId)
-        std::format_to(std::back_inserter(line), "[T:{}]", record.ThreadId);
+        AppendNumberField(line, "T:", record.ThreadId);
 
     if (config.Line.ShowWorkingSet || config.Line.ShowPeakWorkingSet)
     {
         const auto memoryUsage = GetMemoryUsage();
         if (config.Line.ShowWorkingSet)
-            std::format_to(std::back_inserter(line), "[WS:{}]", memoryUsage.WorkingSetBytes);
+            AppendNumberField(line, "WS:", memoryUsage.WorkingSetBytes);
 
         if (config.Line.ShowPeakWorkingSet)
-            std::format_to(std::back_inserter(line), "[PWS:{}]", memoryUsage.PeakWorkingSetBytes);
+            AppendNumberField(line, "PWS:", memoryUsage.PeakWorkingSetBytes);
     }
 
     if (config.Line.ShowFunctionName)
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index 3c98008..fa2830d 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -619,6 +619,28 @@ std::error_code RenameWithoutReplacing(const std::filesystem::path& from, const
 namespace Time
 {
 
+namespace
+{
+
+// The characters after the date in WriteISO8601()'s text: "THH:mm:ss.mmmZ"
+constexpr std::size_t ISO8601TimeOfDaySize = 14;
+
+//---------------------------------------------------------------------------
+
+// Writes the lowest 'digitCount' decimal digits of 'value', with leading zeros, and returns the end of what it wrote
+char* WriteDigits(char* out, std::uint32_t value, int digitCount) noexcept
+{
+    for (int index = digitCount - 1; index >= 0; --index)
+    {
+        out[index] = static_cast<char>('0' + value % 10);
+        value /= 10;
+    }
+
+    return out + digitCount;
+}
+
+} // namespace
+
 //---------------------------------------------------------------------------
 int GetUTCOffsetMinutes(std::chrono::system_clock::time_point timePoint)
 {
@@ -645,44 +667,15 @@ int GetUTCOffsetMinutes(std::chrono::system_clock::time_point timePoint)
 //---------------------------------------------------------------------------
 std::string ToISO8601String(std::chrono::system_clock::time_point timePoint)
 {
-    auto timeTimeT = std::chrono::system_clock::to_time_t(timePoint);
-    auto durationSinceEpoch = timePoint.time_since_epoch();
-    auto secondsSinceEpoch = std::chrono::duration_cast<std::chrono::seconds>(durationSinceEpoch);
-    auto millisecondsFraction = std::chrono::duration_cast<std::chrono::milliseconds>(durationSinceEpoch - secondsSinceEpoch).count();
-
-    std::tm utcTime{};
-#if defined(_WIN32)
-    gmtime_s(&utcTime, &timeTimeT);
-#else
-    gmtime_r(&timeTimeT, &utcTime);
-#endif
-
-    // Use ISO 8601 format with T separator and Z suffix
-    return std::format("{:04}-{:02}-{:02}T{:02}:{:02}:{:02}.{:03}Z",
-        utcTime.tm_year + 1900,
-        utcTime.tm_mon + 1,
-        utcTime.tm_mday,
-        utcTime.tm_hour,
-        utcTime.tm_min,
-        utcTime.tm_sec,
-        millisecondsFraction);
+    char buffer[ISO8601BufferSize];
+    return std::string(buffer, WriteISO8601(buffer, timePoint));
 }
 
 //---------------------------------------------------------------------------
 std::string ToDateString(std::chrono::system_clock::time_point timePoint)
 {
-    auto timeTimeT = std::chrono::system_clock::to_time_t(timePoint);
-    std::tm utcTime{};
-#if defined(_WIN32)
-    gmtime_s(&utcTime, &timeTimeT);
-#else
-    gmtime_r(&timeTimeT, &utcTime);
-#endif
-
-    return std::format("{:04}-{:02}-{:02}",
-        utcTime.tm_year + 1900,
-        utcTime.tm_mon + 1,
-        utcTime.tm_mday);
+    char buffer[ISO8601BufferSize];
+    return std::string(buffer, WriteISO8601(buffer, timePoint) - ISO8601TimeOfDaySize);
 }
 
 //---------------------------------------------------------------------------
@@ -716,6 +709,39 @@ std::string ToLocalISO8601String(std::chrono::system_clock::time_point timePoint
         absoluteOffsetMinutes % 60);
 }
 
+//---------------------------------------------------------------------------
+std::size_t WriteISO8601(char (& buffer)[ISO8601BufferSize], std::chrono::system_clock::time_point timePoint) noexcept
+{
+    // Floored, so a time before 1970 falls on the day and millisecond it is in
+    const auto day = std::chrono::floor<std::chrono::days>(timePoint);
+    const std::chrono::year_month_day date{ day };
+    const auto milliseconds = static_cast<std::uint32_t>(std::chrono::floor<std::chrono::milliseconds>(timePoint - day).count());
+    const int year = static_cast<int>(date.year());
+
+    char* out = buffer;
+
+    if (year >= 0 && year <= 9999)
+        out = WriteDigits(out, static_cast<std::uint32_t>(year), 4);
+    else
+        out = std::to_chars(out, buffer + ISO8601BufferSize, year).ptr;
+
+    *out++ = '-';
+    out = WriteDigits(out, static_cast<unsigned>(date.month()), 2);
+    *out++ = '-';
+    out = WriteDigits(out, static_cast<unsigned>(date.day()), 2);
+    *out++ = 'T';
+    out = WriteDigits(out, milliseconds / 3600000, 2);
+    *out++ = ':';
+    out = WriteDigits(out, milliseconds / 60000 % 60, 2);
+    *out++ = ':';
+    out = WriteDigits(out, milliseconds / 1000 % 60, 2);
+    *out++ = '.';
+    out = WriteDigits(out, milliseconds % 1000, 3);
+    *out++ = 'Z';
+
+    return static_cast<std::size_t>(out - buffer);
+}
+
 } // namespace Time
 
 //---------------------------------------------------------------------------
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index 0ddbc4a..3302924 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -137,6 +137,11 @@ struct TSystemMemoryUsage
 namespace Time
 {
 
+// The size of the buffer WriteISO8601() writes to
+inline constexpr std::size_t ISO8601BufferSize = 32;
+
+//---------------------------------------------------------------------------
+
 /*
     GetUTCOffsetMinutes
 
@@ -171,6 +176,16 @@ namespace Time
 */
 [[nodiscard]] std::string ToLocalISO8601String(std::chrono::system_clock::time_point timePoint);
 
+/*
+    WriteISO8601
+
+    Writes 'timePoint' as an ISO 8601 UTC string, as ToISO8601String() returns it, into 'buffer', and returns the
+    number of characters written: 24 for the years 0 to 9999, the year written in full outside them. Calendar
+    arithmetic only: allocates nothing and calls no C runtime function, so a crash handler can use it too.
+        Format: YYYY-MM-DDTHH:mm:ss.mmmZ
+*/
+[[nodiscard]] std::size_t WriteISO8601(char (& buffer)[ISO8601BufferSize], std::chrono::system_clock::time_point timePoint) noexcept;
+
 } // namespace Time
 
 } // namespace ASWLog
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 194da72..9ef842f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,20 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
 
 ## [Unreleased]
 
+### Changed
+
+- Writing a formatted line is much faster: the built-in layout now writes
+  the timestamp, level, process and thread ids and memory fields itself
+  instead of through `std::format`, which took most of a line's time. A
+  `LogInfo` line to a file with `FlushMode::Manual` takes about 0.4 us
+  instead of 1.0 us (MinGW and RAD Studio, Windows); the output is
+  unchanged. `Time::ToISO8601String()` and `Time::ToDateString()` (which
+  daily rolling calls for each entry) use the same code, and the new
+  `Time::WriteISO8601()` writes the timestamp into a buffer of
+  `Time::ISO8601BufferSize` characters without allocating, e.g. for a
+  custom formatter. A time before 1970 is now written as the day and
+  millisecond it falls in, instead of a malformed time.
+
 ## [0.75.0] - 2026-10-06
 
 ### Added
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index d155073..ceb1a31 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -32,6 +32,7 @@ limitations under the License.
 #include <format>
 #include <fstream>
 #include <iterator>
+#include <limits>
 #include <memory>
 #include <source_location>
 #include <string>
@@ -168,6 +169,7 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
 {
     RegisterTest(&TTest_ASWLog_Formatter::Test_Format_MatchesFormatLine, "Format_MatchesFormatLine");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_AllFieldsInOrder, "FormatLine_AllFieldsInOrder");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_LargestIdsAndEachLevel, "FormatLine_LargestIdsAndEachLevel");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_MemoryFields, "FormatLine_MemoryFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_NoFields, "FormatLine_NoFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread, "Formatter_ReceivesRecordFromLoggingThread");
@@ -244,6 +246,31 @@ void TTest_ASWLog_Formatter::Test_FormatLine_AllFieldsInOrder()
     CheckEquals(expected, line, "Each field should be written from the record, in the documented order");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_FormatLine_LargestIdsAndEachLevel()
+{
+    // Arrange
+    auto config = MakeConfigWithoutFields("unused.log");
+    config.Line.ShowLevel = true;
+    config.Line.ShowProcessId = true;
+    config.Line.ShowThreadId = true;
+    auto record = MakeRecord("ids");
+    record.ProcessId = std::numeric_limits<std::uint32_t>::max();
+    record.ThreadId = 0;
+
+    for (const auto level : { ASWLog::Level::Trace, ASWLog::Level::Debug, ASWLog::Level::Info, ASWLog::Level::Warn,
+                              ASWLog::Level::Error, ASWLog::Level::Critical })
+    {
+        record.LogLevel = level;
+
+        // Act
+        const auto line = ASWLog::TASWTextFormatter::FormatLine(record, config);
+
+        // Assert
+        const auto expected = std::format("[{}][P:4294967295][T:0]: ids", ASWLog::Level_ToString(level));
+        CheckEquals(expected, line, "The level's name and every digit of the ids should be written");
+    }
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_FormatLine_MemoryFields()
 {
     // Arrange
@@ -259,6 +286,16 @@ void TTest_ASWLog_Formatter::Test_FormatLine_MemoryFields()
     CheckStartsWith(line, "[WS:", "The working set should come first: " + line);
     CheckTrue(peakPos != std::string::npos, "The peak working set should follow: " + line);
     CheckEndsWith(line, "]: memory", "The message should follow the fields: " + line);
+
+    if (peakPos != std::string::npos)
+    {
+        const auto isNumber = [](const std::string& text) {
+                return !text.empty() && text.find_first_not_of("0123456789") == std::string::npos;
+            };
+        const auto peakEnd = line.find(']', peakPos + 1);
+        CheckTrue(isNumber(line.substr(4, peakPos - 4)), "The working set should be a decimal number: " + line);
+        CheckTrue(isNumber(line.substr(peakPos + 6, peakEnd - peakPos - 6)), "The peak working set should be a decimal number: " + line);
+    }
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_FormatLine_NoFields()
diff --git a/tests/tests/Test_ASWLog_Formatter.h b/tests/tests/Test_ASWLog_Formatter.h
index 53f56a5..db77d15 100644
--- a/tests/tests/Test_ASWLog_Formatter.h
+++ b/tests/tests/Test_ASWLog_Formatter.h
@@ -38,6 +38,7 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
 private: // Test methods
     void Test_Format_MatchesFormatLine();
     void Test_FormatLine_AllFieldsInOrder();
+    void Test_FormatLine_LargestIdsAndEachLevel();
     void Test_FormatLine_MemoryFields();
     void Test_FormatLine_NoFields();
     void Test_Formatter_ReceivesRecordFromLoggingThread();
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index 5ed5114..2ea5513 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -149,6 +149,7 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToDateString, "Time_ToDateString");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToISO8601String, "Time_ToISO8601String");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToLocalISO8601String_IncludesOffset, "Time_ToLocalISO8601String_IncludesOffset");
+    RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_CalendarEdges, "Time_WriteISO8601_CalendarEdges");
 }
 //---------------------------------------------------------------------------
 TTest_ASWLog_Utils::~TTest_ASWLog_Utils()
@@ -503,6 +504,43 @@ void TTest_ASWLog_Utils::Test_Time_ToLocalISO8601String_IncludesOffset()
     }
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_Time_WriteISO8601_CalendarEdges()
+{
+    // Arrange
+    using namespace std::chrono_literals;
+    using std::chrono::sys_days;
+
+    struct TCase
+    {
+        std::chrono::system_clock::time_point Time;
+        std::string Expected;
+        std::string What;
+    };
+
+    const TCase cases[] = {
+        { sys_days{ 1970y / 1 / 1 }, "1970-01-01T00:00:00.000Z", "The epoch" },
+        { sys_days{ 2026y / 1 / 15 } + 7h + 7ms, "2026-01-15T07:00:00.007Z", "Short fields should be zero-padded" },
+        { sys_days{ 1999y / 12 / 31 } + 23h + 59min + 59s + 999ms, "1999-12-31T23:59:59.999Z", "The last millisecond of a year" },
+        { sys_days{ 2024y / 2 / 29 } + 12h + 34min + 56s + 500ms, "2024-02-29T12:34:56.500Z", "A leap day" },
+        { sys_days{ 2000y / 2 / 29 }, "2000-02-29T00:00:00.000Z", "A leap day in a century year divisible by 400" },
+        { sys_days{ 2100y / 2 / 28 } + 24h, "2100-03-01T00:00:00.000Z", "The day after February 28 in a century year that isn't a leap year" },
+        { sys_days{ 2026y / 7 / 1 } + 12h + 123999us, "2026-07-01T12:00:00.123Z", "Microseconds should be cut off, not rounded" },
+        { sys_days{ 1970y / 1 / 1 } - 1ms, "1969-12-31T23:59:59.999Z", "A time before 1970 should fall on the millisecond it is in" },
+    };
+
+    for (const auto& testCase : cases)
+    {
+        // Act
+        char buffer[ASWLog::Time::ISO8601BufferSize];
+        const auto size = ASWLog::Time::WriteISO8601(buffer, testCase.Time);
+
+        // Assert: the string forms are the same text
+        CheckEquals(testCase.Expected, std::string(buffer, size), testCase.What);
+        CheckEquals(testCase.Expected, ASWLog::Time::ToISO8601String(testCase.Time), testCase.What + " (ToISO8601String)");
+        CheckEquals(testCase.Expected.substr(0, 10), ASWLog::Time::ToDateString(testCase.Time), testCase.What + " (ToDateString)");
+    }
+}
+//---------------------------------------------------------------------------
 
 } // namespace ASWUnitTests
 
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index aab57bb..c23c1f9 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -51,6 +51,7 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_Time_ToDateString();
     void Test_Time_ToISO8601String();
     void Test_Time_ToLocalISO8601String_IncludesOffset();
+    void Test_Time_WriteISO8601_CalendarEdges();
 
 public:
     TTest_ASWLog_Utils();

From 2a7770dce7bfc4363df86971bf64338c56c1a243 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Tue, 6 Oct 2026 22:23:00 -0700
Subject: [PATCH 03/38] Add local-time and microsecond timestamp options

---
 AGENTS.md                                     |   4 +-
 ASWLog/ASWLog_Config.h                        |  14 +-
 ASWLog/ASWLog_CrashHandler.h                  |   3 +-
 ASWLog/ASWLog_FileLog.cpp                     |  33 ++-
 ASWLog/ASWLog_FileLog.h                       |   7 +-
 ASWLog/ASWLog_Formatter.cpp                   |   2 +-
 ASWLog/ASWLog_TextLogBase.cpp                 |   3 +-
 ASWLog/ASWLog_Types.cpp                       |  27 ++
 ASWLog/ASWLog_Types.h                         |  56 ++++
 ASWLog/ASWLog_Utils.cpp                       | 264 +++++++++++++-----
 ASWLog/ASWLog_Utils.h                         |  34 ++-
 CHANGELOG.md                                  |  17 ++
 README.md                                     |   2 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   4 +
 tests/tests/Test_ASWLog_Config.cpp            |   2 +
 tests/tests/Test_ASWLog_FileLog.cpp           | 164 +++++++++++
 tests/tests/Test_ASWLog_FileLog.h             |   5 +
 tests/tests/Test_ASWLog_Formatter.cpp         |  19 ++
 tests/tests/Test_ASWLog_Formatter.h           |   1 +
 tests/tests/Test_ASWLog_Types.cpp             |  53 ++++
 tests/tests/Test_ASWLog_Types.h               |   4 +
 tests/tests/Test_ASWLog_Utils.cpp             | 152 +++++-----
 tests/tests/Test_ASWLog_Utils.h               |   3 +
 tests/tests/UT_Helper_DateTime.cpp            | 101 +++++++
 tests/tests/UT_Helper_DateTime.h              |  59 ++++
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   4 +
 27 files changed, 861 insertions(+), 177 deletions(-)
 create mode 100644 tests/tests/UT_Helper_DateTime.cpp
 create mode 100644 tests/tests/UT_Helper_DateTime.h

diff --git a/AGENTS.md b/AGENTS.md
index 838d34d..09d22b0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -9,7 +9,7 @@ These instructions apply to the entire repository unless a more specific `AGENTS
 ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux projects.
 
 - `ASWLog/` contains the framework implementation.
-- `tests/` contains the unit tests: test modules in `tests/tests/`, their CMake project in `tests/cmake/`, their RAD Studio console project in `tests/rad370/`, and their RAD Studio VCL GUI runner project in `tests/vcl/gui/rad370/` (built from the submodule's `vcl/gui/src`). `tests/compile_checks/` holds "must not compile" checks, which `tests/cmake/CMakeLists.txt` runs with `try_compile` when configuring (a failed check stops the configure).
+- `tests/` contains the unit tests: test modules (`Test_ASWLog_<Unit>`, the tests of `ASWLog_<Unit>`) and shared test helpers (`UT_Helper_<Topic>`, e.g. `UT_Helper_DateTime`) in `tests/tests/`, their CMake project in `tests/cmake/`, their RAD Studio console project in `tests/rad370/`, and their RAD Studio VCL GUI runner project in `tests/vcl/gui/rad370/` (built from the submodule's `vcl/gui/src`). `tests/compile_checks/` holds "must not compile" checks, which `tests/cmake/CMakeLists.txt` runs with `try_compile` when configuring (a failed check stops the configure).
 - `third_party/asw-unit-tests/` is the ASWUnitTests framework, a git submodule pinned to a release tag. Never edit files in it; test modules self-register with `ASW_REGISTER_TEST_GROUP`, so adding a test only touches `tests/` and its build files.
 - `.github/workflows/ci.yml` builds and runs the unit tests on Windows (MSVC, MinGW) and Linux (GCC, Clang), plus Linux Clang builds with ThreadSanitizer and with AddressSanitizer + UBSan (`ASWLOG_SANITIZE`).
 - `example/` contains example app that uses the logger.
@@ -67,7 +67,7 @@ cmake --build tests/cmake/build --config Release
 
 The VCL GUI runner builds with `tests/vcl/gui/rad370/Build_Win64x_Debug.bat` or `Build_Win64x_Release.bat` into the same output folder. To run every test in it without interaction, use `start /wait ASWLogTests_VCL_GUI.exe --run --exit --layout-ignore --report-junit results.xml`; its exit code matches the console runner's.
 
-When adding a test module, add its `.cpp`/`.h` to `tests/cmake/CMakeLists.txt`, `tests/rad370/ASWLogTests.cbproj`, and `tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj`, and keep their include paths in sync. Never open the GUI's main form (`ASWUnitTests_GUI_MainForm`) in the RAD Studio designer and save it, since that writes into the submodule.
+When adding a test module or a test helper, add its `.cpp`/`.h` to `tests/cmake/CMakeLists.txt`, `tests/rad370/ASWLogTests.cbproj`, and `tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj`, and keep their include paths in sync. Never open the GUI's main form (`ASWUnitTests_GUI_MainForm`) in the RAD Studio designer and save it, since that writes into the submodule.
 
 For other environments, use the repository's CMake configuration when present or the IDE's native project configuration. Tests should be run outside the debugger unless debugging an expected exception is intentional. Before considering a change complete:
 
diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index b18fd13..454fb38 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -156,8 +156,8 @@ struct TASWFileConfig
     // After a failed size rotation (e.g. another program holds the file), entries keep going to the current file, and
     // rotating isn't tried again until this long after the failure. 0 = try on every entry.
     std::chrono::milliseconds RotationRetryDelay{ 500 };
-    // Rolls the file over at UTC midnight, and at Initialize() if the file was last written on an earlier UTC day. The
-    // backup is named for the day it holds.
+    // Rolls the file over at midnight, and at Initialize() if the file was last written on an earlier day, both in
+    // Line.TimestampZone (UTC by default). The backup is named for the day it holds.
     bool EnableDailyRolling   = false;
 
     // --- Backup Event ---
@@ -218,8 +218,16 @@ struct TASWLineConfig
     std::shared_ptr<const IASWLogFormatter> Formatter;
     LineEnding Ending = LineEnding::LF; // Added after each line (not after LogRaw entries)
 
+    // The clock and precision of the timestamps, e.g. 2026-09-28T21:02:44.342Z (the defaults) or, with
+    // TimeZone::Local and TimePrecision::Microseconds, 2026-09-28T16:02:44.342519-05:00. The zone also sets when daily
+    // rolling starts a new file (File.EnableDailyRolling), the time in backup names, and the shutdown line's time. A
+    // crash line written in a POSIX signal handler, or when the logger's lock stays busy, is always UTC with
+    // milliseconds (see ASWLog_CrashHandler.h). Local time costs a C runtime call per line (localtime_s/localtime_r).
+    TimeZone TimestampZone = TimeZone::UTC;
+    TimePrecision TimestampPrecision = TimePrecision::Milliseconds;
+
     // The fields TASWTextFormatter writes before the message
-    bool ShowTimestamp      = true; // The entry's time, in UTC
+    bool ShowTimestamp      = true; // The entry's time (see TimestampZone and TimestampPrecision)
     bool ShowLevel          = true;
     bool ShowProcessId      = true;
     bool ShowThreadId       = true;
diff --git a/ASWLog/ASWLog_CrashHandler.h b/ASWLog/ASWLog_CrashHandler.h
index d17f188..0d5bda5 100644
--- a/ASWLog/ASWLog_CrashHandler.h
+++ b/ASWLog/ASWLog_CrashHandler.h
@@ -70,7 +70,8 @@ struct TASWCrashHandlerOptions
 //   costs at most the line.
 // - A POSIX signal handler may only do async-signal-safe work, so there the line has a fixed layout,
 //   "[<UTC time>][CRITICAL][P:<pid>][T:<tid>]: Crash: <reason>", built without allocating and written straight to the
-//   file. The buffered entries are flushed only if the logger's lock is free (fflush isn't on POSIX's list of
+//   file. Its time is UTC with milliseconds whatever TASWLineConfig::TimestampZone and TimestampPrecision say, since
+//   converting to local time isn't async-signal-safe. The buffered entries are flushed only if the logger's lock is free (fflush isn't on POSIX's list of
 //   async-signal-safe functions, but no other thread can use the file then). The backtrace's lines get the same
 //   layout, with their own level, and only if the backtrace's lock is free.
 // - If a logger's lock stays busy until WaitTimeout has passed (e.g. the crash happened while that thread was
diff --git a/ASWLog/ASWLog_FileLog.cpp b/ASWLog/ASWLog_FileLog.cpp
index 0f90f3c..aa00487 100644
--- a/ASWLog/ASWLog_FileLog.cpp
+++ b/ASWLog/ASWLog_FileLog.cpp
@@ -218,11 +218,12 @@ std::vector<TBackupFile> ListBackups(const std::filesystem::path& logPath, std::
     return backups;
 }
 
-// Formats a UTC time for a backup file name: "YYYY-MM-DD_HHMMSS_mmm".
-std::string ToBackupTimeLabel(std::chrono::system_clock::time_point timePoint)
+// Formats a time in 'zone' for a backup file name: "YYYY-MM-DD_HHMMSS_mmm".
+std::string ToBackupTimeLabel(std::chrono::system_clock::time_point timePoint, TimeZone zone)
 {
-    // Cut from the ISO 8601 form "YYYY-MM-DDTHH:mm:ss.mmmZ", leaving out the characters not wanted in a file name
-    const auto isoTime = Time::ToISO8601String(timePoint);
+    // Cut from the ISO 8601 form "YYYY-MM-DDTHH:mm:ss.mmmZ" (or "...mmm+hh:mm" in local time), leaving out the
+    // characters not wanted in a file name
+    const auto isoTime = Time::ToISO8601String(timePoint, zone);
     const std::string_view iso(isoTime);
     return std::format("{}_{}{}{}_{}", iso.substr(0, 10), iso.substr(11, 2), iso.substr(14, 2), iso.substr(17, 2),
         iso.substr(20, 3));
@@ -708,7 +709,7 @@ bool TASWFileLog::InitializeUnlocked()
         return false;
     }
 
-    m_LastLogDateStr = Time::ToDateString(NowUTC());
+    m_LastLogDateStr = Time::ToDateString(NowUTC(), GetConfigUnlocked().Line.TimestampZone);
     return true;
 }
 
@@ -786,7 +787,7 @@ bool TASWFileLog::OpenUnlocked()
 
     if (m_LastLogDateStr.empty())
     {
-        m_LastLogDateStr = Time::ToDateString(NowUTC());
+        m_LastLogDateStr = Time::ToDateString(NowUTC(), GetConfigUnlocked().Line.TimestampZone);
     }
 
     m_IsOpen.store(true, std::memory_order_release);
@@ -807,7 +808,7 @@ bool TASWFileLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point now
     {
         // Only rolls forward (ISO dates compare as text): an entry stamped just before midnight can get the lock after
         // another thread's entry has rolled the log over, and then goes into the new day's log
-        const auto currentDateStr = Time::ToDateString(now);
+        const auto currentDateStr = Time::ToDateString(now, GetConfigUnlocked().Line.TimestampZone);
         if (currentDateStr > m_LastLogDateStr)
         {
             // Name the backup for the day its content is from, not the day that just started. A log shared with other
@@ -826,7 +827,7 @@ bool TASWFileLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point now
     if (GetConfigUnlocked().File.EnableRotation && m_FileStream.IsOpen() && m_FileStream.GetSize() >= GetConfigUnlocked().File.MaxFileSizeBytes &&
         IsRetryDue(m_LastRotationFailure, now, GetConfigUnlocked().File.RotationRetryDelay))
     {
-        RotateLogFilesUnlocked("size", ToBackupTimeLabel(now));
+        RotateLogFilesUnlocked("size", ToBackupTimeLabel(now, GetConfigUnlocked().Line.TimestampZone));
     }
 
     return m_FileStream.IsOpen();
@@ -843,16 +844,21 @@ bool TASWFileLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point now
 
     Otherwise the file stays open: flushes what the previous flush mode may have buffered, and the other settings take
     effect with the next entry (a FlushMode::Periodic thread is started, stopped or given its new interval after the
-    lock is released, see GetWorkerIntervalUnlocked()).
+    lock is released, see GetWorkerIntervalUnlocked()). A new Line.TimestampZone makes the file's day today's date in
+    that zone, so daily rolling next rolls over at that zone's midnight.
 */
 bool TASWFileLog::ReconfigureUnlocked(const TASWLogConfig& previous)
 {
-    const auto& file = GetConfigUnlocked().File;
+    const auto& config = GetConfigUnlocked();
+    const auto& file = config.File;
     m_SyncsCrashLine.store(Level::Critical >= file.SyncToDiskAtLevel, std::memory_order_relaxed);
 
     if (file.ResolvePath() == previous.File.ResolvePath() &&
         file.AutoOpenClosePerWrite == previous.File.AutoOpenClosePerWrite)
     {
+        if (config.Line.TimestampZone != previous.Line.TimestampZone)
+            m_LastLogDateStr = Time::ToDateString(NowUTC(), config.Line.TimestampZone);
+
         if (m_FileStream.IsOpen())
             FlushUnlocked();
 
@@ -907,7 +913,7 @@ bool TASWFileLog::RotateLogFiles(std::string_view reasonTag)
 {
     TDeferredWorkRunner deferredWorkRunner(*this);
     std::lock_guard<std::mutex> lock(m_Mutex);
-    return RotateLogFilesUnlocked(reasonTag, ToBackupTimeLabel(NowUTC()));
+    return RotateLogFilesUnlocked(reasonTag, ToBackupTimeLabel(NowUTC(), GetConfigUnlocked().Line.TimestampZone));
 }
 
 //---------------------------------------------------------------------------
@@ -944,8 +950,9 @@ void TASWFileLog::RotateDailyLogFromEarlierDayUnlocked()
     const auto lastWriteUTC = now - std::chrono::duration_cast<std::chrono::system_clock::duration>(fileAge);
 
     // YYYY-MM-DD strings compare in date order
-    const auto lastWriteDateStr = Time::ToDateString(lastWriteUTC);
-    if (lastWriteDateStr < Time::ToDateString(now))
+    const auto zone = GetConfigUnlocked().Line.TimestampZone;
+    const auto lastWriteDateStr = Time::ToDateString(lastWriteUTC, zone);
+    if (lastWriteDateStr < Time::ToDateString(now, zone))
         RotateLogFilesUnlocked("daily", lastWriteDateStr);
 }
 
diff --git a/ASWLog/ASWLog_FileLog.h b/ASWLog/ASWLog_FileLog.h
index f6d92b1..80e08ba 100644
--- a/ASWLog/ASWLog_FileLog.h
+++ b/ASWLog/ASWLog_FileLog.h
@@ -181,9 +181,10 @@ class TASWFileLog : public TASWTextLogBase
     TASWFileLog() = default;
     ~TASWFileLog();
 
-    // Renames the log file to "<stem>.<reasonTag>.<YYYY-MM-DD_HHMMSS_mmm>.bak" (UTC), adding "_1", "_2", ... to the
-    // time if that name is taken, so an existing backup is never replaced. Then reopens the log if it was open. A
-    // 'reasonTag' that contains '.' makes a backup that TASWFileConfig's backup cleanup doesn't recognize, so it is kept.
+    // Renames the log file to "<stem>.<reasonTag>.<YYYY-MM-DD_HHMMSS_mmm>.bak" (the time in Line.TimestampZone, UTC by
+    // default), adding "_1", "_2", ... to the time if that name is taken, so an existing backup is never replaced. Then
+    // reopens the log if it was open. A 'reasonTag' that contains '.' makes a backup that TASWFileConfig's backup
+    // cleanup doesn't recognize, so it is kept.
     bool RotateLogFiles(std::string_view reasonTag = "manual");
 };
 
diff --git a/ASWLog/ASWLog_Formatter.cpp b/ASWLog/ASWLog_Formatter.cpp
index 731fcb5..9cb06da 100644
--- a/ASWLog/ASWLog_Formatter.cpp
+++ b/ASWLog/ASWLog_Formatter.cpp
@@ -86,7 +86,7 @@ std::string TASWTextFormatter::FormatLine(const TASWLogRecord& record, const TAS
     {
         char timestamp[Time::ISO8601BufferSize];
         line += '[';
-        line.append(timestamp, Time::WriteISO8601(timestamp, record.Timestamp));
+        line.append(timestamp, Time::WriteISO8601(timestamp, record.Timestamp, config.Line.TimestampZone, config.Line.TimestampPrecision));
         line += ']';
     }
 
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index 0b29d10..8a7bcc0 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -142,7 +142,8 @@ void TASWTextLogBase::Finalize() noexcept
         // AutoOpenClosePerWrite)
         if (GetConfigUnlocked().Shutdown.WriteLine && EnsureReadyUnlocked())
         {
-            std::string msg = "Logger shutdown: " + Time::ToISO8601String(NowUTC());
+            const auto& line = GetConfigUnlocked().Line;
+            std::string msg = "Logger shutdown: " + Time::ToISO8601String(NowUTC(), line.TimestampZone, line.TimestampPrecision);
 
             if (!GetConfigUnlocked().Shutdown.Banner.empty())
                 msg += ", " + GetConfigUnlocked().Shutdown.Banner;
diff --git a/ASWLog/ASWLog_Types.cpp b/ASWLog/ASWLog_Types.cpp
index 415f1d4..3b0c1c5 100644
--- a/ASWLog/ASWLog_Types.cpp
+++ b/ASWLog/ASWLog_Types.cpp
@@ -140,6 +140,33 @@ std::optional<LineEnding> LineEnding_FromString(std::string_view str) noexcept
     return std::nullopt; // Return empty optional if the string is not recognized
 }
 
+//---------------------------------------------------------------------------
+std::optional<TimePrecision> TimePrecision_FromString(std::string_view str) noexcept
+{
+    if (iequals(str, "MILLISECONDS") || iequals(str, "MS"))
+        return TimePrecision::Milliseconds;
+
+    if (iequals(str, "MICROSECONDS") || iequals(str, "US"))
+        return TimePrecision::Microseconds;
+
+    if (iequals(str, "NANOSECONDS") || iequals(str, "NS"))
+        return TimePrecision::Nanoseconds;
+
+    return std::nullopt;
+}
+
+//---------------------------------------------------------------------------
+std::optional<TimeZone> TimeZone_FromString(std::string_view str) noexcept
+{
+    if (iequals(str, "UTC"))
+        return TimeZone::UTC;
+
+    if (iequals(str, "LOCAL"))
+        return TimeZone::Local;
+
+    return std::nullopt;
+}
+
 //---------------------------------------------------------------------------
 
 /////////////////////////////////////////////////////////////////////////////
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index fa79712..c3e9b62 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -330,6 +330,62 @@ enum class LineEnding
 
 //---------------------------------------------------------------------------
 
+// How many digits of the second a timestamp shows (see TASWLineConfig::TimestampPrecision). The digits past the system
+// clock's resolution are 0: with nanoseconds, the last two with MSVC and MinGW on Windows (100 ns), the last three with
+// libc++ (1 us, e.g. RAD Studio).
+enum class TimePrecision
+{
+    Milliseconds, // .mmm
+    Microseconds, // .uuuuuu
+    Nanoseconds,  // .nnnnnnnnn
+};
+
+[[nodiscard]] std::optional<TimePrecision> TimePrecision_FromString(std::string_view str) noexcept;
+
+[[nodiscard]] constexpr std::string_view TimePrecision_ToString(TimePrecision precision) noexcept
+{
+    switch (precision)
+    {
+        case TimePrecision::Milliseconds:
+            return "MILLISECONDS";
+
+        case TimePrecision::Microseconds:
+            return "MICROSECONDS";
+
+        case TimePrecision::Nanoseconds:
+            return "NANOSECONDS";
+    }
+
+    return "UNKNOWN";
+}
+
+//---------------------------------------------------------------------------
+
+// The clock a timestamp is shown in (see TASWLineConfig::TimestampZone)
+enum class TimeZone
+{
+    UTC,   // "Z" suffix, e.g. 2026-09-28T21:02:44.342Z
+    Local, // The local time zone, with its offset from UTC, e.g. 2026-09-28T16:02:44.342-05:00
+};
+
+[[nodiscard]] std::optional<TimeZone> TimeZone_FromString(std::string_view str) noexcept;
+
+[[nodiscard]] constexpr std::string_view TimeZone_ToString(TimeZone zone) noexcept
+{
+    switch (zone)
+    {
+        case TimeZone::UTC:
+            return "UTC";
+
+        case TimeZone::Local:
+            return "LOCAL";
+    }
+
+    return "UNKNOWN";
+}
+
+//---------------------------------------------------------------------------
+
 /////////////////////////////////////////////////////////////////////////////
 // TASWLogError struct
 //
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index fa2830d..d4d9b3f 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -622,12 +622,144 @@ namespace Time
 namespace
 {
 
-// The characters after the date in WriteISO8601()'s text: "THH:mm:ss.mmmZ"
-constexpr std::size_t ISO8601TimeOfDaySize = 14;
+// The calendar fields WriteISO8601() writes
+struct TDateAndTime
+{
+    int Year = 0;
+    std::uint32_t Month = 0;
+    std::uint32_t Day = 0;
+    std::uint32_t Hour = 0;
+    std::uint32_t Minute = 0;
+    std::uint32_t Second = 0;
+    std::uint32_t Nanosecond = 0;
+};
+
+//---------------------------------------------------------------------------
+
+int GetOffsetMinutes(const std::tm& localTime, std::chrono::sys_seconds time) noexcept;
+bool ToLocalCalendarTime(std::time_t timeValue, std::tm& localTime) noexcept;
+bool ToLocalDateAndTime(std::chrono::system_clock::time_point timePoint, TDateAndTime& dateAndTime, int& offsetMinutes) noexcept;
+TDateAndTime ToUTCDateAndTime(std::chrono::system_clock::time_point timePoint) noexcept;
+char* WriteDateAndTime(char* out, char* end, const TDateAndTime& dateAndTime) noexcept;
+char* WriteDigits(char* out, std::uint32_t value, int digitCount) noexcept;
+char* WriteFraction(char* out, std::uint32_t nanoseconds, TimePrecision precision) noexcept;
 
 //---------------------------------------------------------------------------
 
-// Writes the lowest 'digitCount' decimal digits of 'value', with leading zeros, and returns the end of what it wrote
+/*
+  GetOffsetMinutes
+
+  How many minutes 'localTime', the local calendar fields of 'time', is ahead of UTC: the local date and time read as
+  if they were UTC, minus the actual time. Not mktime(), which would read UTC fields as local time and apply this
+  zone's daylight saving rules to them.
+*/
+int GetOffsetMinutes(const std::tm& localTime, std::chrono::sys_seconds time) noexcept
+{
+    const std::chrono::sys_days localDate = std::chrono::year(localTime.tm_year + 1900) / (localTime.tm_mon + 1) / localTime.tm_mday;
+    const auto localAsUTC = localDate + std::chrono::hours(localTime.tm_hour) + std::chrono::minutes(localTime.tm_min) +
+        std::chrono::seconds(localTime.tm_sec);
+
+    return static_cast<int>(std::chrono::duration_cast<std::chrono::minutes>(localAsUTC - time).count());
+}
+
+/*
+  ToLocalCalendarTime
+
+  Converts 'timeValue' to the local time zone's calendar fields. Returns false if it can't (e.g. a time before 1970 on
+  Windows).
+*/
+bool ToLocalCalendarTime(std::time_t timeValue, std::tm& localTime) noexcept
+{
+#if defined(_WIN32)
+    return localtime_s(&localTime, &timeValue) == 0;
+#else
+    return localtime_r(&timeValue, &localTime) != nullptr;
+#endif
+}
+
+/*
+  ToLocalDateAndTime
+
+  The calendar fields of 'timePoint' in the local time zone, and the zone's offset from UTC then. Returns false if the
+  local time can't be determined (see ToLocalCalendarTime()).
+*/
+bool ToLocalDateAndTime(std::chrono::system_clock::time_point timePoint, TDateAndTime& dateAndTime, int& offsetMinutes) noexcept
+{
+    // Floored, so a time before 1970 falls on the second it is in
+    const auto seconds = std::chrono::floor<std::chrono::seconds>(timePoint);
+    std::tm localTime{};
+
+    if (!ToLocalCalendarTime(std::chrono::system_clock::to_time_t(seconds), localTime))
+        return false;
+
+    dateAndTime.Year = localTime.tm_year + 1900;
+    dateAndTime.Month = static_cast<std::uint32_t>(localTime.tm_mon + 1);
+    dateAndTime.Day = static_cast<std::uint32_t>(localTime.tm_mday);
+    dateAndTime.Hour = static_cast<std::uint32_t>(localTime.tm_hour);
+    dateAndTime.Minute = static_cast<std::uint32_t>(localTime.tm_min);
+    dateAndTime.Second = static_cast<std::uint32_t>(localTime.tm_sec);
+    dateAndTime.Nanosecond = static_cast<std::uint32_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(timePoint - seconds).count());
+    offsetMinutes = GetOffsetMinutes(localTime, seconds);
+
+    return true;
+}
+
+/*
+  ToUTCDateAndTime
+
+  The calendar fields of 'timePoint' in UTC. Calendar arithmetic only.
+*/
+TDateAndTime ToUTCDateAndTime(std::chrono::system_clock::time_point timePoint) noexcept
+{
+    // Floored, so a time before 1970 falls on the day it is in; the time of day is then never negative
+    const auto day = std::chrono::floor<std::chrono::days>(timePoint);
+    const std::chrono::year_month_day date{ day };
+    const auto timeOfDay = timePoint - day;
+    const auto seconds = std::chrono::duration_cast<std::chrono::seconds>(timeOfDay);
+    const auto secondOfDay = static_cast<std::uint32_t>(seconds.count());
+
+    TDateAndTime dateAndTime;
+    dateAndTime.Year = static_cast<int>(date.year());
+    dateAndTime.Month = static_cast<unsigned>(date.month());
+    dateAndTime.Day = static_cast<unsigned>(date.day());
+    dateAndTime.Hour = secondOfDay / 3600;
+    dateAndTime.Minute = secondOfDay / 60 % 60;
+    dateAndTime.Second = secondOfDay % 60;
+    dateAndTime.Nanosecond = static_cast<std::uint32_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(timeOfDay - seconds).count());
+
+    return dateAndTime;
+}
+
+/*
+  WriteDateAndTime
+
+  Writes "YYYY-MM-DDTHH:mm:ss" (a 4-digit year for the years 0 to 9999, the year in full outside them) and returns the
+  end of what it wrote
+*/
+char* WriteDateAndTime(char* out, char* end, const TDateAndTime& dateAndTime) noexcept
+{
+    if (dateAndTime.Year >= 0 && dateAndTime.Year <= 9999)
+        out = WriteDigits(out, static_cast<std::uint32_t>(dateAndTime.Year), 4);
+    else
+        out = std::to_chars(out, end, dateAndTime.Year).ptr;
+
+    *out++ = '-';
+    out = WriteDigits(out, dateAndTime.Month, 2);
+    *out++ = '-';
+    out = WriteDigits(out, dateAndTime.Day, 2);
+    *out++ = 'T';
+    out = WriteDigits(out, dateAndTime.Hour, 2);
+    *out++ = ':';
+    out = WriteDigits(out, dateAndTime.Minute, 2);
+    *out++ = ':';
+    return WriteDigits(out, dateAndTime.Second, 2);
+}
+
+/*
+  WriteDigits
+
+  Writes the lowest 'digitCount' decimal digits of 'value', with leading zeros, and returns the end of what it wrote
+*/
 char* WriteDigits(char* out, std::uint32_t value, int digitCount) noexcept
 {
     for (int index = digitCount - 1; index >= 0; --index)
@@ -639,105 +771,93 @@ char* WriteDigits(char* out, std::uint32_t value, int digitCount) noexcept
     return out + digitCount;
 }
 
+/*
+  WriteFraction
+
+  Writes '.' and the fraction of the second, 'nanoseconds' (0 to 999999999), with the digits of 'precision', cut off
+  rather than rounded, and returns the end of what it wrote
+*/
+char* WriteFraction(char* out, std::uint32_t nanoseconds, TimePrecision precision) noexcept
+{
+    *out++ = '.';
+
+    switch (precision)
+    {
+        case TimePrecision::Microseconds:
+            return WriteDigits(out, nanoseconds / 1000, 6);
+
+        case TimePrecision::Nanoseconds:
+            return WriteDigits(out, nanoseconds, 9);
+
+        case TimePrecision::Milliseconds:
+            break;
+    }
+
+    return WriteDigits(out, nanoseconds / 1000000, 3);
+}
+
 } // namespace
 
 //---------------------------------------------------------------------------
 int GetUTCOffsetMinutes(std::chrono::system_clock::time_point timePoint)
 {
-    const auto timeValue = std::chrono::system_clock::to_time_t(timePoint);
+    const auto seconds = std::chrono::floor<std::chrono::seconds>(timePoint);
     std::tm localTime{};
-#if defined(_WIN32)
-    if (localtime_s(&localTime, &timeValue) != 0)
-        return 0;
-#else
-    if (localtime_r(&timeValue, &localTime) == nullptr)
-        return 0;
-#endif
 
-    // The local date and time read as if they were UTC, minus the actual time. Not mktime(), which would read UTC
-    // fields as local time and apply this zone's daylight saving rules to them.
-    const std::chrono::sys_days localDate = std::chrono::year(localTime.tm_year + 1900) / (localTime.tm_mon + 1) / localTime.tm_mday;
-    const auto localAsUTC = localDate + std::chrono::hours(localTime.tm_hour) + std::chrono::minutes(localTime.tm_min) +
-        std::chrono::seconds(localTime.tm_sec);
-    const auto actualTime = std::chrono::time_point_cast<std::chrono::seconds>(std::chrono::system_clock::from_time_t(timeValue));
+    if (!ToLocalCalendarTime(std::chrono::system_clock::to_time_t(seconds), localTime))
+        return 0;
 
-    return static_cast<int>(std::chrono::duration_cast<std::chrono::minutes>(localAsUTC - actualTime).count());
+    return GetOffsetMinutes(localTime, seconds);
 }
 
 //---------------------------------------------------------------------------
-std::string ToISO8601String(std::chrono::system_clock::time_point timePoint)
+std::string ToISO8601String(std::chrono::system_clock::time_point timePoint, TimeZone zone, TimePrecision precision)
 {
     char buffer[ISO8601BufferSize];
-    return std::string(buffer, WriteISO8601(buffer, timePoint));
+    return std::string(buffer, WriteISO8601(buffer, timePoint, zone, precision));
 }
 
 //---------------------------------------------------------------------------
-std::string ToDateString(std::chrono::system_clock::time_point timePoint)
+std::string ToDateString(std::chrono::system_clock::time_point timePoint, TimeZone zone)
 {
     char buffer[ISO8601BufferSize];
-    return std::string(buffer, WriteISO8601(buffer, timePoint) - ISO8601TimeOfDaySize);
+    const std::string_view text(buffer, WriteISO8601(buffer, timePoint, zone));
+    return std::string(text.substr(0, text.find('T')));
 }
 
 //---------------------------------------------------------------------------
 std::string ToLocalISO8601String(std::chrono::system_clock::time_point timePoint)
 {
-    const auto timeValue = std::chrono::system_clock::to_time_t(timePoint);
-    std::tm localTime{};
-#if defined(_WIN32)
-    localtime_s(&localTime, &timeValue);
-#else
-    localtime_r(&timeValue, &localTime);
-#endif
-
-    const auto durationSinceEpoch = timePoint.time_since_epoch();
-    const auto secondsSinceEpoch = std::chrono::duration_cast<std::chrono::seconds>(durationSinceEpoch);
-    const auto millisecondsFraction = std::chrono::duration_cast<std::chrono::milliseconds>(durationSinceEpoch - secondsSinceEpoch).count();
-
-    const auto offsetMinutes = GetUTCOffsetMinutes(timePoint);
-    const auto absoluteOffsetMinutes = offsetMinutes < 0 ? -offsetMinutes : offsetMinutes;
-
-    return std::format("{:04}-{:02}-{:02}T{:02}:{:02}:{:02}.{:03}{}{:02}:{:02}",
-        localTime.tm_year + 1900,
-        localTime.tm_mon + 1,
-        localTime.tm_mday,
-        localTime.tm_hour,
-        localTime.tm_min,
-        localTime.tm_sec,
-        millisecondsFraction,
-        offsetMinutes < 0 ? '-' : '+',
-        absoluteOffsetMinutes / 60,
-        absoluteOffsetMinutes % 60);
+    return ToISO8601String(timePoint, TimeZone::Local);
 }
 
 //---------------------------------------------------------------------------
-std::size_t WriteISO8601(char (& buffer)[ISO8601BufferSize], std::chrono::system_clock::time_point timePoint) noexcept
+std::size_t WriteISO8601(char (& buffer)[ISO8601BufferSize], std::chrono::system_clock::time_point timePoint, TimeZone zone,
+    TimePrecision precision) noexcept
 {
-    // Floored, so a time before 1970 falls on the day and millisecond it is in
-    const auto day = std::chrono::floor<std::chrono::days>(timePoint);
-    const std::chrono::year_month_day date{ day };
-    const auto milliseconds = static_cast<std::uint32_t>(std::chrono::floor<std::chrono::milliseconds>(timePoint - day).count());
-    const int year = static_cast<int>(date.year());
+    // Each helper is called once, so the compiler can inline the UTC path into one function
+    TDateAndTime dateAndTime;
+    int offsetMinutes = 0;
+    const bool isLocal = zone == TimeZone::Local && ToLocalDateAndTime(timePoint, dateAndTime, offsetMinutes);
 
-    char* out = buffer;
+    if (!isLocal)
+        dateAndTime = ToUTCDateAndTime(timePoint);
 
-    if (year >= 0 && year <= 9999)
-        out = WriteDigits(out, static_cast<std::uint32_t>(year), 4);
-    else
-        out = std::to_chars(out, buffer + ISO8601BufferSize, year).ptr;
+    char* out = WriteDateAndTime(buffer, buffer + ISO8601BufferSize, dateAndTime);
+    out = WriteFraction(out, dateAndTime.Nanosecond, precision);
 
-    *out++ = '-';
-    out = WriteDigits(out, static_cast<unsigned>(date.month()), 2);
-    *out++ = '-';
-    out = WriteDigits(out, static_cast<unsigned>(date.day()), 2);
-    *out++ = 'T';
-    out = WriteDigits(out, milliseconds / 3600000, 2);
-    *out++ = ':';
-    out = WriteDigits(out, milliseconds / 60000 % 60, 2);
-    *out++ = ':';
-    out = WriteDigits(out, milliseconds / 1000 % 60, 2);
-    *out++ = '.';
-    out = WriteDigits(out, milliseconds % 1000, 3);
-    *out++ = 'Z';
+    if (isLocal)
+    {
+        const auto absoluteOffsetMinutes = static_cast<std::uint32_t>(offsetMinutes < 0 ? -offsetMinutes : offsetMinutes);
+        *out++ = offsetMinutes < 0 ? '-' : '+';
+        out = WriteDigits(out, absoluteOffsetMinutes / 60, 2);
+        *out++ = ':';
+        out = WriteDigits(out, absoluteOffsetMinutes % 60, 2);
+    }
+    else
+    {
+        *out++ = 'Z';
+    }
 
     return static_cast<std::size_t>(out - buffer);
 }
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index 3302924..76cc4d6 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -37,6 +37,8 @@ limitations under the License.
 #include <string_view>
 #include <system_error>
 //---------------------------------------------------------------------------
+#include "ASWLog_Types.h"
+//---------------------------------------------------------------------------
 
 namespace ASWLog
 {
@@ -137,8 +139,9 @@ struct TSystemMemoryUsage
 namespace Time
 {
 
-// The size of the buffer WriteISO8601() writes to
-inline constexpr std::size_t ISO8601BufferSize = 32;
+// The size of the buffer WriteISO8601() writes to: enough for the longest form, a 6-character year with nanoseconds
+// and an offset
+inline constexpr std::size_t ISO8601BufferSize = 40;
 
 //---------------------------------------------------------------------------
 
@@ -154,24 +157,25 @@ inline constexpr std::size_t ISO8601BufferSize = 32;
 /*
     ToISO8601String
 
-    Converts a high-precision system time point into a valid ISO 8601 UTC string.
-        Format: YYYY-MM-DDTHH:mm:ss.mmmZ
+    Converts a system time point into an ISO 8601 string, as WriteISO8601() writes it.
+        Format: YYYY-MM-DDTHH:mm:ss.mmmZ (the defaults)
 */
-[[nodiscard]] std::string ToISO8601String(std::chrono::system_clock::time_point timePoint);
+[[nodiscard]] std::string ToISO8601String(std::chrono::system_clock::time_point timePoint, TimeZone zone = TimeZone::UTC,
+    TimePrecision precision = TimePrecision::Milliseconds);
 
 /*
     ToDateString
 
-    Extracts just the calendar date segment needed for midnight rolling checks.
+    The date part of ToISO8601String(), in 'zone', e.g. for daily rolling.
         Format: YYYY-MM-DD
 */
-[[nodiscard]] std::string ToDateString(std::chrono::system_clock::time_point timePoint);
+[[nodiscard]] std::string ToDateString(std::chrono::system_clock::time_point timePoint, TimeZone zone = TimeZone::UTC);
 
 /*
     ToLocalISO8601String
 
     Converts a system time point into an ISO 8601 local time string with the local time zone's offset from UTC (see
-    GetUTCOffsetMinutes()), with milliseconds like ToISO8601String().
+    GetUTCOffsetMinutes()), with milliseconds: ToISO8601String() with TimeZone::Local.
         Format: YYYY-MM-DDTHH:mm:ss.mmm+hh:mm (e.g. 2026-09-28T21:02:44.123-05:00)
 */
 [[nodiscard]] std::string ToLocalISO8601String(std::chrono::system_clock::time_point timePoint);
@@ -179,12 +183,16 @@ inline constexpr std::size_t ISO8601BufferSize = 32;
 /*
     WriteISO8601
 
-    Writes 'timePoint' as an ISO 8601 UTC string, as ToISO8601String() returns it, into 'buffer', and returns the
-    number of characters written: 24 for the years 0 to 9999, the year written in full outside them. Calendar
-    arithmetic only: allocates nothing and calls no C runtime function, so a crash handler can use it too.
-        Format: YYYY-MM-DDTHH:mm:ss.mmmZ
+    Writes 'timePoint' as an ISO 8601 string into 'buffer' and returns the number of characters written: the date, the
+    time with 3, 6 or 9 digits of the second ('precision'), and "Z" for TimeZone::UTC, or the local time zone's offset
+    from UTC for TimeZone::Local (see GetUTCOffsetMinutes()). A 4-digit year for the years 0 to 9999, the year in full
+    outside them. Allocates nothing. UTC is calendar arithmetic only, so a crash handler can use it, even in a POSIX
+    signal handler; Local calls localtime_s/localtime_r, which isn't safe there, and falls back to UTC if the local
+    time can't be determined.
+        Format: YYYY-MM-DDTHH:mm:ss.mmmZ (the defaults), or e.g. 2026-09-28T16:02:44.342519-05:00
 */
-[[nodiscard]] std::size_t WriteISO8601(char (& buffer)[ISO8601BufferSize], std::chrono::system_clock::time_point timePoint) noexcept;
+[[nodiscard]] std::size_t WriteISO8601(char (& buffer)[ISO8601BufferSize], std::chrono::system_clock::time_point timePoint,
+    TimeZone zone = TimeZone::UTC, TimePrecision precision = TimePrecision::Milliseconds) noexcept;
 
 } // namespace Time
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9ef842f..ef12703 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,23 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
 
 ## [Unreleased]
 
+### Added
+
+- Local-time and finer timestamps: `Line.TimestampZone` (`TimeZone::UTC`,
+  the default, or `TimeZone::Local`) and `Line.TimestampPrecision`
+  (`TimePrecision::Milliseconds`, the default, `Microseconds` or
+  `Nanoseconds`), e.g. `2026-09-28T16:02:44.342519-05:00` for local time
+  with microseconds. The digits past the system clock's resolution are 0
+  (100 ns with MSVC and MinGW, 1 us with RAD Studio's libc++). The zone also
+  decides when daily rolling starts a new file (local midnight with
+  `Local`), the time in backup names, and the time in the "Logger shutdown"
+  line; a `Reconfigure()` that changes it rolls over next at the new zone's
+  midnight. The fixed-layout crash line (in a POSIX signal handler, or when
+  the logger's lock stays busy) stays UTC with milliseconds. Local time
+  costs a `localtime_s`/`localtime_r` call per line. `Time::WriteISO8601()`
+  and `Time::ToISO8601String()` take the zone and precision too, and
+  `Time::ToDateString()` the zone.
+
 ### Changed
 
 - Writing a formatted line is much faster: the built-in layout now writes
diff --git a/README.md b/README.md
index 8684cea..f16089a 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
 - Portable C++20 logger for Windows and Linux, with CMake and RAD Studio examples.
 - Thread-safe file logging with singleton or independent logger instances.
 - Configurable log levels, metadata, line endings, flushing, file paths, and rotation.
+- ISO 8601 timestamps in UTC (the default) or local time with its offset, to the millisecond, microsecond or
+  nanosecond (`Line.TimestampZone`, `Line.TimestampPrecision`); daily rolling and backup names follow the same clock.
 - Formatted, raw, forced, and force-raw logging APIs with source-location support. Format strings are checked
   against their arguments at compile time; wrap one built at run time in `ASWLog::RuntimeFormat()`.
 - Runtime `Open()`, `Close()`, `Flush()` and log rotation controls, and `Reconfigure()` to change settings safely
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index 7656b26..5cf83b8 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -43,6 +43,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Types.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Utils.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Version.cpp"
+    "${ASWLOG_TESTS_DIR}/UT_Helper_DateTime.cpp"
 )
 
 target_include_directories(ASWLogTests PRIVATE
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index e22aa6a..a506c85 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -246,6 +246,10 @@
             <DependentOn>..\tests\Test_ASWLog_Version.h</DependentOn>
             <BuildOrder>31</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\UT_Helper_DateTime.cpp">
+            <DependentOn>..\tests\UT_Helper_DateTime.h</DependentOn>
+            <BuildOrder>35</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\third_party\asw-unit-tests\src\ASWUnitTests_CLI.cpp">
             <DependentOn>..\..\third_party\asw-unit-tests\src\ASWUnitTests_CLI.h</DependentOn>
             <BuildOrder>8</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 639d9c5..0c39deb 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -89,6 +89,8 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     // Assert: Line
     CheckTrue(config.Line.Formatter == nullptr, "Line.Formatter should default to unset (the built-in layout)");
     CheckTrue(config.Line.Ending == ASWLog::LineEnding::LF, "Line.Ending should default to LF");
+    CheckTrue(config.Line.TimestampZone == ASWLog::TimeZone::UTC, "Line.TimestampZone should default to UTC");
+    CheckTrue(config.Line.TimestampPrecision == ASWLog::TimePrecision::Milliseconds, "Line.TimestampPrecision should default to Milliseconds");
     CheckTrue(config.Line.ShowTimestamp, "Line.ShowTimestamp should default to true");
     CheckTrue(config.Line.ShowLevel, "Line.ShowLevel should default to true");
     CheckTrue(config.Line.ShowProcessId, "Line.ShowProcessId should default to true");
diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index 4fd71e1..4bc94cf 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -57,6 +57,8 @@ limitations under the License.
 #include "ASWLog_FileLog.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
+#include "UT_Helper_DateTime.h"
+//---------------------------------------------------------------------------
 
 namespace ASWUnitTests
 {
@@ -127,6 +129,12 @@ class TFixedClockFileLog : public ASWLog::TASWFileLog
 public:
     std::chrono::system_clock::time_point CurrentTime{};
 
+    // Finalized here, so the shutdown line still gets the fixed clock
+    ~TFixedClockFileLog() override
+    {
+        Finalize();
+    }
+
 protected:
     std::chrono::system_clock::time_point NowUTC() const noexcept override
     {
@@ -354,8 +362,11 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_ChildProcess_DoesNotInheritLogFile, "ChildProcess_DoesNotInheritLogFile");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_KeepsExistingBackupForSameDate, "DailyRolling_KeepsExistingBackupForSameDate");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_KeepsLeftoverLogFromSameDay, "DailyRolling_KeepsLeftoverLogFromSameDay");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_LocalZoneRollsAtLocalMidnight, "DailyRolling_LocalZoneRollsAtLocalMidnight");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_NamesBackupForContentDate, "DailyRolling_NamesBackupForContentDate");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_ReconfiguredZoneRollsAtItsMidnight, "DailyRolling_ReconfiguredZoneRollsAtItsMidnight");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_RotatesLeftoverLogFromEarlierDay, "DailyRolling_RotatesLeftoverLogFromEarlierDay");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_RotatesLeftoverLogFromEarlierLocalDay, "DailyRolling_RotatesLeftoverLogFromEarlierLocalDay");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_SharedLogRollsOverOnce, "DailyRolling_SharedLogRollsOverOnce");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_AcceptsShortRelativeFolder, "DeleteOldLogs_AcceptsShortRelativeFolder");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_EmptyPatternDeletesNothing, "DeleteOldLogs_EmptyPatternDeletesNothing");
@@ -407,7 +418,9 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_RetentionMaxAge_DefaultDisabledPreservesOldBackups, "RetentionMaxAge_DefaultDisabledPreservesOldBackups");
     RegisterTest(&TTest_ASWLog_FileLog::Test_RetentionMaxAge_DeletesExpiredBackupsAfterRotation, "RetentionMaxAge_DeletesExpiredBackupsAfterRotation");
     RegisterTest(&TTest_ASWLog_FileLog::Test_RotateLogFiles_KeepsEveryBackup, "RotateLogFiles_KeepsEveryBackup");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_RotateLogFiles_NamesBackupInLocalTime, "RotateLogFiles_NamesBackupInLocalTime");
     RegisterTest(&TTest_ASWLog_FileLog::Test_SetEnabled_FalseStopsAutoOpenCloseLogging, "SetEnabled_FalseStopsAutoOpenCloseLogging");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_ShutdownLine_TimeFollowsTimestampZone, "ShutdownLine_TimeFollowsTimestampZone");
     RegisterTest(&TTest_ASWLog_FileLog::Test_SizeRotation_AutoOpenCloseCountsOtherWriters, "SizeRotation_AutoOpenCloseCountsOtherWriters");
     RegisterTest(&TTest_ASWLog_FileLog::Test_SizeRotation_CountsExistingFileSize, "SizeRotation_CountsExistingFileSize");
     RegisterTest(&TTest_ASWLog_FileLog::Test_SizeRotation_RotatesWhenLimitReached, "SizeRotation_RotatesWhenLimitReached");
@@ -866,6 +879,42 @@ void TTest_ASWLog_FileLog::Test_DailyRolling_KeepsLeftoverLogFromSameDay()
     CheckContains(contents, "new_entry", "New entries should be appended to the log");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_DailyRolling_LocalZoneRollsAtLocalMidnight()
+{
+    // Arrange: US Eastern time, 5 hours behind UTC in January
+    using namespace std::chrono_literals;
+    const TScopedTimeZone timeZone("EST5EDT");
+    const auto logFile = TestTempDir / "local_rolling.log";
+    auto config = MakeRotationTestConfig(logFile);
+    config.File.EnableDailyRolling = true;
+    config.Line.TimestampZone = ASWLog::TimeZone::Local;
+
+    // Started after UTC midnight, when it is still the 15th in local time
+    const auto utcDay = std::chrono::sys_days{ 2026y / 1 / 16 };
+    TFixedClockFileLog logger;
+    logger.CurrentTime = utcDay + 1min;
+
+    // Act: log in the local evening, just before local midnight, then after it
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("evening_entry");
+    logger.CurrentTime = utcDay + 4h + 59min;
+    logger.LogInfo("before_local_midnight");
+    logger.CurrentTime = utcDay + 5h + 1min;
+    logger.LogInfo("after_local_midnight");
+    logger.Close();
+
+    // Assert
+    const auto backupContents = ReadFileText(TestTempDir / "local_rolling.daily.2026-01-15.bak");
+    const auto currentContents = ReadFileText(logFile);
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckFalse(std::filesystem::exists(TestTempDir / "local_rolling.daily.2026-01-16.bak"), "No backup should be named for the UTC date");
+    CheckContains(backupContents, "evening_entry", "The backup should be named for the local day its entries are from");
+    CheckContains(backupContents, "before_local_midnight", "The log should not roll over before local midnight");
+    CheckNotContains(backupContents, "after_local_midnight", "The backup should not contain entries from the new local day");
+    CheckContains(currentContents, "after_local_midnight", "The log should roll over at local midnight");
+    CheckNotContains(currentContents, "evening_entry", "The new local day's file should not contain the previous day's entries");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_DailyRolling_NamesBackupForContentDate()
 {
     // Arrange
@@ -896,6 +945,40 @@ void TTest_ASWLog_FileLog::Test_DailyRolling_NamesBackupForContentDate()
     CheckNotContains(currentContents, "day_one_entry", "The reopened log file should not contain the previous day's entries");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_DailyRolling_ReconfiguredZoneRollsAtItsMidnight()
+{
+    // Arrange: 01:00 UTC on the 16th is 20:00 on the 15th in US Eastern time
+    using namespace std::chrono_literals;
+    const TScopedTimeZone timeZone("EST5EDT");
+    const auto logFile = TestTempDir / "zone_change.log";
+    auto config = MakeRotationTestConfig(logFile);
+    config.File.EnableDailyRolling = true;
+
+    const auto utcDay = std::chrono::sys_days{ 2026y / 1 / 16 };
+    TFixedClockFileLog logger;
+    logger.CurrentTime = utcDay + 1h;
+
+    // Act: switch from UTC to local time, then log after local midnight
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("before_switch");
+    config.Line.TimestampZone = ASWLog::TimeZone::Local;
+    const bool reconfigured = logger.Reconfigure(config);
+    logger.LogInfo("after_switch");
+    logger.CurrentTime = utcDay + 5h + 1min;
+    logger.LogInfo("after_local_midnight");
+    logger.Close();
+
+    // Assert
+    const auto backupContents = ReadFileText(TestTempDir / "zone_change.daily.2026-01-15.bak");
+    const auto currentContents = ReadFileText(logFile);
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(reconfigured, "Reconfigure should succeed");
+    CheckContains(backupContents, "before_switch", "After the switch, the file's day should be the local date");
+    CheckContains(backupContents, "after_switch", "The switch itself should not roll the log over");
+    CheckContains(currentContents, "after_local_midnight", "The log should roll over at the new zone's midnight");
+    CheckNotContains(currentContents, "after_switch", "The new local day's file should not contain the previous day's entries");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_DailyRolling_RotatesLeftoverLogFromEarlierDay()
 {
     // Arrange: a log last written 30 hours before the logger starts at 10:00 UTC on 2026-01-15, i.e. on 2026-01-14
@@ -929,6 +1012,39 @@ void TTest_ASWLog_FileLog::Test_DailyRolling_RotatesLeftoverLogFromEarlierDay()
     CheckNotContains(currentContents, "yesterday_entry", "The new log file should not contain the earlier day's entries");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_DailyRolling_RotatesLeftoverLogFromEarlierLocalDay()
+{
+    // Arrange: the logger starts at 00:10 on the 16th in US Eastern time (05:10 UTC); the log was last written 20 minutes
+    // earlier, on the 15th in local time but on the same UTC day
+    using namespace std::chrono_literals;
+    const TScopedTimeZone timeZone("EST5EDT");
+    const auto logFile = TestTempDir / "leftover_local.log";
+    {
+        std::ofstream leftoverStream(logFile);
+        leftoverStream << "local_yesterday_entry\n";
+    }
+
+    std::filesystem::last_write_time(logFile, std::chrono::file_clock::now() - 20min);
+
+    auto config = MakeRotationTestConfig(logFile);
+    config.File.EnableDailyRolling = true;
+    config.Line.TimestampZone = ASWLog::TimeZone::Local;
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 16 } + 5h + 10min;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("local_today_entry");
+    logger.Close();
+
+    // Assert
+    const auto backupContents = ReadFileText(TestTempDir / "leftover_local.daily.2026-01-15.bak");
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckContains(backupContents, "local_yesterday_entry", "The leftover log should be rotated to a backup named for the local day it was written");
+    CheckNotContains(ReadFileText(logFile), "local_yesterday_entry", "The new log file should not contain the earlier local day's entries");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_DailyRolling_SharedLogRollsOverOnce()
 {
     // Arrange: two loggers sharing one log, as two processes would (File.AutoOpenClosePerWrite), both logging at 23:59 UTC
@@ -2745,6 +2861,30 @@ void TTest_ASWLog_FileLog::Test_RotateLogFiles_KeepsEveryBackup()
     CheckContains(ReadFileText(logFile), "third_segment", "Entries after the last rotation should go to the reopened log file");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_RotateLogFiles_NamesBackupInLocalTime()
+{
+    // Arrange: 04:59:30.250 UTC on the 16th is 23:59:30.250 on the 15th in US Eastern time
+    using namespace std::chrono_literals;
+    const TScopedTimeZone timeZone("EST5EDT");
+    const auto logFile = TestTempDir / "rotate_local.log";
+    auto config = MakeRotationTestConfig(logFile);
+    config.Line.TimestampZone = ASWLog::TimeZone::Local;
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 16 } + 4h + 59min + 30s + 250ms;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("rotated_entry");
+    const bool rotated = logger.RotateLogFiles("manual");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(rotated, "RotateLogFiles should succeed");
+    CheckContains(ReadFileText(TestTempDir / "rotate_local.manual.2026-01-15_235930_250.bak"), "rotated_entry", "The backup should be named for the local time");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_SetEnabled_FalseStopsAutoOpenCloseLogging()
 {
     // Arrange: with File.AutoOpenClosePerWrite the file is only open while an entry is written
@@ -2775,6 +2915,30 @@ void TTest_ASWLog_FileLog::Test_SetEnabled_FalseStopsAutoOpenCloseLogging()
     CheckEquals(std::string(": enabled_again\n"), ReadFileText(logFile), "Logging should resume once enabled again");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_ShutdownLine_TimeFollowsTimestampZone()
+{
+    // Arrange: 04:59:30.250 UTC on the 16th is 23:59:30.250 on the 15th in US Eastern time
+    using namespace std::chrono_literals;
+    const TScopedTimeZone timeZone("EST5EDT");
+    const auto logFile = TestTempDir / "shutdown_local.log";
+    auto config = MakeRotationTestConfig(logFile);
+    config.Line.TimestampZone = ASWLog::TimeZone::Local;
+    config.Line.TimestampPrecision = ASWLog::TimePrecision::Microseconds;
+    config.Shutdown.WriteLine = true;
+
+    // Act
+    bool initialized = false;
+    {
+        TFixedClockFileLog logger;
+        logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 16 } + 4h + 59min + 30s + 250ms;
+        initialized = logger.Initialize(config);
+    }
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckContains(ReadFileText(logFile), ": Logger shutdown: 2026-01-15T23:59:30.250000-05:00\n", "The shutdown line's time should use the line's zone and precision");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_SizeRotation_AutoOpenCloseCountsOtherWriters()
 {
     // Arrange: in File.AutoOpenClosePerWrite mode the log is closed between writes, so other processes can append to it
diff --git a/tests/tests/Test_ASWLog_FileLog.h b/tests/tests/Test_ASWLog_FileLog.h
index c942bfe..c18e7ba 100644
--- a/tests/tests/Test_ASWLog_FileLog.h
+++ b/tests/tests/Test_ASWLog_FileLog.h
@@ -49,8 +49,11 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_ChildProcess_DoesNotInheritLogFile();
     void Test_DailyRolling_KeepsExistingBackupForSameDate();
     void Test_DailyRolling_KeepsLeftoverLogFromSameDay();
+    void Test_DailyRolling_LocalZoneRollsAtLocalMidnight();
     void Test_DailyRolling_NamesBackupForContentDate();
+    void Test_DailyRolling_ReconfiguredZoneRollsAtItsMidnight();
     void Test_DailyRolling_RotatesLeftoverLogFromEarlierDay();
+    void Test_DailyRolling_RotatesLeftoverLogFromEarlierLocalDay();
     void Test_DailyRolling_SharedLogRollsOverOnce();
     void Test_DeleteOldLogs_AcceptsShortRelativeFolder();
     void Test_DeleteOldLogs_EmptyPatternDeletesNothing();
@@ -102,7 +105,9 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_RetentionMaxAge_DefaultDisabledPreservesOldBackups();
     void Test_RetentionMaxAge_DeletesExpiredBackupsAfterRotation();
     void Test_RotateLogFiles_KeepsEveryBackup();
+    void Test_RotateLogFiles_NamesBackupInLocalTime();
     void Test_SetEnabled_FalseStopsAutoOpenCloseLogging();
+    void Test_ShutdownLine_TimeFollowsTimestampZone();
     void Test_SizeRotation_AutoOpenCloseCountsOtherWriters();
     void Test_SizeRotation_CountsExistingFileSize();
     void Test_SizeRotation_RotatesWhenLimitReached();
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index ceb1a31..f8b4262 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -45,6 +45,8 @@ limitations under the License.
 #include "ASWLog_Formatter.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
+#include "UT_Helper_DateTime.h"
+//---------------------------------------------------------------------------
 
 namespace ASWUnitTests
 {
@@ -172,6 +174,7 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_LargestIdsAndEachLevel, "FormatLine_LargestIdsAndEachLevel");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_MemoryFields, "FormatLine_MemoryFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_NoFields, "FormatLine_NoFields");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_TimestampFollowsZoneAndPrecision, "FormatLine_TimestampFollowsZoneAndPrecision");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread, "Formatter_ReceivesRecordFromLoggingThread");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_SharedByTwoLoggers, "Formatter_SharedByTwoLoggers");
 }
@@ -310,6 +313,22 @@ void TTest_ASWLog_Formatter::Test_FormatLine_NoFields()
     CheckEquals(std::string(": just the message"), line, "With every field off, only the separator and message remain");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_FormatLine_TimestampFollowsZoneAndPrecision()
+{
+    // Arrange: FixedTime is 2026-09-21T14:13:20.123Z, during US Eastern daylight time
+    auto config = MakeConfigWithoutFields("unused.log");
+    config.Line.ShowTimestamp = true;
+    config.Line.TimestampZone = ASWLog::TimeZone::Local;
+    config.Line.TimestampPrecision = ASWLog::TimePrecision::Microseconds;
+    const TScopedTimeZone timeZone("EST5EDT");
+
+    // Act
+    const auto line = ASWLog::TASWTextFormatter::FormatLine(MakeRecord("local"), config);
+
+    // Assert
+    CheckEquals(std::string("[2026-09-21T10:13:20.123000-04:00]: local"), line, "The timestamp should be local time with microseconds and the offset");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_Formatter.h b/tests/tests/Test_ASWLog_Formatter.h
index db77d15..55e6495 100644
--- a/tests/tests/Test_ASWLog_Formatter.h
+++ b/tests/tests/Test_ASWLog_Formatter.h
@@ -41,6 +41,7 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
     void Test_FormatLine_LargestIdsAndEachLevel();
     void Test_FormatLine_MemoryFields();
     void Test_FormatLine_NoFields();
+    void Test_FormatLine_TimestampFollowsZoneAndPrecision();
     void Test_Formatter_ReceivesRecordFromLoggingThread();
     void Test_Formatter_SharedByTwoLoggers();
 
diff --git a/tests/tests/Test_ASWLog_Types.cpp b/tests/tests/Test_ASWLog_Types.cpp
index e1f1005..ab08e2c 100644
--- a/tests/tests/Test_ASWLog_Types.cpp
+++ b/tests/tests/Test_ASWLog_Types.cpp
@@ -53,6 +53,10 @@ TTest_ASWLog_Types::TTest_ASWLog_Types()
     RegisterTest(&TTest_ASWLog_Types::Test_LineEnding_FromString, "LineEnding_FromString");
     RegisterTest(&TTest_ASWLog_Types::Test_LineEnding_ToString, "LineEnding_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_LogError_ToString, "LogError_ToString");
+    RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_FromString, "TimePrecision_FromString");
+    RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_ToString, "TimePrecision_ToString");
+    RegisterTest(&TTest_ASWLog_Types::Test_TimeZone_FromString, "TimeZone_FromString");
+    RegisterTest(&TTest_ASWLog_Types::Test_TimeZone_ToString, "TimeZone_ToString");
 }
 //---------------------------------------------------------------------------
 TTest_ASWLog_Types::~TTest_ASWLog_Types()
@@ -311,6 +315,55 @@ void TTest_ASWLog_Types::Test_LogError_ToString()
     CheckEquals("OPEN_FAILED: Couldn't open the log file 'logs/app.log': " + code.message() + " (3 more not reported)", everyPartText, "Every part should be in the line");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_TimePrecision_FromString()
+{
+    // Arrange
+    const auto milliseconds = ASWLog::TimePrecision_FromString("MILLISECONDS");
+    const auto microseconds = ASWLog::TimePrecision_FromString("microseconds");
+    const auto nanoseconds = ASWLog::TimePrecision_FromString("NANOSECONDS");
+    const auto msAlias = ASWLog::TimePrecision_FromString("ms");
+    const auto usAlias = ASWLog::TimePrecision_FromString("US");
+    const auto nsAlias = ASWLog::TimePrecision_FromString("NS");
+    const auto unknown = ASWLog::TimePrecision_FromString("seconds");
+
+    // Act & Assert
+    CheckTrue(milliseconds == ASWLog::TimePrecision::Milliseconds, "MILLISECONDS should map to Milliseconds");
+    CheckTrue(microseconds == ASWLog::TimePrecision::Microseconds, "microseconds should map to Microseconds, ignoring case");
+    CheckTrue(nanoseconds == ASWLog::TimePrecision::Nanoseconds, "NANOSECONDS should map to Nanoseconds");
+    CheckTrue(msAlias == ASWLog::TimePrecision::Milliseconds, "ms should map to Milliseconds");
+    CheckTrue(usAlias == ASWLog::TimePrecision::Microseconds, "US should map to Microseconds");
+    CheckTrue(nsAlias == ASWLog::TimePrecision::Nanoseconds, "NS should map to Nanoseconds");
+    CheckFalse(unknown.has_value(), "An unknown precision should not parse");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_TimePrecision_ToString()
+{
+    // Act & Assert
+    CheckEquals(std::string("MILLISECONDS"), std::string(ASWLog::TimePrecision_ToString(ASWLog::TimePrecision::Milliseconds)), "Milliseconds should stringify as MILLISECONDS");
+    CheckEquals(std::string("MICROSECONDS"), std::string(ASWLog::TimePrecision_ToString(ASWLog::TimePrecision::Microseconds)), "Microseconds should stringify as MICROSECONDS");
+    CheckEquals(std::string("NANOSECONDS"), std::string(ASWLog::TimePrecision_ToString(ASWLog::TimePrecision::Nanoseconds)), "Nanoseconds should stringify as NANOSECONDS");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_TimeZone_FromString()
+{
+    // Arrange
+    const auto utc = ASWLog::TimeZone_FromString("UTC");
+    const auto local = ASWLog::TimeZone_FromString("local");
+    const auto unknown = ASWLog::TimeZone_FromString("EST");
+
+    // Act & Assert
+    CheckTrue(utc == ASWLog::TimeZone::UTC, "UTC should map to UTC");
+    CheckTrue(local == ASWLog::TimeZone::Local, "local should map to Local, ignoring case");
+    CheckFalse(unknown.has_value(), "A named time zone should not parse");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_TimeZone_ToString()
+{
+    // Act & Assert
+    CheckEquals(std::string("UTC"), std::string(ASWLog::TimeZone_ToString(ASWLog::TimeZone::UTC)), "UTC should stringify as UTC");
+    CheckEquals(std::string("LOCAL"), std::string(ASWLog::TimeZone_ToString(ASWLog::TimeZone::Local)), "Local should stringify as LOCAL");
+}
+//---------------------------------------------------------------------------
 
 } // namespace ASWUnitTests
 
diff --git a/tests/tests/Test_ASWLog_Types.h b/tests/tests/Test_ASWLog_Types.h
index 6b6de75..69b5735 100644
--- a/tests/tests/Test_ASWLog_Types.h
+++ b/tests/tests/Test_ASWLog_Types.h
@@ -48,6 +48,10 @@ class TTest_ASWLog_Types : public TTestGroupBase
     void Test_LineEnding_FromString();
     void Test_LineEnding_ToString();
     void Test_LogError_ToString();
+    void Test_TimePrecision_FromString();
+    void Test_TimePrecision_ToString();
+    void Test_TimeZone_FromString();
+    void Test_TimeZone_ToString();
 
 public:
     TTest_ASWLog_Types();
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index 2ea5513..23371ae 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -33,6 +33,7 @@ limitations under the License.
 #include <filesystem>
 #include <fstream>
 #include <iterator>
+#include <ratio>
 #include <string>
 #include <system_error>
 #include <thread>
@@ -43,6 +44,8 @@ limitations under the License.
 //---------------------------------------------------------------------------
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
+#include "UT_Helper_DateTime.h"
+//---------------------------------------------------------------------------
 
 namespace ASWUnitTests
 {
@@ -50,75 +53,11 @@ namespace ASWUnitTests
 namespace
 {
 
-// While alive, sets the C runtime's local time zone through the TZ environment variable (POSIX format, e.g. "EST5EDT",
-// which the Windows C runtime also reads), then restores the previous value.
-class TScopedTimeZone
-{
-private:
-    bool m_HadValue = false;
-    std::string m_PreviousValue;
-
-    // Sets TZ to 'value', or removes it if 'value' is null, and makes the C runtime read it again
-    static void Apply(const char* value)
-    {
-#if defined(_WIN32)
-        _putenv_s("TZ", value != nullptr ? value : ""); // An empty value removes the variable
-        _tzset();
-
-        // Once the Windows C runtime has read a system time zone without daylight saving time (e.g. UTC on CI machines,
-        // or Arizona), it keeps that zone's daylight saving bias of 0 even when TZ then names a zone that has daylight
-        // saving time, so summer would be flagged as daylight saving time without moving the clock. TZ can't give the
-        // bias, so set the usual hour.
-        int hasDaylightSavingTime = 0;
-        if (value != nullptr && _get_daylight(&hasDaylightSavingTime) == 0 && hasDaylightSavingTime != 0)
-        {
-            // __dstbias() is deprecated in favor of _get_dstbias(), which can't set it.
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4996)
-#endif
-            *__dstbias() = -3600;
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-        }
-#else
-        if (value != nullptr)
-            setenv("TZ", value, 1);
-        else
-            unsetenv("TZ");
-        tzset();
-#endif
-    }
-
-public:
-    explicit TScopedTimeZone(const char* timeZone)
-    {
-#if defined(_WIN32)
-        // _putenv_s also updates the process environment, which GetEnvironmentVariableA reads (avoids getenv(), which
-        // MSVC warns about)
-        char buffer[256]{};
-        const DWORD length = GetEnvironmentVariableA("TZ", buffer, sizeof(buffer));
-        m_HadValue = length > 0 && length < sizeof(buffer);
-        if (m_HadValue)
-            m_PreviousValue.assign(buffer, length);
-#else
-        const char* previous = std::getenv("TZ");
-        m_HadValue = previous != nullptr;
-        if (m_HadValue)
-            m_PreviousValue = previous;
-#endif
-        Apply(timeZone);
-    }
-
-    ~TScopedTimeZone()
-    {
-        Apply(m_HadValue ? m_PreviousValue.c_str() : nullptr);
-    }
+// True if system_clock ticks in less than 1 us (100 ns with MSVC and MinGW on Windows, 1 ns with libstdc++ on Linux),
+// false for 1 us (libc++, e.g. RAD Studio)
+constexpr bool HasSubmicrosecondClock = std::ratio_less_v<std::chrono::system_clock::period, std::micro>;
 
-    TScopedTimeZone(const TScopedTimeZone&) = delete;
-    TScopedTimeZone& operator=(const TScopedTimeZone&) = delete;
-};
+//---------------------------------------------------------------------------
 
 std::string ReadText(const std::filesystem::path& path)
 {
@@ -147,9 +86,12 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_RenameWithoutReplacing_KeepsExistingTarget, "RenameWithoutReplacing_KeepsExistingTarget");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime, "Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToDateString, "Time_ToDateString");
+    RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToDateString_FollowsZone, "Time_ToDateString_FollowsZone");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToISO8601String, "Time_ToISO8601String");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToLocalISO8601String_IncludesOffset, "Time_ToLocalISO8601String_IncludesOffset");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_CalendarEdges, "Time_WriteISO8601_CalendarEdges");
+    RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_LocalTimeWithEachPrecision, "Time_WriteISO8601_LocalTimeWithEachPrecision");
+    RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision, "Time_WriteISO8601_UTCWithEachPrecision");
 }
 //---------------------------------------------------------------------------
 TTest_ASWLog_Utils::~TTest_ASWLog_Utils()
@@ -466,6 +408,22 @@ void TTest_ASWLog_Utils::Test_Time_ToDateString()
     CheckContains(date, "-", "Date string should include date separators");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_Time_ToDateString_FollowsZone()
+{
+    // Arrange: 02:00 UTC is still the evening before in US Eastern time
+    using namespace std::chrono_literals;
+    const auto time = std::chrono::sys_days{ 2026y / 7 / 1 } + 2h;
+    const TScopedTimeZone timeZone("EST5EDT");
+
+    // Act
+    const auto utcDate = ASWLog::Time::ToDateString(time);
+    const auto localDate = ASWLog::Time::ToDateString(time, ASWLog::TimeZone::Local);
+
+    // Assert
+    CheckEquals(std::string("2026-07-01"), utcDate, "The UTC date should be the default");
+    CheckEquals(std::string("2026-06-30"), localDate, "The local date should be the day before, 4 hours behind UTC");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_Time_ToISO8601String()
 {
     // Arrange
@@ -541,6 +499,64 @@ void TTest_ASWLog_Utils::Test_Time_WriteISO8601_CalendarEdges()
     }
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_Time_WriteISO8601_LocalTimeWithEachPrecision()
+{
+    // Arrange: a winter noon UTC, with a fraction whose 7th digit only a clock finer than 1 us keeps
+    using namespace std::chrono_literals;
+    const auto time = std::chrono::sys_days{ 2026y / 1 / 15 } + 12h + std::chrono::duration_cast<std::chrono::system_clock::duration>(7000400ns);
+    const std::string nanosecondDigits = HasSubmicrosecondClock ? "007000400" : "007000000";
+
+    const auto write = [&](ASWLog::TimePrecision precision) {
+            char buffer[ASWLog::Time::ISO8601BufferSize];
+            return std::string(buffer, ASWLog::Time::WriteISO8601(buffer, time, ASWLog::TimeZone::Local, precision));
+        };
+
+    // Act & Assert
+    {
+        const TScopedTimeZone timeZone("EST5EDT");
+        CheckEquals(std::string("2026-01-15T07:00:00.007-05:00"), write(ASWLog::TimePrecision::Milliseconds), "Milliseconds should come before the offset");
+        CheckEquals(std::string("2026-01-15T07:00:00.007000-05:00"), write(ASWLog::TimePrecision::Microseconds), "Microseconds should come before the offset");
+        CheckEquals("2026-01-15T07:00:00." + nanosecondDigits + "-05:00", write(ASWLog::TimePrecision::Nanoseconds), "Nanoseconds should come before the offset");
+        CheckEquals(std::string("2026-01-15T07:00:00.007000-05:00"), ASWLog::Time::ToISO8601String(time, ASWLog::TimeZone::Local, ASWLog::TimePrecision::Microseconds), "ToISO8601String should pass the zone and precision on");
+    }
+    {
+        const TScopedTimeZone timeZone("IST-5:30");
+        CheckEquals("2026-01-15T17:30:00." + nanosecondDigits + "+05:30", write(ASWLog::TimePrecision::Nanoseconds), "A zone ahead of UTC should show a '+' offset with its minutes");
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision()
+{
+    // Arrange: a fraction with a digit in each place, the 7th only kept by a clock finer than 1 us
+    using namespace std::chrono_literals;
+    const auto time = std::chrono::sys_days{ 2026y / 7 / 1 } + 12h + std::chrono::duration_cast<std::chrono::system_clock::duration>(123456700ns);
+
+    struct TCase
+    {
+        ASWLog::TimePrecision Precision;
+        std::string Expected;
+        std::string What;
+    };
+
+    const TCase cases[] = {
+        { ASWLog::TimePrecision::Milliseconds, "2026-07-01T12:00:00.123Z", "Milliseconds should show 3 digits" },
+        { ASWLog::TimePrecision::Microseconds, "2026-07-01T12:00:00.123456Z", "Microseconds should show 6 digits, cut off rather than rounded" },
+        { ASWLog::TimePrecision::Nanoseconds, HasSubmicrosecondClock ? "2026-07-01T12:00:00.123456700Z" : "2026-07-01T12:00:00.123456000Z",
+          "Nanoseconds should show 9 digits, as far as the clock holds them" },
+    };
+
+    for (const auto& testCase : cases)
+    {
+        // Act
+        char buffer[ASWLog::Time::ISO8601BufferSize];
+        const auto size = ASWLog::Time::WriteISO8601(buffer, time, ASWLog::TimeZone::UTC, testCase.Precision);
+
+        // Assert
+        CheckEquals(testCase.Expected, std::string(buffer, size), testCase.What);
+        CheckEquals(testCase.Expected, ASWLog::Time::ToISO8601String(time, ASWLog::TimeZone::UTC, testCase.Precision), testCase.What + " (ToISO8601String)");
+    }
+}
+//---------------------------------------------------------------------------
 
 } // namespace ASWUnitTests
 
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index c23c1f9..cf38644 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -49,9 +49,12 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_RenameWithoutReplacing_KeepsExistingTarget();
     void Test_Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime();
     void Test_Time_ToDateString();
+    void Test_Time_ToDateString_FollowsZone();
     void Test_Time_ToISO8601String();
     void Test_Time_ToLocalISO8601String_IncludesOffset();
     void Test_Time_WriteISO8601_CalendarEdges();
+    void Test_Time_WriteISO8601_LocalTimeWithEachPrecision();
+    void Test_Time_WriteISO8601_UTCWithEachPrecision();
 
 public:
     TTest_ASWLog_Utils();
diff --git a/tests/tests/UT_Helper_DateTime.cpp b/tests/tests/UT_Helper_DateTime.cpp
new file mode 100644
index 0000000..c5ac4e1
--- /dev/null
+++ b/tests/tests/UT_Helper_DateTime.cpp
@@ -0,0 +1,101 @@
+/* **************************************************************************
+UT_Helper_DateTime.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "UT_Helper_DateTime.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstdlib>
+#include <ctime>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TScopedTimeZone
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TScopedTimeZone::TScopedTimeZone(const char* timeZone)
+{
+#if defined(_WIN32)
+    // _putenv_s also updates the process environment, which GetEnvironmentVariableA reads (avoids getenv(), which
+    // MSVC warns about)
+    char buffer[256]{};
+    const DWORD length = GetEnvironmentVariableA("TZ", buffer, sizeof(buffer));
+    m_HadValue = length > 0 && length < sizeof(buffer);
+    if (m_HadValue)
+        m_PreviousValue.assign(buffer, length);
+#else
+    const char* previous = std::getenv("TZ");
+    m_HadValue = previous != nullptr;
+    if (m_HadValue)
+        m_PreviousValue = previous;
+#endif
+    Apply(timeZone);
+}
+//---------------------------------------------------------------------------
+TScopedTimeZone::~TScopedTimeZone()
+{
+    Apply(m_HadValue ? m_PreviousValue.c_str() : nullptr);
+}
+//---------------------------------------------------------------------------
+void TScopedTimeZone::Apply(const char* value)
+{
+#if defined(_WIN32)
+    _putenv_s("TZ", value != nullptr ? value : ""); // An empty value removes the variable
+    _tzset();
+
+    // Once the Windows C runtime has read a system time zone without daylight saving time (e.g. UTC on CI machines, or
+    // Arizona), it keeps that zone's daylight saving bias of 0 even when TZ then names a zone that has daylight saving
+    // time, so summer would be flagged as daylight saving time without moving the clock. TZ can't give the bias, so
+    // set the usual hour.
+    int hasDaylightSavingTime = 0;
+    if (value != nullptr && _get_daylight(&hasDaylightSavingTime) == 0 && hasDaylightSavingTime != 0)
+    {
+        // __dstbias() is deprecated in favor of _get_dstbias(), which can't set it.
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+        *__dstbias() = -3600;
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+    }
+#else
+    if (value != nullptr)
+        setenv("TZ", value, 1);
+    else
+        unsetenv("TZ");
+    tzset();
+#endif
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
diff --git a/tests/tests/UT_Helper_DateTime.h b/tests/tests/UT_Helper_DateTime.h
new file mode 100644
index 0000000..6cad910
--- /dev/null
+++ b/tests/tests/UT_Helper_DateTime.h
@@ -0,0 +1,59 @@
+/* **************************************************************************
+UT_Helper_DateTime.h
+Author: Anthony S. West - ASW Software
+
+Date and time helpers shared by the unit tests.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#ifndef UT_Helper_DateTimeH
+#define UT_Helper_DateTimeH
+//---------------------------------------------------------------------------
+#include <string>
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TScopedTimeZone
+//
+// While alive, sets the C runtime's local time zone through the TZ environment variable (POSIX format, e.g. "EST5EDT",
+// which the Windows C runtime also reads), then restores the previous value. For the tests of local time.
+///////////////////////////////////////////////////////////////////////////
+class TScopedTimeZone
+{
+private:
+    bool m_HadValue = false;
+    std::string m_PreviousValue;
+
+private:
+    // Sets TZ to 'value', or removes it if 'value' is null, and makes the C runtime read it again
+    static void Apply(const char* value);
+
+public:
+    explicit TScopedTimeZone(const char* timeZone);
+    ~TScopedTimeZone();
+
+    TScopedTimeZone(const TScopedTimeZone&) = delete;
+    TScopedTimeZone& operator=(const TScopedTimeZone&) = delete;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef UT_Helper_DateTimeH
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index 0fbc65b..e04a7c3 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -280,6 +280,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_Version.h</DependentOn>
             <BuildOrder>39</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\UT_Helper_DateTime.cpp">
+            <DependentOn>..\..\..\tests\UT_Helper_DateTime.h</DependentOn>
+            <BuildOrder>44</BuildOrder>
+        </CppCompile>
         <CppCompile Include="ASWLogTests_VCL_GUI.cpp">
             <BuildOrder>0</BuildOrder>
         </CppCompile>

From ce4f4b3690e65fdffbc66651776aa8e9a74a6e01 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Thu, 8 Oct 2026 06:36:09 -0700
Subject: [PATCH 04/38] Update ASWUnitTests to 1.2.0 and use its new checks

---
 tests/tests/Test_ASWLog_Base.cpp              | 64 ++++++++-----------
 tests/tests/Test_ASWLog_Config.cpp            | 36 +++++------
 tests/tests/Test_ASWLog_ConsoleLog.cpp        | 18 +++---
 tests/tests/Test_ASWLog_CrashHandler.cpp      |  2 +-
 tests/tests/Test_ASWLog_FileLog.cpp           | 54 ++++++----------
 tests/tests/Test_ASWLog_Formatter.cpp         | 18 +-----
 tests/tests/Test_ASWLog_MultiLog.cpp          | 28 +++-----
 tests/tests/Test_ASWLog_TextLogBase.cpp       | 40 ++++--------
 tests/tests/Test_ASWLog_Types.cpp             | 54 ++++++++--------
 tests/tests/Test_ASWLog_Utils.cpp             | 12 ++--
 tests/tests/Test_ASWLog_Version.cpp           | 44 ++-----------
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |  8 +++
 third_party/asw-unit-tests                    |  2 +-
 13 files changed, 147 insertions(+), 233 deletions(-)

diff --git a/tests/tests/Test_ASWLog_Base.cpp b/tests/tests/Test_ASWLog_Base.cpp
index e03b621..df1f9cd 100644
--- a/tests/tests/Test_ASWLog_Base.cpp
+++ b/tests/tests/Test_ASWLog_Base.cpp
@@ -453,7 +453,7 @@ void TTest_ASWLog_Base::Test_Backtrace_MinimumLevelChangesKeepTheBacktrace()
     // Assert
     CheckTrue(shouldLogTraceAtWarn, "The backtrace should still keep Trace with a minimum level of Warn");
     CheckFalse(shouldLogTraceAtOff, "A minimum level of Off should keep nothing");
-    CheckEquals(static_cast<int>(ASWLog::Level::Info), static_cast<int>(logger.GetMinimumLevel()),
+    CheckEquals(ASWLog::Level::Info, logger.GetMinimumLevel(),
         "GetMinimumLevel() should return the level set");
     const std::vector<std::string> expected{ "INFO|Backtrace: the last 1 entry below the minimum level|forced", "INFO|info_kept|forced",
                                              "INFO|Backtrace end|forced" };
@@ -656,27 +656,20 @@ void TTest_ASWLog_Base::Test_LogFormatMethods_LogErrorInsteadOfThrowing()
     std::string wrongArgumentCountMessage;
     std::string stdExceptionMessage;
     std::string otherExceptionMessage;
-    bool threw = false;
 
     // Act
-    try
-    {
-        logger.LogInfoFmt(ASWLog::RuntimeFormat("bad {} {}"), 1); // A literal would fail to compile
-        wrongArgumentCountMessage = logger.LastMessage;
+    CheckNoThrow([&] {
+            logger.LogInfoFmt(ASWLog::RuntimeFormat("bad {} {}"), 1); // A literal would fail to compile
+            wrongArgumentCountMessage = logger.LastMessage;
 
-        logger.LogErrorFmt("value {}", TThrowingValue{ true });
-        stdExceptionMessage = logger.LastMessage;
+            logger.LogErrorFmt("value {}", TThrowingValue{ true });
+            stdExceptionMessage = logger.LastMessage;
 
-        logger.LogForceFmt(ASWLog::Level::Warn, "value {}", TThrowingValue{ false });
-        otherExceptionMessage = logger.LastMessage;
-    }
-    catch (...)
-    {
-        threw = true;
-    }
+            logger.LogForceFmt(ASWLog::Level::Warn, "value {}", TThrowingValue{ false });
+            otherExceptionMessage = logger.LastMessage;
+        }, "A *Fmt call should not throw when formatting fails");
 
     // Assert
-    CheckFalse(threw, "A *Fmt call should not throw when formatting fails");
     CheckStartsWith(wrongArgumentCountMessage, "[ASWLog format error: ", "A format string that doesn't match its arguments should log the error: " + wrongArgumentCountMessage);
     CheckEndsWith(wrongArgumentCountMessage, "] bad {} {}", "The logged error should end with the format string: " + wrongArgumentCountMessage);
     CheckEquals(std::string("[ASWLog format error: formatter failed] value {}"), stdExceptionMessage, "A std::exception from a formatter should be logged with its message");
@@ -777,7 +770,7 @@ void TTest_ASWLog_Base::Test_LogFormatMethods_SkipFormattingWhenNotWritten()
     logger.LogForceFmt(ASWLog::Level::Critical, "{}", TCountedValue{});
     logger.LogForceRawFmt(ASWLog::Level::Critical, "{}", TCountedValue{});
     CheckEquals(3, CountedValueFormatCount, "Nothing should be formatted while the logger is disabled, not even forced entries");
-    CheckTrue(logger.LastMessage.empty(), "Nothing should reach the logger while it is disabled");
+    CheckEmpty(logger.LastMessage, "Nothing should reach the logger while it is disabled");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Base::Test_LogLevelConvenienceMethods()
@@ -790,42 +783,42 @@ void TTest_ASWLog_Base::Test_LogLevelConvenienceMethods()
     logger.LogTrace("trace");
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Trace), static_cast<int32_t>(logger.LastLevel), "LogTrace should set Trace level");
+    CheckEquals(ASWLog::Level::Trace, logger.LastLevel, "LogTrace should set Trace level");
     CheckEquals(std::string("trace"), logger.LastMessage, "LogTrace should store the message");
 
     // Act
     logger.LogDebug("debug");
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Debug), static_cast<int32_t>(logger.LastLevel), "LogDebug should set Debug level");
+    CheckEquals(ASWLog::Level::Debug, logger.LastLevel, "LogDebug should set Debug level");
     CheckEquals(std::string("debug"), logger.LastMessage, "LogDebug should store the message");
 
     // Act
     logger.LogInfo("info");
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Info), static_cast<int32_t>(logger.LastLevel), "LogInfo should set Info level");
+    CheckEquals(ASWLog::Level::Info, logger.LastLevel, "LogInfo should set Info level");
     CheckEquals(std::string("info"), logger.LastMessage, "LogInfo should store the message");
 
     // Act
     logger.LogWarn("warn");
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Warn), static_cast<int32_t>(logger.LastLevel), "LogWarn should set Warn level");
+    CheckEquals(ASWLog::Level::Warn, logger.LastLevel, "LogWarn should set Warn level");
     CheckEquals(std::string("warn"), logger.LastMessage, "LogWarn should store the message");
 
     // Act
     logger.LogError("error");
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Error), static_cast<int32_t>(logger.LastLevel), "LogError should set Error level");
+    CheckEquals(ASWLog::Level::Error, logger.LastLevel, "LogError should set Error level");
     CheckEquals(std::string("error"), logger.LastMessage, "LogError should store the message");
 
     // Act
     logger.LogCritical("critical");
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Critical), static_cast<int32_t>(logger.LastLevel), "LogCritical should set Critical level");
+    CheckEquals(ASWLog::Level::Critical, logger.LastLevel, "LogCritical should set Critical level");
     CheckEquals(std::string("critical"), logger.LastMessage, "LogCritical should store the message");
 }
 //---------------------------------------------------------------------------
@@ -840,7 +833,7 @@ void TTest_ASWLog_Base::Test_LogMethods_PassRecordsToWrite()
                                  std::source_location loc = std::source_location::current())
         {
             const auto& record = logger.LastRecord;
-            CheckEquals(static_cast<int32_t>(expectedLevel), static_cast<int32_t>(record.LogLevel), method + " should pass its level", loc);
+            CheckEquals(expectedLevel, record.LogLevel, method + " should pass its level", loc);
             CheckEquals(expectedMessage, std::string(record.Message), method + " should pass its message", loc);
             CheckEquals(expectedLine, record.Location.line(), method + " should pass the caller's line", loc);
             CheckEquals(expectedRaw, record.Raw, method + " should set Raw correctly", loc);
@@ -970,21 +963,14 @@ void TTest_ASWLog_Base::Test_ReportError_ThrowingHandlerDoesNotEscape()
         };
     logger.Initialize(config);
     logger.ThrowsOnWrite = true;
-    bool threw = false;
 
     // Act: ReportError() is noexcept, so an escaping exception would end the test run with std::terminate
-    try
-    {
-        logger.ReportTestError(ASWLog::ErrorKind::OpenFailed);
-        logger.LogError("dropped"); // Reported from TASWLogBase::Write()
-    }
-    catch (...)
-    {
-        threw = true;
-    }
+    CheckNoThrow([&] {
+            logger.ReportTestError(ASWLog::ErrorKind::OpenFailed);
+            logger.LogError("dropped"); // Reported from TASWLogBase::Write()
+        }, "An exception from OnError should not escape");
 
     // Assert
-    CheckFalse(threw, "An exception from OnError should not escape");
     CheckEquals(2, handlerCalls, "A handler that threw should still be called for the next failure");
 }
 //---------------------------------------------------------------------------
@@ -1038,13 +1024,13 @@ void TTest_ASWLog_Base::Test_SetGetMinimumLevel_RoundTrips()
     logger.Initialize(config);
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Warn), static_cast<int32_t>(logger.GetMinimumLevel()), "GetMinimumLevel should be seeded from the config's InitialMinimumLevel at Initialize() time");
+    CheckEquals(ASWLog::Level::Warn, logger.GetMinimumLevel(), "GetMinimumLevel should be seeded from the config's InitialMinimumLevel at Initialize() time");
 
     // Act
     logger.SetMinimumLevel(ASWLog::Level::Trace);
 
     // Assert
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Trace), static_cast<int32_t>(logger.GetMinimumLevel()), "SetMinimumLevel should update the value returned by GetMinimumLevel immediately");
+    CheckEquals(ASWLog::Level::Trace, logger.GetMinimumLevel(), "SetMinimumLevel should update the value returned by GetMinimumLevel immediately");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Base::Test_ShouldLog_ReflectsEnabledAndLevel()
@@ -1070,7 +1056,7 @@ void TTest_ASWLog_Base::Test_ShouldLog_ReflectsEnabledAndLevel()
 
     // Assert
     CheckTrue(enabledByDefault, "A logger should be enabled by default");
-    CheckTrue(logger.GetMinimumLevel() == ASWLog::Level::Off, "The minimum level should be readable through IASWLog");
+    CheckEquals(ASWLog::Level::Off, logger.GetMinimumLevel(), "The minimum level should be readable through IASWLog");
     CheckFalse(shouldLogInfo, "An entry below the minimum level should not be logged");
     CheckTrue(shouldLogWarn, "An entry at the minimum level should be logged");
     CheckFalse(shouldLogOff, "An entry at Off should never be logged");
@@ -1175,7 +1161,7 @@ void TTest_ASWLog_Base::Test_Write_ThrowingWriteRecordDropsEntry()
     if (reports.empty())
         return;
 
-    CheckTrue(reports[0].Kind == ASWLog::ErrorKind::Exception, "A dropped entry should be reported as an Exception");
+    CheckEquals(ASWLog::ErrorKind::Exception, reports[0].Kind, "A dropped entry should be reported as an Exception");
     CheckEquals(std::string("Dropped an entry: write failed"), reports[0].Message, "The report should give the exception's what()");
 }
 //---------------------------------------------------------------------------
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 0c39deb..6aaa48e 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -76,21 +76,21 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     const ASWLog::TASWLogConfig config;
 
     // Assert: top level
-    CheckTrue(config.InitialMinimumLevel == ASWLog::Level::Info, "InitialMinimumLevel should default to Info");
-    CheckTrue(config.OnLogEntry == nullptr, "OnLogEntry should default to unset");
-    CheckTrue(config.OnLogEntryMinimumLevel == ASWLog::Level::Error, "OnLogEntryMinimumLevel should default to Error");
-    CheckTrue(config.OnError == nullptr, "OnError should default to unset (reports go to stderr)");
+    CheckEquals(ASWLog::Level::Info, config.InitialMinimumLevel, "InitialMinimumLevel should default to Info");
+    CheckNull(config.OnLogEntry, "OnLogEntry should default to unset");
+    CheckEquals(ASWLog::Level::Error, config.OnLogEntryMinimumLevel, "OnLogEntryMinimumLevel should default to Error");
+    CheckNull(config.OnError, "OnError should default to unset (reports go to stderr)");
     CheckFalse(config.Async.Enabled, "Async.Enabled should default to false");
     CheckEquals(8192, config.Async.QueueCapacity, "Async.QueueCapacity should default to 8192");
-    CheckTrue(config.Async.OverflowPolicy == ASWLog::AsyncOverflowPolicy::Block, "Async.OverflowPolicy should default to Block");
-    CheckTrue(config.Async.WaitAtLevel == ASWLog::Level::Error, "Async.WaitAtLevel should default to Error");
+    CheckEquals(ASWLog::AsyncOverflowPolicy::Block, config.Async.OverflowPolicy, "Async.OverflowPolicy should default to Block");
+    CheckEquals(ASWLog::Level::Error, config.Async.WaitAtLevel, "Async.WaitAtLevel should default to Error");
     CheckTrue(config.ErrorReportInterval == std::chrono::minutes(1), "ErrorReportInterval should default to 1 minute");
 
     // Assert: Line
-    CheckTrue(config.Line.Formatter == nullptr, "Line.Formatter should default to unset (the built-in layout)");
-    CheckTrue(config.Line.Ending == ASWLog::LineEnding::LF, "Line.Ending should default to LF");
-    CheckTrue(config.Line.TimestampZone == ASWLog::TimeZone::UTC, "Line.TimestampZone should default to UTC");
-    CheckTrue(config.Line.TimestampPrecision == ASWLog::TimePrecision::Milliseconds, "Line.TimestampPrecision should default to Milliseconds");
+    CheckNull(config.Line.Formatter, "Line.Formatter should default to unset (the built-in layout)");
+    CheckEquals(ASWLog::LineEnding::LF, config.Line.Ending, "Line.Ending should default to LF");
+    CheckEquals(ASWLog::TimeZone::UTC, config.Line.TimestampZone, "Line.TimestampZone should default to UTC");
+    CheckEquals(ASWLog::TimePrecision::Milliseconds, config.Line.TimestampPrecision, "Line.TimestampPrecision should default to Milliseconds");
     CheckTrue(config.Line.ShowTimestamp, "Line.ShowTimestamp should default to true");
     CheckTrue(config.Line.ShowLevel, "Line.ShowLevel should default to true");
     CheckTrue(config.Line.ShowProcessId, "Line.ShowProcessId should default to true");
@@ -101,7 +101,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     CheckFalse(config.Line.ShowSourceLine, "Line.ShowSourceLine should default to false");
 
     // Assert: Startup
-    CheckTrue(config.Startup.Banner.empty(), "Startup.Banner should default to empty");
+    CheckEmpty(config.Startup.Banner, "Startup.Banner should default to empty");
     CheckTrue(config.Startup.WriteApplicationInfo, "Startup.WriteApplicationInfo should default to true");
     CheckFalse(config.Startup.WriteCommandLine, "Startup.WriteCommandLine should default to false");
     CheckTrue(config.Startup.WriteDriveInfo, "Startup.WriteDriveInfo should default to true");
@@ -112,22 +112,22 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
 
     // Assert: Shutdown
     CheckTrue(config.Shutdown.WriteLine, "Shutdown.WriteLine should default to true");
-    CheckTrue(config.Shutdown.Banner.empty(), "Shutdown.Banner should default to empty");
+    CheckEmpty(config.Shutdown.Banner, "Shutdown.Banner should default to empty");
     CheckTrue(config.Shutdown.WriteCrashLine, "Shutdown.WriteCrashLine should default to true");
 
     // Assert: Backtrace
     CheckEquals(0, config.Backtrace.Capacity, "Backtrace.Capacity should default to 0 (off)");
-    CheckEquals(static_cast<int>(ASWLog::Level::Trace), static_cast<int>(config.Backtrace.LowestLevel), "Backtrace.LowestLevel should default to Trace");
-    CheckEquals(static_cast<int>(ASWLog::Level::Error), static_cast<int>(config.Backtrace.DumpAtLevel), "Backtrace.DumpAtLevel should default to Error");
+    CheckEquals(ASWLog::Level::Trace, config.Backtrace.LowestLevel, "Backtrace.LowestLevel should default to Trace");
+    CheckEquals(ASWLog::Level::Error, config.Backtrace.DumpAtLevel, "Backtrace.DumpAtLevel should default to Error");
 
     // Assert: File
     CheckTrue(config.File.FolderPath == std::filesystem::path("logs"), "File.FolderPath should default to logs");
     CheckTrue(config.File.FilePath == std::filesystem::path("aswlog.txt"), "File.FilePath should default to aswlog.txt");
     CheckFalse(config.File.AutoOpenClosePerWrite, "File.AutoOpenClosePerWrite should default to false");
-    CheckTrue(config.File.Flush == ASWLog::FlushMode::EveryWrite, "File.Flush should default to EveryWrite");
+    CheckEquals(ASWLog::FlushMode::EveryWrite, config.File.Flush, "File.Flush should default to EveryWrite");
     CheckTrue(config.File.FlushInterval == std::chrono::milliseconds(1000), "File.FlushInterval should default to 1000 ms");
-    CheckTrue(config.File.FlushImmediatelyAtLevel == ASWLog::Level::Error, "File.FlushImmediatelyAtLevel should default to Error");
-    CheckTrue(config.File.SyncToDiskAtLevel == ASWLog::Level::Off, "File.SyncToDiskAtLevel should default to Off");
+    CheckEquals(ASWLog::Level::Error, config.File.FlushImmediatelyAtLevel, "File.FlushImmediatelyAtLevel should default to Error");
+    CheckEquals(ASWLog::Level::Off, config.File.SyncToDiskAtLevel, "File.SyncToDiskAtLevel should default to Off");
     CheckEquals(5, config.File.OpenRetryCount, "File.OpenRetryCount should default to 5");
     CheckTrue(config.File.OpenRetryDelay == std::chrono::milliseconds(50), "File.OpenRetryDelay should default to 50 ms");
     CheckTrue(config.File.CircuitBreakerResetDelay == std::chrono::milliseconds(500),
@@ -138,7 +138,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
         "File.RotationRetryDelay should default to 500 ms");
     CheckFalse(config.File.EnableDailyRolling, "File.EnableDailyRolling should default to false");
     CheckTrue(config.File.RetentionMaxAge == std::chrono::hours(0), "File.RetentionMaxAge should default to 0 (disabled)");
-    CheckTrue(config.File.OnBackupCreated == nullptr, "File.OnBackupCreated should default to unset");
+    CheckNull(config.File.OnBackupCreated, "File.OnBackupCreated should default to unset");
     CheckEquals(0, config.File.MaxBackupFiles, "File.MaxBackupFiles should default to 0 (unlimited)");
     CheckEquals(0, config.File.MaxBackupTotalBytes, "File.MaxBackupTotalBytes should default to 0 (unlimited)");
 }
diff --git a/tests/tests/Test_ASWLog_ConsoleLog.cpp b/tests/tests/Test_ASWLog_ConsoleLog.cpp
index 0659ca2..2ab52ae 100644
--- a/tests/tests/Test_ASWLog_ConsoleLog.cpp
+++ b/tests/tests/Test_ASWLog_ConsoleLog.cpp
@@ -365,7 +365,7 @@ void TTest_ASWLog_ConsoleLog::Test_ColorModeAuto_ColorsOnlyStreamsThatSupportIt(
 
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
-    CheckTrue(logger.GetColorMode() == ASWLog::ColorMode::Auto, "ColorMode should default to Auto");
+    CheckEquals(ASWLog::ColorMode::Auto, logger.GetColorMode(), "ColorMode should default to Auto");
     CheckContains(outContents, "\x1b[", "Auto should color a stream that shows colors");
     CheckNotContains(errContents, "\x1b[", "Auto should not color a stream that doesn't show colors, such as a file or a pipe");
     CheckContains(errContents, "stderr_message", "The uncolored message should still be written");
@@ -479,17 +479,17 @@ void TTest_ASWLog_ConsoleLog::Test_GetColorMode_ReflectsSetColorMode()
     ASWLog::TASWConsoleLog logger;
 
     // Assert
-    CheckTrue(logger.GetColorMode() == ASWLog::ColorMode::Auto, "ColorMode should default to Auto");
+    CheckEquals(ASWLog::ColorMode::Auto, logger.GetColorMode(), "ColorMode should default to Auto");
 
     // Act & Assert
     logger.SetColorMode(ASWLog::ColorMode::Always);
-    CheckTrue(logger.GetColorMode() == ASWLog::ColorMode::Always, "SetColorMode(Always) should be reflected by GetColorMode()");
+    CheckEquals(ASWLog::ColorMode::Always, logger.GetColorMode(), "SetColorMode(Always) should be reflected by GetColorMode()");
 
     logger.SetColorMode(ASWLog::ColorMode::Never);
-    CheckTrue(logger.GetColorMode() == ASWLog::ColorMode::Never, "SetColorMode(Never) should be reflected by GetColorMode()");
+    CheckEquals(ASWLog::ColorMode::Never, logger.GetColorMode(), "SetColorMode(Never) should be reflected by GetColorMode()");
 
     logger.SetColorMode(ASWLog::ColorMode::Auto);
-    CheckTrue(logger.GetColorMode() == ASWLog::ColorMode::Auto, "SetColorMode(Auto) should be reflected by GetColorMode()");
+    CheckEquals(ASWLog::ColorMode::Auto, logger.GetColorMode(), "SetColorMode(Auto) should be reflected by GetColorMode()");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_ConsoleLog::Test_GetInstance_ReturnsSameInstance()
@@ -499,7 +499,7 @@ void TTest_ASWLog_ConsoleLog::Test_GetInstance_ReturnsSameInstance()
     auto& second = ASWLog::TASWConsoleLog::GetInstance();
 
     // Assert
-    CheckTrue(&first == &second, "GetInstance should return the same logger on every call");
+    CheckSame(&first, &second, "GetInstance should return the same logger on every call");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_ConsoleLog::Test_GetLevelColor_OffHasNoColor()
@@ -514,7 +514,7 @@ void TTest_ASWLog_ConsoleLog::Test_GetLevelColor_OffHasNoColor()
     const auto offColor = logger.GetLevelColor(ASWLog::Level::Off);
 
     // Assert
-    CheckTrue(offColor.empty(), "Off isn't a severity, so it should have no color, and setting one should be ignored");
+    CheckEmpty(offColor, "Off isn't a severity, so it should have no color, and setting one should be ignored");
     CheckEquals(defaultCriticalColor, logger.GetLevelColor(ASWLog::Level::Critical),
         "Setting or resetting Off's color should not change another level's color");
 }
@@ -749,7 +749,7 @@ void TTest_ASWLog_ConsoleLog::Test_OnError_ReportsOnlyTheWriteThatFailedTheStrea
     if (reports.empty())
         return;
 
-    CheckTrue(reports[0].Kind == ASWLog::ErrorKind::WriteFailed, "A failed console write should be reported as WriteFailed");
+    CheckEquals(ASWLog::ErrorKind::WriteFailed, reports[0].Kind, "A failed console write should be reported as WriteFailed");
     CheckEquals(std::string("Couldn't write to stdout"), reports[0].Message, "The report should name the stream");
 }
 //---------------------------------------------------------------------------
@@ -864,7 +864,7 @@ void TTest_ASWLog_ConsoleLog::Test_SetLevelColor_OverridesDefaultColor()
 
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
-    CheckFalse(defaultInfoColor.empty(), "GetLevelColor should return a non-empty default color for Info");
+    CheckNotEmpty(defaultInfoColor, "GetLevelColor should return a non-empty default color for Info");
     CheckEquals(customColor, updatedColor, "GetLevelColor should reflect the color set via SetLevelColor");
     CheckContains(contents, customColor, "WriteLogEntry should use the custom color for Info");
     CheckNotContains(contents, defaultInfoColor, "The default color should no longer appear for Info once overridden");
diff --git a/tests/tests/Test_ASWLog_CrashHandler.cpp b/tests/tests/Test_ASWLog_CrashHandler.cpp
index ebed2e9..775d850 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.cpp
+++ b/tests/tests/Test_ASWLog_CrashHandler.cpp
@@ -881,7 +881,7 @@ void TTest_ASWLog_CrashHandler::Test_HandleCrash_SyncsTheLineAtSyncToDiskAtLevel
     CheckEquals(0, reportsWithoutSync, "A logger whose SyncToDiskAtLevel is above Critical shouldn't sync the crash line");
     CheckEquals(1, reports.size(), "The crash line should be synced once");
     if (reports.size() == 1)
-        CheckTrue(reports[0] == ASWLog::ErrorKind::SyncFailed, "The report should be SyncFailed");
+        CheckEquals(ASWLog::ErrorKind::SyncFailed, reports[0], "The report should be SyncFailed");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_HandleCrash_ThrowingFormatterGetsTheFixedLayoutLine()
diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index 4bc94cf..3a772b6 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -1153,20 +1153,13 @@ void TTest_ASWLog_FileLog::Test_DeleteOldLogs_MatchesNonASCIIFileNames()
 
     const std::string utf8Pattern = "\xCE\xBB_*example.log"; // U+03BB in UTF-8, then "_*example.log"
     std::size_t deletedCount = 0;
-    bool threw = false;
 
     // Act
-    try
-    {
-        deletedCount = ASWLog::TASWFileLog::DeleteOldLogs(TestTempDir, utf8Pattern, std::chrono::hours(1));
-    }
-    catch (...)
-    {
-        threw = true;
-    }
+    CheckNoThrow([&] {
+            deletedCount = ASWLog::TASWFileLog::DeleteOldLogs(TestTempDir, utf8Pattern, std::chrono::hours(1));
+        }, "DeleteOldLogs should not throw for a file name the ANSI code page can't represent");
 
     // Assert
-    CheckFalse(threw, "DeleteOldLogs should not throw for a file name the ANSI code page can't represent");
     CheckEquals(1, deletedCount, "DeleteOldLogs should match UTF-8 patterns against UTF-8 file names");
     CheckFalse(std::filesystem::exists(oldFile), "The matching old file should be removed");
 }
@@ -1448,7 +1441,7 @@ void TTest_ASWLog_FileLog::Test_GetInstance_ReturnsSameInstance()
     auto& second = ASWLog::TASWFileLog::GetInstance();
 
     // Assert
-    CheckTrue(&first == &second, "GetInstance should return the same logger on every call");
+    CheckSame(&first, &second, "GetInstance should return the same logger on every call");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_InitializeAndLogInfo_WritesText()
@@ -1788,7 +1781,7 @@ void TTest_ASWLog_FileLog::Test_MultiThreadedStress_WritesAllMessagesToDisk()
 
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
-    CheckTrue(!contents.empty(), "Stress log file should contain at least one entry");
+    CheckNotEmpty(contents, "Stress log file should contain at least one entry");
     for (const auto& message : expectedMessages)
     {
         CheckContains(contents, message,
@@ -1855,7 +1848,7 @@ void TTest_ASWLog_FileLog::Test_MultiThreadedStress_WritesAllMessagesToDisk_Open
 
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
-    CheckTrue(!contents.empty(), "Stress log file should contain at least one entry");
+    CheckNotEmpty(contents, "Stress log file should contain at least one entry");
     for (const auto& message : expectedMessages)
     {
         CheckContains(contents, message,
@@ -1920,7 +1913,7 @@ void TTest_ASWLog_FileLog::Test_OnBackupCreated_LeavesARenamedBackupToTheApp()
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
     CheckTrue(rotated, "RotateLogFiles should succeed");
-    CheckFalse(compressedPath.empty(), "OnBackupCreated should be called");
+    CheckNotEmpty(compressedPath, "OnBackupCreated should be called");
     CheckTrue(std::filesystem::exists(compressedPath), "The cleanup should leave a file renamed out of the backup form to the application");
 }
 //---------------------------------------------------------------------------
@@ -2045,22 +2038,15 @@ void TTest_ASWLog_FileLog::Test_OnBackupCreated_ThrowingCallbackStillCleansUp()
     logger.LogInfo("entry");
 
     // Act
-    bool threw = false;
     bool rotated = false;
-    try
-    {
-        rotated = logger.RotateLogFiles("manual");
-    }
-    catch (...)
-    {
-        threw = true;
-    }
+    CheckNoThrow([&] {
+            rotated = logger.RotateLogFiles("manual");
+        }, "An exception from OnBackupCreated should not escape");
     logger.LogInfo("after");
     logger.Close();
 
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
-    CheckFalse(threw, "An exception from OnBackupCreated should not escape");
     CheckTrue(rotated, "RotateLogFiles should succeed");
     CheckFalse(backupPath.empty() || std::filesystem::exists(backupPath), "The cleanup should still run after the callback threw");
     CheckEquals(std::string(": after\n"), ReadFileText(logFile), "Logging should go on");
@@ -2096,13 +2082,13 @@ void TTest_ASWLog_FileLog::Test_OnError_ReportsFailedDelete()
 
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
-    CheckTrue(otherHandle != nullptr, "The test should be able to hold the backup open");
+    CheckNotNull(otherHandle, "The test should be able to hold the backup open");
     CheckTrue(rotated, "The rotation itself should succeed");
     CheckEquals(1, reports.size(), "The backup that couldn't be deleted should be reported once");
     if (reports.empty())
         return;
 
-    CheckTrue(reports[0].Kind == ASWLog::ErrorKind::DeleteFailed, "The failure should be reported as DeleteFailed");
+    CheckEquals(ASWLog::ErrorKind::DeleteFailed, reports[0].Kind, "The failure should be reported as DeleteFailed");
     CheckTrue(reports[0].Path.filename() == heldBackup.filename(), "The report should name the backup");
     CheckTrue(static_cast<bool>(reports[0].Code), "The report should carry the operating system's error");
 #else
@@ -2132,7 +2118,7 @@ void TTest_ASWLog_FileLog::Test_OnError_ReportsFailedOpen()
     if (reports.empty())
         return;
 
-    CheckTrue(reports[0].Kind == ASWLog::ErrorKind::OpenFailed, "The failure should be reported as OpenFailed");
+    CheckEquals(ASWLog::ErrorKind::OpenFailed, reports[0].Kind, "The failure should be reported as OpenFailed");
     CheckTrue(reports[0].Path == config.File.ResolvePath().parent_path(), "The report should name the folder that couldn't be created");
     CheckTrue(static_cast<bool>(reports[0].Code), "The report should carry the operating system's error");
 }
@@ -2175,14 +2161,14 @@ void TTest_ASWLog_FileLog::Test_OnError_ReportsFailedRotationAndReopen()
     if (reports.size() != 3)
         return;
 
-    CheckTrue(reports[0].Kind == ASWLog::ErrorKind::RotationFailed, "The failed rename should be reported as RotationFailed");
+    CheckEquals(ASWLog::ErrorKind::RotationFailed, reports[0].Kind, "The failed rename should be reported as RotationFailed");
     CheckTrue(reports[0].Path == config.File.ResolvePath(), "The rotation report should name the log file");
     CheckTrue(static_cast<bool>(reports[0].Code), "The rotation report should carry the operating system's error");
-    CheckTrue(reports[1].Kind == ASWLog::ErrorKind::OpenFailed, "The failed reopen should be reported as OpenFailed");
+    CheckEquals(ASWLog::ErrorKind::OpenFailed, reports[1].Kind, "The failed reopen should be reported as OpenFailed");
     CheckTrue(reports[1].Path == config.File.ResolvePath(), "The open report should name the log file");
     CheckTrue(static_cast<bool>(reports[1].Code), "The open report should carry the operating system's error");
     CheckEquals(0, reports[1].SuppressedCount, "Nothing was left out before the first open report");
-    CheckTrue(reports[2].Kind == ASWLog::ErrorKind::OpenFailed, "The failed open after the interval should be reported");
+    CheckEquals(ASWLog::ErrorKind::OpenFailed, reports[2].Kind, "The failed open after the interval should be reported");
     CheckEquals(2, reports[2].SuppressedCount, "The report should count the failed opens left out");
 }
 //---------------------------------------------------------------------------
@@ -2219,7 +2205,7 @@ void TTest_ASWLog_FileLog::Test_OnError_ReportsFailedSync()
     CheckEquals(1, reports.size(), "The failed sync should be reported once");
     if (reports.size() == 1)
     {
-        CheckTrue(reports[0].Kind == ASWLog::ErrorKind::SyncFailed, "The report should be SyncFailed");
+        CheckEquals(ASWLog::ErrorKind::SyncFailed, reports[0].Kind, "The report should be SyncFailed");
         CheckTrue(reports[0].Path == config.File.ResolvePath(), "The report should name the log file");
         CheckTrue(static_cast<bool>(reports[0].Code), "The report should carry the operating system's error");
     }
@@ -2313,9 +2299,9 @@ void TTest_ASWLog_FileLog::Test_OnLogEntry_FiresForQualifyingLevelsOnly()
     CheckEquals(2, callbackMessages.size(), "OnLogEntry should only fire for entries at or above OnLogEntryMinimumLevel");
     if (callbackMessages.size() == 2)
     {
-        CheckEquals(static_cast<int32_t>(ASWLog::Level::Error), static_cast<int32_t>(callbackLevels[0]), "First callback should report the Error entry's level");
+        CheckEquals(ASWLog::Level::Error, callbackLevels[0], "First callback should report the Error entry's level");
         CheckContains(callbackMessages[0], "at_threshold", "Callback should receive the same formatted line written to disk");
-        CheckEquals(static_cast<int32_t>(ASWLog::Level::Critical), static_cast<int32_t>(callbackLevels[1]), "Second callback should report the Critical entry's level");
+        CheckEquals(ASWLog::Level::Critical, callbackLevels[1], "Second callback should report the Critical entry's level");
         CheckContains(callbackMessages[1], "above_threshold", "Callback should receive the same formatted line written to disk");
         CheckEquals(std::string("at_threshold"), callbackRecordMessages[0], "Callback should receive the entry's record, with the unformatted message");
         CheckTrue(callbackRecords[0].Timestamp != std::chrono::system_clock::time_point{}, "The callback's record should be stamped with its time");
@@ -2545,7 +2531,7 @@ void TTest_ASWLog_FileLog::Test_Periodic_ErrorHandlerCanCloseAndReopenOnTheThrea
     CheckTrue(wasReported, "The failed flush should be reported");
     if (wasReported)
     {
-        CheckEquals(static_cast<int>(ASWLog::ErrorKind::FlushFailed), static_cast<int>(reportedKind), "The report should be a FlushFailed");
+        CheckEquals(ASWLog::ErrorKind::FlushFailed, reportedKind, "The report should be a FlushFailed");
         CheckTrue(reportThreadId != std::this_thread::get_id(), "The flush thread should report its own failure");
         CheckTrue(closedInHandler, "Close should succeed from OnError on the flush thread");
         CheckTrue(reopenedInHandler, "Open should succeed from OnError on the flush thread");
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index f8b4262..49219ab 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -285,20 +285,8 @@ void TTest_ASWLog_Formatter::Test_FormatLine_MemoryFields()
     const auto line = ASWLog::TASWTextFormatter::FormatLine(MakeRecord("memory"), config);
 
     // Assert
-    const auto peakPos = line.find("][PWS:");
-    CheckStartsWith(line, "[WS:", "The working set should come first: " + line);
-    CheckTrue(peakPos != std::string::npos, "The peak working set should follow: " + line);
-    CheckEndsWith(line, "]: memory", "The message should follow the fields: " + line);
-
-    if (peakPos != std::string::npos)
-    {
-        const auto isNumber = [](const std::string& text) {
-                return !text.empty() && text.find_first_not_of("0123456789") == std::string::npos;
-            };
-        const auto peakEnd = line.find(']', peakPos + 1);
-        CheckTrue(isNumber(line.substr(4, peakPos - 4)), "The working set should be a decimal number: " + line);
-        CheckTrue(isNumber(line.substr(peakPos + 6, peakEnd - peakPos - 6)), "The peak working set should be a decimal number: " + line);
-    }
+    CheckMatches(line, R"(\[WS:[0-9]+\]\[PWS:[0-9]+\]: memory)",
+        "The working set, then the peak working set, each a decimal number, should come before the message");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_FormatLine_NoFields()
@@ -357,7 +345,7 @@ void TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread()
     {
         const auto& record = records[0];
         CheckTrue(record.Timestamp == FixedTime, "The record's time should come from the logger's NowUTC()");
-        CheckTrue(record.LogLevel == ASWLog::Level::Debug, "The record should have the entry's level");
+        CheckEquals(ASWLog::Level::Debug, record.LogLevel, "The record should have the entry's level");
         CheckEquals(std::string("from worker"), record.Message, "The record should have the message");
         CheckEquals(loggedLine, record.Line, "The record should have the caller's source location");
         CheckEquals(ASWLog::GetCurrentOSProcessId(), record.ProcessId, "The record should have the process id");
diff --git a/tests/tests/Test_ASWLog_MultiLog.cpp b/tests/tests/Test_ASWLog_MultiLog.cpp
index a47d627..1aa70c0 100644
--- a/tests/tests/Test_ASWLog_MultiLog.cpp
+++ b/tests/tests/Test_ASWLog_MultiLog.cpp
@@ -440,7 +440,7 @@ void TTest_ASWLog_MultiLog::Test_Close_AllowsInitializeAgain()
     // Assert
     CheckTrue(firstInitialize, "The first Initialize should succeed");
     CheckTrue(secondInitialize, "Initialize after Close should succeed");
-    CheckTrue(levelAfterSecondInitialize == ASWLog::Level::Error, "Initialize after Close should seed the level from the new config");
+    CheckEquals(ASWLog::Level::Error, levelAfterSecondInitialize, "Initialize after Close should seed the level from the new config");
     CheckContains(ReadFileText(fileA), "after_reinitialize", "Initialize after Close should initialize the sinks again");
 }
 //---------------------------------------------------------------------------
@@ -736,7 +736,7 @@ void TTest_ASWLog_MultiLog::Test_Log_AtLevelOffIsNotFannedOut()
     multiLog.LogForceRaw(ASWLog::Level::Info, "forced_raw");
 
     // Assert
-    CheckTrue(callsAtOffLevel.empty(), "A message at Off should not reach any sink, even when forced");
+    CheckEmpty(callsAtOffLevel, "A message at Off should not reach any sink, even when forced");
     CheckTrue(sink.Calls == std::vector<std::string>{ "LogForce:forced", "LogForceRaw:forced_raw" },
         "With the composite's minimum level at Off, only forced entries should be fanned out");
 }
@@ -787,25 +787,17 @@ void TTest_ASWLog_MultiLog::Test_Log_ThrowingSinkDoesNotStopOtherSinks()
     multiLog.AddLogger(throwingSink);
     multiLog.AddLogger(fileSink);
 
-    bool threw = false;
-
     // Act
-    try
-    {
-        multiLog.LogInfo("log_message");
-        multiLog.LogRaw(ASWLog::Level::Info, "raw_message\n");
-        multiLog.LogForce(ASWLog::Level::Info, "force_message");
-        multiLog.LogForceRaw(ASWLog::Level::Info, "force_raw_message\n");
-    }
-    catch (...)
-    {
-        threw = true;
-    }
+    CheckNoThrow([&] {
+            multiLog.LogInfo("log_message");
+            multiLog.LogRaw(ASWLog::Level::Info, "raw_message\n");
+            multiLog.LogForce(ASWLog::Level::Info, "force_message");
+            multiLog.LogForceRaw(ASWLog::Level::Info, "force_raw_message\n");
+        }, "An exception from one sink should not escape the composite");
     fileSink.Close();
 
     // Assert
     const auto contents = ReadFileText(file);
-    CheckFalse(threw, "An exception from one sink should not escape the composite");
     CheckContains(contents, "log_message", "Log should still reach the other sinks");
     CheckContains(contents, "raw_message", "LogRaw should still reach the other sinks");
     CheckContains(contents, "force_message", "LogForce should still reach the other sinks");
@@ -881,7 +873,7 @@ void TTest_ASWLog_MultiLog::Test_Reconfigure_PassesConfigToEverySink()
     // Assert
     const std::vector<std::string> twoReconfigures{ "Reconfigure", "Reconfigure" };
     CheckFalse(reconfiguredBeforeInitialize, "Reconfigure() should fail before Initialize()");
-    CheckTrue(callsBeforeInitialize.empty(), "Reconfigure() before Initialize() should not reach the sinks");
+    CheckEmpty(callsBeforeInitialize, "Reconfigure() before Initialize() should not reach the sinks");
     CheckFalse(reconfiguredWithFailure, "Reconfigure() should return false if any sink's Reconfigure() fails");
     CheckTrue(reconfigured, "Reconfigure() should return true once every sink's Reconfigure() succeeds");
     CheckTrue(failingSink.Calls == twoReconfigures, "Each Reconfigure() should reach the failing sink");
@@ -966,7 +958,7 @@ void TTest_ASWLog_MultiLog::Test_SetEnabled_FalseStopsFanOut()
     multiLog.LogInfo("enabled_again");
 
     // Assert
-    CheckTrue(callsWhileDisabled.empty(), "A disabled composite should fan out nothing, not even forced entries");
+    CheckEmpty(callsWhileDisabled, "A disabled composite should fan out nothing, not even forced entries");
     CheckTrue(sink.IsEnabled(), "Disabling the composite should not change its sinks");
     CheckTrue(sink.Calls == std::vector<std::string>{ "Log:enabled_again" }, "Fan-out should resume once enabled again");
 }
diff --git a/tests/tests/Test_ASWLog_TextLogBase.cpp b/tests/tests/Test_ASWLog_TextLogBase.cpp
index e7c0daa..7053fa3 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.cpp
+++ b/tests/tests/Test_ASWLog_TextLogBase.cpp
@@ -617,7 +617,7 @@ void TTest_ASWLog_TextLogBase::Test_Async_DropNewestReportsAndMarksDroppedEntrie
     CheckEquals(1, errors.size(), "The drop should be reported once");
     if (errors.size() == 1)
     {
-        CheckEquals(static_cast<int>(ASWLog::ErrorKind::EntriesDropped), static_cast<int>(errors[0].Kind), "The report should be EntriesDropped");
+        CheckEquals(ASWLog::ErrorKind::EntriesDropped, errors[0].Kind, "The report should be EntriesDropped");
         CheckContains(errors[0].Message, "Dropped 3 entries", "The report should say how many were dropped");
     }
 }
@@ -1056,22 +1056,15 @@ void TTest_ASWLog_TextLogBase::Test_Initialize_ThrowingFormatterStillInitializes
 
     TMemoryTextLog log(output);
     bool initialized = false;
-    bool threw = false;
 
     // Act
-    try
-    {
-        initialized = log.Initialize(config);
-        log.LogInfo("formatted"); // Dropped, since its line can't be formatted
-        log.LogRaw(ASWLog::Level::Info, "raw"); // Written: raw entries don't use the formatter
-    }
-    catch (...)
-    {
-        threw = true;
-    }
+    CheckNoThrow([&] {
+            initialized = log.Initialize(config);
+            log.LogInfo("formatted"); // Dropped, since its line can't be formatted
+            log.LogRaw(ASWLog::Level::Info, "raw"); // Written: raw entries don't use the formatter
+        }, "A throwing formatter should not throw out of Initialize() or the Log* methods");
 
     // Assert
-    CheckFalse(threw, "A throwing formatter should not throw out of Initialize() or the Log* methods");
     CheckTrue(initialized, "Initialize() should succeed: the startup lines are best effort once the output is open");
     CheckTrue(log.IsOpen(), "The logger should be open");
     CheckTrue(output.Lines == std::vector<std::string>{ "raw" }, "Only the raw entry should be written");
@@ -1167,7 +1160,7 @@ void TTest_ASWLog_TextLogBase::Test_Log_DroppedWhenNotReadyOrNotPrepared()
     log.LogInfo("after_close");
 
     // Assert
-    CheckTrue(output.Lines.empty(), "No entry should be written");
+    CheckEmpty(output.Lines, "No entry should be written");
     CheckEquals(0, callbackCount, "OnLogEntry should not be called for a dropped entry");
     CheckEquals(afterEntryCountAtStart + 1, output.AfterEntryCount,
         "AfterEntryUnlocked should be skipped when EnsureReadyUnlocked fails, but called when only PrepareWriteUnlocked drops the line");
@@ -1229,7 +1222,7 @@ void TTest_ASWLog_TextLogBase::Test_Log_MinimumLevelOffAllowsOnlyForcedEntries()
 
     // Assert
     CheckTrue(initialized, "Initialize should succeed");
-    CheckTrue(log.GetMinimumLevel() == ASWLog::Level::Off, "InitialMinimumLevel should seed the minimum level");
+    CheckEquals(ASWLog::Level::Off, log.GetMinimumLevel(), "InitialMinimumLevel should seed the minimum level");
     CheckEquals(0, linesAfterInitialize,
         "With the minimum level at Off, Initialize should write no startup lines");
     CheckTrue(output.Lines == std::vector<std::string>{ "[INFO]: forced\n", "forced_raw\n" },
@@ -1251,22 +1244,15 @@ void TTest_ASWLog_TextLogBase::Test_Log_ThrowingWriteDoesNotEscape()
     CheckTrue(log.Initialize(config), "Initialize should succeed");
 
     // Act
-    bool threw = false;
     log.ThrowsOnWrite = true;
-    try
-    {
-        log.LogInfo("write_throws");
-        log.LogForceRaw(ASWLog::Level::Error, "write_throws_raw");
-    }
-    catch (...)
-    {
-        threw = true;
-    }
+    CheckNoThrow([&] {
+            log.LogInfo("write_throws");
+            log.LogForceRaw(ASWLog::Level::Error, "write_throws_raw");
+        }, "An exception from WriteLineUnlocked should not reach the caller");
     log.ThrowsOnWrite = false;
     log.LogInfo("after_throw"); // Would deadlock if the throw had left the mutex locked
 
     // Assert
-    CheckFalse(threw, "An exception from WriteLineUnlocked should not reach the caller");
     CheckTrue(output.Lines == std::vector<std::string>{ "[INFO]: after_throw\n" }, "Logging should work after a failed write");
     CheckTrue(reportedMessages == std::vector<std::string>{ "Dropped an entry: write failed", "Dropped an entry: write failed" },
         "Each dropped entry should be reported");
@@ -1349,7 +1335,7 @@ void TTest_ASWLog_TextLogBase::Test_Reconfigure_AppliesNewConfigButKeepsLevel()
     CheckTrue(reconfigured, "Reconfigure() should succeed once initialized");
     CheckTrue(output.Lines == std::vector<std::string>{ "[INFO]: first\n", "[DEBUG]: before\n", ": after\n" },
         "Entries after Reconfigure() should use the new line layout, and Reconfigure() should write no startup lines");
-    CheckEquals(static_cast<int>(ASWLog::Level::Debug), static_cast<int>(log.GetMinimumLevel()),
+    CheckEquals(ASWLog::Level::Debug, log.GetMinimumLevel(),
         "Reconfigure() should keep the minimum level set with SetMinimumLevel(), not apply InitialMinimumLevel");
     CheckTrue(log.ReconfiguredFromBanners == std::vector<std::string>{ "first", "second" },
         "ReconfigureUnlocked() should get the config it replaced (and not be called before Initialize())");
diff --git a/tests/tests/Test_ASWLog_Types.cpp b/tests/tests/Test_ASWLog_Types.cpp
index ab08e2c..6947ca4 100644
--- a/tests/tests/Test_ASWLog_Types.cpp
+++ b/tests/tests/Test_ASWLog_Types.cpp
@@ -96,9 +96,9 @@ void TTest_ASWLog_Types::Test_AsyncOverflowPolicy_FromString()
     CheckTrue(dropNewest.has_value(), "DROP_NEWEST should parse");
     CheckTrue(dropNewestAlias_mixedCase.has_value(), "DropNewest should parse");
     CheckFalse(unknown.has_value(), "An unknown string should not parse");
-    CheckEquals(static_cast<int32_t>(ASWLog::AsyncOverflowPolicy::Block), static_cast<int32_t>(*block), "BLOCK should map to Block");
-    CheckEquals(static_cast<int32_t>(ASWLog::AsyncOverflowPolicy::DropNewest), static_cast<int32_t>(*dropNewest), "DROP_NEWEST should map to DropNewest");
-    CheckEquals(static_cast<int32_t>(ASWLog::AsyncOverflowPolicy::DropNewest), static_cast<int32_t>(*dropNewestAlias_mixedCase), "DropNewest should map to DropNewest");
+    CheckEquals(ASWLog::AsyncOverflowPolicy::Block, *block, "BLOCK should map to Block");
+    CheckEquals(ASWLog::AsyncOverflowPolicy::DropNewest, *dropNewest, "DROP_NEWEST should map to DropNewest");
+    CheckEquals(ASWLog::AsyncOverflowPolicy::DropNewest, *dropNewestAlias_mixedCase, "DropNewest should map to DropNewest");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_AsyncOverflowPolicy_ToString()
@@ -123,10 +123,10 @@ void TTest_ASWLog_Types::Test_ColorMode_FromString()
     CheckTrue(never.has_value(), "NEVER should parse");
     CheckTrue(never_mixedCase.has_value(), "Never mixed case should parse");
     CheckFalse(unknown.has_value(), "An unknown string should not parse");
-    CheckEquals(static_cast<int32_t>(ASWLog::ColorMode::Auto), static_cast<int32_t>(*autoMode), "AUTO should map to Auto");
-    CheckEquals(static_cast<int32_t>(ASWLog::ColorMode::Always), static_cast<int32_t>(*always), "ALWAYS should map to Always");
-    CheckEquals(static_cast<int32_t>(ASWLog::ColorMode::Never), static_cast<int32_t>(*never), "NEVER should map to Never");
-    CheckEquals(static_cast<int32_t>(ASWLog::ColorMode::Never), static_cast<int32_t>(*never_mixedCase), "Never should map to Never");
+    CheckEquals(ASWLog::ColorMode::Auto, *autoMode, "AUTO should map to Auto");
+    CheckEquals(ASWLog::ColorMode::Always, *always, "ALWAYS should map to Always");
+    CheckEquals(ASWLog::ColorMode::Never, *never, "NEVER should map to Never");
+    CheckEquals(ASWLog::ColorMode::Never, *never_mixedCase, "Never should map to Never");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_ColorMode_ToString()
@@ -174,12 +174,12 @@ void TTest_ASWLog_Types::Test_FlushMode_FromString()
     CheckTrue(onNewLineAlias_mixed.has_value(), "OnNewLine should parse");
     CheckTrue(manual.has_value(), "MANUAL should parse");
     CheckTrue(periodic.has_value(), "PERIODIC should parse");
-    CheckEquals(static_cast<int32_t>(ASWLog::FlushMode::EveryWrite), static_cast<int32_t>(*everyWrite), "EVERY_WRITE should map to EveryWrite");
-    CheckEquals(static_cast<int32_t>(ASWLog::FlushMode::EveryWrite), static_cast<int32_t>(*everyWriteAlias), "EVERYWRITE should map to EveryWrite");
-    CheckEquals(static_cast<int32_t>(ASWLog::FlushMode::OnNewLine), static_cast<int32_t>(*onNewLine), "ON_NEW_LINE should map to OnNewLine");
-    CheckEquals(static_cast<int32_t>(ASWLog::FlushMode::OnNewLine), static_cast<int32_t>(*onNewLineAlias_mixed), "OnNewLine should map to OnNewLine");
-    CheckEquals(static_cast<int32_t>(ASWLog::FlushMode::Manual), static_cast<int32_t>(*manual), "MANUAL should map to Manual");
-    CheckEquals(static_cast<int32_t>(ASWLog::FlushMode::Periodic), static_cast<int32_t>(*periodic), "PERIODIC should map to Periodic");
+    CheckEquals(ASWLog::FlushMode::EveryWrite, *everyWrite, "EVERY_WRITE should map to EveryWrite");
+    CheckEquals(ASWLog::FlushMode::EveryWrite, *everyWriteAlias, "EVERYWRITE should map to EveryWrite");
+    CheckEquals(ASWLog::FlushMode::OnNewLine, *onNewLine, "ON_NEW_LINE should map to OnNewLine");
+    CheckEquals(ASWLog::FlushMode::OnNewLine, *onNewLineAlias_mixed, "OnNewLine should map to OnNewLine");
+    CheckEquals(ASWLog::FlushMode::Manual, *manual, "MANUAL should map to Manual");
+    CheckEquals(ASWLog::FlushMode::Periodic, *periodic, "PERIODIC should map to Periodic");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_FlushMode_ToString()
@@ -222,15 +222,15 @@ void TTest_ASWLog_Types::Test_Level_FromString()
     CheckTrue(error.has_value(), "ERROR should parse");
     CheckTrue(critical.has_value(), "CRITICAL should parse");
     CheckTrue(criticalAlias.has_value(), "FATAL should parse");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Trace), static_cast<int32_t>(*trace), "TRACE should map to Trace");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Debug), static_cast<int32_t>(*debug), "DEBUG should map to Debug");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Info), static_cast<int32_t>(*info), "INFO should map to Info");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Info), static_cast<int32_t>(*info_mixedCase), "Info should map to Info");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Warn), static_cast<int32_t>(*warn), "WARN should map to Warn");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Warn), static_cast<int32_t>(*warnAlias), "WARNING should map to Warn");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Error), static_cast<int32_t>(*error), "ERROR should map to Error");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Critical), static_cast<int32_t>(*critical), "CRITICAL should map to Critical");
-    CheckEquals(static_cast<int32_t>(ASWLog::Level::Critical), static_cast<int32_t>(*criticalAlias), "FATAL should map to Critical");
+    CheckEquals(ASWLog::Level::Trace, *trace, "TRACE should map to Trace");
+    CheckEquals(ASWLog::Level::Debug, *debug, "DEBUG should map to Debug");
+    CheckEquals(ASWLog::Level::Info, *info, "INFO should map to Info");
+    CheckEquals(ASWLog::Level::Info, *info_mixedCase, "Info should map to Info");
+    CheckEquals(ASWLog::Level::Warn, *warn, "WARN should map to Warn");
+    CheckEquals(ASWLog::Level::Warn, *warnAlias, "WARNING should map to Warn");
+    CheckEquals(ASWLog::Level::Error, *error, "ERROR should map to Error");
+    CheckEquals(ASWLog::Level::Critical, *critical, "CRITICAL should map to Critical");
+    CheckEquals(ASWLog::Level::Critical, *criticalAlias, "FATAL should map to Critical");
     CheckTrue(off.has_value() && *off == ASWLog::Level::Off, "OFF should map to Off");
     CheckTrue(offAlias.has_value() && *offAlias == ASWLog::Level::Off, "none (NONE alias, any case) should map to Off");
 }
@@ -273,11 +273,11 @@ void TTest_ASWLog_Types::Test_LineEnding_FromString()
     CheckTrue(lf_lower.has_value(), "lf should parse");
     CheckTrue(crlf.has_value(), "CRLF should parse");
     CheckTrue(crlfAlias.has_value(), "WINDOWS should parse");
-    CheckEquals(static_cast<int32_t>(ASWLog::LineEnding::LF), static_cast<int32_t>(*lf), "LF should map to LF");
-    CheckEquals(static_cast<int32_t>(ASWLog::LineEnding::LF), static_cast<int32_t>(*lfAlias), "LINUX should map to LF");
-    CheckEquals(static_cast<int32_t>(ASWLog::LineEnding::LF), static_cast<int32_t>(*lf_lower), "lf should map to LF");
-    CheckEquals(static_cast<int32_t>(ASWLog::LineEnding::CRLF), static_cast<int32_t>(*crlf), "CRLF should map to CRLF");
-    CheckEquals(static_cast<int32_t>(ASWLog::LineEnding::CRLF), static_cast<int32_t>(*crlfAlias), "WINDOWS should map to CRLF");
+    CheckEquals(ASWLog::LineEnding::LF, *lf, "LF should map to LF");
+    CheckEquals(ASWLog::LineEnding::LF, *lfAlias, "LINUX should map to LF");
+    CheckEquals(ASWLog::LineEnding::LF, *lf_lower, "lf should map to LF");
+    CheckEquals(ASWLog::LineEnding::CRLF, *crlf, "CRLF should map to CRLF");
+    CheckEquals(ASWLog::LineEnding::CRLF, *crlfAlias, "WINDOWS should map to CRLF");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_LineEnding_ToString()
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index 23371ae..7a0fbeb 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -124,7 +124,7 @@ void TTest_ASWLog_Utils::Test_GenerateLogFileName_ContainsExpectedFields()
     const std::string logName = ASWLog::GenerateLogFileName("", "ExampleLog.txt");
 
     // Act & Assert
-    AssertTrue(!logName.empty(), "Generated log file name should not be empty");
+    AssertNotEmpty(logName, "Generated log file name should not be empty");
 
     CheckContains(logName, "_PID", "Generated file name should include process id");
     CheckContains(logName, "_TID", "Generated file name should include thread id");
@@ -153,7 +153,7 @@ void TTest_ASWLog_Utils::Test_GenerateLogFileName_PrefixAndPostfixAreOptional()
     CheckNotStartsWith(postfixOnly, "_", "An empty prefix should not leave a leading separator");
     CheckContains(postfixOnly, "ExampleLog.txt", "The postfix should still be included when the prefix is empty");
 
-    CheckFalse(neither.empty(), "The name should still contain the timestamp/PID/TID segments when both are empty");
+    CheckNotEmpty(neither, "The name should still contain the timestamp/PID/TID segments when both are empty");
     CheckNotStartsWith(neither, "_", "An empty prefix should not leave a leading separator when the postfix is also empty");
     CheckNotEndsWith(neither, "_", "An empty postfix should not leave a trailing separator when the prefix is also empty");
 }
@@ -193,7 +193,7 @@ void TTest_ASWLog_Utils::Test_GetCurrentOSThreadId_IdentifiesCallingThread()
 #if defined(_WIN32)
     // The id should name a live thread of this process
     const HANDLE thread = OpenThread(THREAD_QUERY_LIMITED_INFORMATION, FALSE, mainThreadId);
-    CheckTrue(thread != nullptr, "The id should open a thread");
+    CheckNotNull(thread, "The id should open a thread");
     if (thread != nullptr)
     {
         CheckEquals(static_cast<std::uint32_t>(GetCurrentProcessId()), static_cast<std::uint32_t>(GetProcessIdOfThread(thread)), "The thread should belong to this process");
@@ -221,10 +221,10 @@ void TTest_ASWLog_Utils::Test_GetOSInfoString_ContainsEdition()
         osInfo.find("Server") != std::string::npos ||
         osInfo.find("Ultimate") != std::string::npos;
 
-    CheckTrue(!osInfo.empty(), "OS info string should not be empty");
+    CheckNotEmpty(osInfo, "OS info string should not be empty");
     CheckTrue(hasEdition, "Windows OS info should include the edition name (Home, Pro, Enterprise, etc.)");
 #else
-    CheckTrue(!osInfo.empty(), "OS info string should not be empty");
+    CheckNotEmpty(osInfo, "OS info string should not be empty");
 #endif
 }
 //---------------------------------------------------------------------------
@@ -319,7 +319,7 @@ void TTest_ASWLog_Utils::Test_IsRootFolder_ResolvesRelativePaths()
     const auto relativeRoot = std::filesystem::relative(currentPath.root_path(), currentPath);
 
     // Act & Assert
-    CheckFalse(relativeRoot.empty(), "The relative path to the root should be found");
+    CheckNotEmpty(relativeRoot, "The relative path to the root should be found");
     CheckTrue(ASWLog::IsRootFolder(relativeRoot), "A relative path that leads to a root should be a root folder");
     if (currentPath != currentPath.root_path())
         CheckFalse(ASWLog::IsRootFolder("."), "\".\" should not be a root folder when the current folder isn't one");
diff --git a/tests/tests/Test_ASWLog_Version.cpp b/tests/tests/Test_ASWLog_Version.cpp
index bb741df..35bb4e4 100644
--- a/tests/tests/Test_ASWLog_Version.cpp
+++ b/tests/tests/Test_ASWLog_Version.cpp
@@ -24,7 +24,6 @@ limitations under the License.
 // Module header
 #include "Test_ASWLog_Version.h"
 //---------------------------------------------------------------------------
-#include <cstddef>
 #include <format>
 #include <string>
 #include <string_view>
@@ -48,31 +47,6 @@ static_assert(std::string_view(ASWLog::Version) == ASWLOG_VERSION_STRING);
 namespace ASWUnitTests
 {
 
-namespace
-{
-
-// A SemVer pre-release identifier: not empty, only [0-9A-Za-z-], and no leading zero if it is all digits
-bool IsValidPreReleaseIdentifier(std::string_view identifier)
-{
-    if (identifier.empty())
-        return false;
-
-    bool isNumeric = true;
-    for (const char character : identifier)
-    {
-        const bool isDigit = character >= '0' && character <= '9';
-        const bool isLetter = (character >= 'A' && character <= 'Z') || (character >= 'a' && character <= 'z');
-        if (!isDigit && !isLetter && character != '-')
-            return false;
-
-        isNumeric = isNumeric && isDigit;
-    }
-
-    return !isNumeric || identifier.size() == 1 || identifier.front() != '0';
-}
-
-} // namespace
-
 //---------------------------------------------------------------------------
 TTest_ASWLog_Version::TTest_ASWLog_Version()
     : inherited("ASWLog_Version_Tests")
@@ -122,22 +96,16 @@ void TTest_ASWLog_Version::Test_GetVersionStr_ReturnsVersion()
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Version::Test_PreRelease_IsValidSemVer()
 {
-    // Arrange: a pre-release is empty (a release) or dot-separated identifiers, e.g. "dev.1"
-    const std::string_view preRelease = ASWLog::VersionPreRelease;
+    // Arrange: a pre-release is empty (a release) or dot-separated identifiers, e.g. "dev.1". An identifier is
+    // [0-9A-Za-z-], not empty, and has no leading zero if it is all digits (SemVer 2.0.0).
+    const std::string identifier = "(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)";
 
     // Act
-    bool isValid = true;
-    for (std::size_t start = 0; !preRelease.empty() && start <= preRelease.size();)
-    {
-        const auto dot = preRelease.find('.', start);
-        const auto end = dot == std::string_view::npos ? preRelease.size() : dot;
-        isValid = isValid && IsValidPreReleaseIdentifier(preRelease.substr(start, end - start));
-        start = end + 1;
-    }
+    const std::string preRelease = ASWLog::VersionPreRelease;
 
     // Assert
-    CheckTrue(isValid,
-        "ASWLOG_VERSION_PRERELEASE should be empty or SemVer pre-release identifiers: " + std::string(preRelease));
+    CheckMatches(preRelease, "(?:" + identifier + "(?:\\." + identifier + ")*)?",
+        "ASWLOG_VERSION_PRERELEASE should be empty or SemVer pre-release identifiers");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Version::Test_VersionString_MatchesParts()
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index e04a7c3..a1fa5a9 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -357,6 +357,14 @@
             <DependentOn>..\..\..\..\third_party\asw-unit-tests\vcl\gui\src\ASWUnitTests_GUI_Selection.h</DependentOn>
             <BuildOrder>41</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\third_party\asw-unit-tests\vcl\gui\src\ASWUnitTests_GUI_Shuffle.cpp">
+            <DependentOn>..\..\..\..\third_party\asw-unit-tests\vcl\gui\src\ASWUnitTests_GUI_Shuffle.h</DependentOn>
+            <BuildOrder>45</BuildOrder>
+        </CppCompile>
+        <CppCompile Include="..\..\..\..\third_party\asw-unit-tests\vcl\gui\src\ASWUnitTests_GUI_ShuffleSeedDialog.cpp">
+            <DependentOn>..\..\..\..\third_party\asw-unit-tests\vcl\gui\src\ASWUnitTests_GUI_ShuffleSeedDialog.h</DependentOn>
+            <BuildOrder>46</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\third_party\asw-unit-tests\vcl\gui\src\ASWUnitTests_GUI_Strings.cpp">
             <DependentOn>..\..\..\..\third_party\asw-unit-tests\vcl\gui\src\ASWUnitTests_GUI_Strings.h</DependentOn>
             <BuildOrder>24</BuildOrder>
diff --git a/third_party/asw-unit-tests b/third_party/asw-unit-tests
index 0c90606..cb3b248 160000
--- a/third_party/asw-unit-tests
+++ b/third_party/asw-unit-tests
@@ -1 +1 @@
-Subproject commit 0c90606665363f127a73f59a802bfab8c69e5ae4
+Subproject commit cb3b248f3bdcceb4a1962311accfdc41750b5414

From 3bce1514bc527e4527301f9bed8ad0c298150177 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Thu, 8 Oct 2026 06:52:19 -0700
Subject: [PATCH 05/38] Add logger categories with per-category levels

---
 ASWLog/ASWLog_Base.cpp                        |  17 +-
 ASWLog/ASWLog_Base.h                          |  53 +-
 ASWLog/ASWLog_CategoryLog.cpp                 | 225 ++++++
 ASWLog/ASWLog_CategoryLog.h                   | 141 ++++
 ASWLog/ASWLog_Config.h                        |   1 +
 ASWLog/ASWLog_CrashHandler.cpp                |   7 +
 ASWLog/ASWLog_CrashHandler.h                  |   2 +-
 ASWLog/ASWLog_Formatter.cpp                   |   7 +
 ASWLog/ASWLog_Formatter.h                     |   7 +-
 ASWLog/ASWLog_Interface.h                     |  17 +-
 ASWLog/ASWLog_MultiLog.cpp                    |  28 +-
 ASWLog/ASWLog_MultiLog.h                      |  10 +-
 ASWLog/ASWLog_TextLogBase.cpp                 |   5 +-
 ASWLog/ASWLog_TextLogBase.h                   |   3 +-
 ASWLog/ASWLog_Types.h                         |  18 +-
 CHANGELOG.md                                  |  25 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 README.md                                     |   3 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 example/src/main.cpp                          |  11 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_Base.cpp              |  46 ++
 tests/tests/Test_ASWLog_Base.h                |   1 +
 tests/tests/Test_ASWLog_CategoryLog.cpp       | 690 ++++++++++++++++++
 tests/tests/Test_ASWLog_CategoryLog.h         |  69 ++
 tests/tests/Test_ASWLog_Config.cpp            |   1 +
 tests/tests/Test_ASWLog_CrashHandler.cpp      |  22 +
 tests/tests/Test_ASWLog_CrashHandler.h        |   1 +
 tests/tests/Test_ASWLog_Formatter.cpp         |  27 +-
 tests/tests/Test_ASWLog_Formatter.h           |   1 +
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 33 files changed, 1422 insertions(+), 43 deletions(-)
 create mode 100644 ASWLog/ASWLog_CategoryLog.cpp
 create mode 100644 ASWLog/ASWLog_CategoryLog.h
 create mode 100644 tests/tests/Test_ASWLog_CategoryLog.cpp
 create mode 100644 tests/tests/Test_ASWLog_CategoryLog.h

diff --git a/ASWLog/ASWLog_Base.cpp b/ASWLog/ASWLog_Base.cpp
index 5932ceb..35a4f31 100644
--- a/ASWLog/ASWLog_Base.cpp
+++ b/ASWLog/ASWLog_Base.cpp
@@ -173,18 +173,23 @@ void TASWLogBase::KeepInBacktrace(const TASWLogRecord& record)
 
     if (m_Backtrace.size() < m_BacktraceCapacity)
     {
-        // The message is copied first, so a failed copy leaves no empty entry behind
-        TBacktraceEntry entry{ record, std::string(record.Message) };
+        // The texts are copied first, so a failed copy leaves no empty entry behind
+        TBacktraceEntry entry{ record, std::string(record.Message), std::string(record.Category) };
         entry.Record.Message = {};
+        entry.Record.Category = {};
         m_Backtrace.push_back(std::move(entry));
     }
     else
     {
-        // Replaces the oldest, reusing its message's memory
+        // Replaces the oldest, reusing its message's memory. The category is copied first and swapped in last, so a
+        // failed copy leaves the oldest entry as it was.
         auto& entry = m_Backtrace[m_BacktraceOldest];
+        std::string category(record.Category);
         entry.Message.assign(record.Message);
+        entry.Category.swap(category);
         entry.Record = record;
         entry.Record.Message = {};
+        entry.Record.Category = {};
         m_BacktraceOldest = (m_BacktraceOldest + 1) % m_BacktraceCapacity;
     }
 
@@ -333,8 +338,7 @@ void TASWLogBase::Write(const TASWLogRecord& record) noexcept
 {
     // Off isn't a severity and a disabled logger writes nothing, even when forced; a forced entry ignores only the
     // minimum level. Checked before stamping, so a filtered entry costs no clock or thread id read.
-    const bool isAccepted = record.Forced ? record.LogLevel != Level::Off && IsEnabled() : PassesLevelGate(record.LogLevel);
-    if (!isAccepted)
+    if (!PassesLevelGate(record))
         return;
 
     // Stamped now, on the calling thread and before any lock, so the time is the moment of the call
@@ -347,7 +351,7 @@ void TASWLogBase::Write(const TASWLogRecord& record) noexcept
     {
         // Let in only for the backtrace. Read again: if the minimum level changed since the gate, the entry is kept or
         // written as if it had been logged just before or after the change.
-        if (!record.Forced && record.LogLevel < GetMinimumLevel())
+        if (!record.Forced && record.LogLevel < GetMinimumLevelFor(record))
         {
             KeepInBacktrace(stampedRecord);
             return;
@@ -396,6 +400,7 @@ void TASWLogBase::WriteBacktrace()
     {
         auto record = entry.Record;
         record.Message = entry.Message;
+        record.Category = entry.Category;
         record.Forced = true;
         WriteRecord(record);
     }
diff --git a/ASWLog/ASWLog_Base.h b/ASWLog/ASWLog_Base.h
index 5035cd4..56ad7c9 100644
--- a/ASWLog/ASWLog_Base.h
+++ b/ASWLog/ASWLog_Base.h
@@ -112,12 +112,13 @@ class TASWLogBase : public IASWLog
     std::atomic<std::uint32_t> m_Levels{ PackLevels(Level::Info, Level::Off) };
     std::atomic<bool> m_IsEnabled{ true };
 
-    // An entry the backtrace keeps (see TASWBacktraceConfig): the record, with its message copied (the record's
-    // Message is empty)
+    // An entry the backtrace keeps (see TASWBacktraceConfig): the record, with its message and category copied (the
+    // record's Message and Category are empty)
     struct TBacktraceEntry
     {
         TASWLogRecord Record;
         std::string Message;
+        std::string Category;
     };
 
     // The backtrace, guarded by m_BacktraceMutex: at most m_BacktraceCapacity entries, the oldest at m_BacktraceOldest
@@ -176,6 +177,13 @@ class TASWLogBase : public IASWLog
     // Pure virtual helper so the base class knows what implementation name to print
     virtual std::string_view GetLoggerClassName() const noexcept = 0;
 
+    // The minimum level 'record' needs: its category's level if set (see TASWLogRecord::CategoryLevel), else this
+    // logger's
+    Level GetMinimumLevelFor(const TASWLogRecord& record) const noexcept
+    {
+        return record.CategoryLevel ? *record.CategoryLevel : GetMinimumLevel();
+    }
+
     // Whether this logger keeps a backtrace when its config asks for one (see TASWBacktraceConfig), read by SetConfig().
     // True by default; a logger that passes its entries on to other loggers, which keep their own (a multi-log),
     // returns false, and its gate is then its minimum level alone.
@@ -194,6 +202,23 @@ class TASWLogBase : public IASWLog
             level >= GateLevelOf(m_Levels.load(std::memory_order_relaxed));
     }
 
+    // This logger's check for 'record', as Write() makes it (see ShouldLog(const TASWLogRecord&)): a forced entry
+    // needs only to be enabled and not Off; a category's level, if set, takes the minimum level's place, and the
+    // backtrace's level still lets in what it keeps.
+    bool PassesLevelGate(const TASWLogRecord& record) const noexcept
+    {
+        if (record.Forced)
+            return record.LogLevel != Level::Off && IsEnabled();
+
+        if (!record.CategoryLevel)
+            return PassesLevelGate(record.LogLevel);
+
+        const Level backtraceLevel = BacktraceLevelOf(m_Levels.load(std::memory_order_relaxed));
+
+        return m_IsEnabled.load(std::memory_order_relaxed) && record.LogLevel != Level::Off &&
+            record.LogLevel >= GateLevelOf(PackLevels(*record.CategoryLevel, backtraceLevel));
+    }
+
     // The current time, used for log line timestamps, daily rolling, and backup file names. Override it to control
     // the logger's clock, e.g. in tests. A system_clock time point has no time zone (it counts from the UTC epoch).
     virtual std::chrono::system_clock::time_point NowUTC() const noexcept
@@ -225,10 +250,10 @@ class TASWLogBase : public IASWLog
     void StampRecord(TASWLogRecord& record) const noexcept;
 
     // For a crash handler (see TASWTextLogBase): if the backtrace's lock is free, calls visit(record, index, count) for
-    // each kept entry, oldest first ('record' is marked Forced, and its Message refers to the kept copy, valid during the
-    // call), then forgets them if 'mustClear', and returns true. Returns false at once if the lock is busy (e.g. the
-    // crashed thread holds it). Allocates nothing itself, except that clearing frees the copies, so with a visitor that
-    // doesn't allocate and 'mustClear' false, it can run in a signal handler.
+    // each kept entry, oldest first ('record' is marked Forced, and its Message and Category refer to the kept copies,
+    // valid during the call), then forgets them if 'mustClear', and returns true. Returns false at once if the lock is
+    // busy (e.g. the crashed thread holds it). Allocates nothing itself, except that clearing frees the copies, so with
+    // a visitor that doesn't allocate and 'mustClear' false, it can run in a signal handler.
     template<typename TVisit>
     bool VisitBacktraceForCrash(TVisit&& visit, bool mustClear)
     {
@@ -242,6 +267,7 @@ class TASWLogBase : public IASWLog
             const auto& entry = m_Backtrace[(m_BacktraceOldest + index) % count];
             TASWLogRecord record = entry.Record;
             record.Message = entry.Message;
+            record.Category = entry.Category;
             record.Forced = true;
             visit(static_cast<const TASWLogRecord&>(record), index, count);
         }
@@ -314,12 +340,17 @@ class TASWLogBase : public IASWLog
         return PassesLevelGate(level);
     }
 
+    bool ShouldLog(const TASWLogRecord& record) const noexcept override
+    {
+        return PassesLevelGate(record);
+    }
+
 public:
-    // Applies this logger's checks (enabled, not Level::Off, and the minimum level unless record.Forced), then stamps
-    // the record (see StampRecord()) and passes it to WriteRecord(). A filtered entry is never stamped. An entry below
-    // the minimum level that the backtrace keeps (see TASWBacktraceConfig) is stamped and kept instead; one at or above
-    // its DumpAtLevel first passes the kept entries to WriteRecord(), between the two marker lines. If WriteRecord()
-    // throws, the entry is dropped and reported (see ReportError()).
+    // Applies this logger's checks (enabled, not Level::Off, and the minimum level, or record.CategoryLevel if set,
+    // unless record.Forced), then stamps the record (see StampRecord()) and passes it to WriteRecord(). A filtered
+    // entry is never stamped. An entry below that minimum level that the backtrace keeps (see TASWBacktraceConfig) is
+    // stamped and kept instead; one at or above its DumpAtLevel first passes the kept entries to WriteRecord(), between
+    // the two marker lines. If WriteRecord() throws, the entry is dropped and reported (see ReportError()).
     void Write(const TASWLogRecord& record) noexcept final;
 };
 
diff --git a/ASWLog/ASWLog_CategoryLog.cpp b/ASWLog/ASWLog_CategoryLog.cpp
new file mode 100644
index 0000000..24504a2
--- /dev/null
+++ b/ASWLog/ASWLog_CategoryLog.cpp
@@ -0,0 +1,225 @@
+/* **************************************************************************
+ASWLog_CategoryLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_CategoryLog.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <format>
+//---------------------------------------------------------------------------
+#include "ASWLog_Version.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+namespace
+{
+
+std::string MakeCategoryName(std::string_view name, const IASWLog& log);
+
+//---------------------------------------------------------------------------
+
+/*
+  MakeCategoryName
+
+  The full name of a category called 'name' wrapping 'log': "<log's name>.<name>" if 'log' is a category, else 'name'
+*/
+std::string MakeCategoryName(std::string_view name, const IASWLog& log)
+{
+    const auto* category = dynamic_cast<const TASWCategoryLog*>(&log);
+    if (category == nullptr)
+        return std::string(name);
+
+    std::string fullName(category->GetName());
+    fullName += '.';
+    fullName.append(name);
+    return fullName;
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWCategoryLog
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWCategoryLog::TASWCategoryLog(std::string_view name, IASWLog& log)
+    : m_Log(log),
+      m_Name(MakeCategoryName(name, log))
+{
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::Close() noexcept
+{
+    return false;
+}
+
+//---------------------------------------------------------------------------
+void TASWCategoryLog::DumpBacktrace() noexcept
+{
+    if (IsEnabled())
+        m_Log.DumpBacktrace();
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::Flush() noexcept
+{
+    return m_Log.Flush();
+}
+
+//---------------------------------------------------------------------------
+std::shared_ptr<const TASWLogConfig> TASWCategoryLog::GetConfig() const noexcept
+{
+    return m_Log.GetConfig();
+}
+
+//---------------------------------------------------------------------------
+std::string TASWCategoryLog::GetFullVersionStr() const
+{
+    return std::format("TASWCategoryLog - Base version {}", GetVersionStr());
+}
+
+//---------------------------------------------------------------------------
+Level TASWCategoryLog::GetMinimumLevel() const noexcept
+{
+    const auto level = m_Level.load(std::memory_order_relaxed);
+    return level == NoOwnLevel ? m_Log.GetMinimumLevel() : static_cast<Level>(level);
+}
+
+//---------------------------------------------------------------------------
+std::string_view TASWCategoryLog::GetName() const noexcept
+{
+    return m_Name;
+}
+
+//---------------------------------------------------------------------------
+std::string_view TASWCategoryLog::GetVersionStr() const noexcept
+{
+    return Version; // See ASWLog_Version.h
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::HasOwnMinimumLevel() const noexcept
+{
+    return m_Level.load(std::memory_order_relaxed) != NoOwnLevel;
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::Initialize(const TASWLogConfig& /*config*/) noexcept
+{
+    return false;
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::IsEnabled() const noexcept
+{
+    return m_IsEnabled.load(std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::IsOpen() const noexcept
+{
+    return m_Log.IsOpen();
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::Open() noexcept
+{
+    return false;
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::Reconfigure(const TASWLogConfig& /*config*/) noexcept
+{
+    return false;
+}
+
+//---------------------------------------------------------------------------
+void TASWCategoryLog::ResetMinimumLevel() noexcept
+{
+    m_Level.store(NoOwnLevel, std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+void TASWCategoryLog::SetEnabled(bool enabled) noexcept
+{
+    m_IsEnabled.store(enabled, std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+void TASWCategoryLog::SetMinimumLevel(Level level) noexcept
+{
+    m_Level.store(static_cast<std::uint8_t>(level), std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::ShouldLog(Level level) const noexcept
+{
+    TASWLogRecord record;
+    record.LogLevel = level;
+
+    return ShouldLog(record);
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::ShouldLog(const TASWLogRecord& record) const noexcept
+{
+    return IsEnabled() && m_Log.ShouldLog(WithCategory(record));
+}
+
+//---------------------------------------------------------------------------
+/*
+    TASWCategoryLog::WithCategory
+
+    'record' with this category's name and own level filled in, where a category wrapping this one hasn't set them
+*/
+TASWLogRecord TASWCategoryLog::WithCategory(const TASWLogRecord& record) const noexcept
+{
+    TASWLogRecord result = record;
+    if (result.Category.empty())
+        result.Category = m_Name;
+
+    if (!result.CategoryLevel)
+    {
+        const auto level = m_Level.load(std::memory_order_relaxed);
+        if (level != NoOwnLevel)
+            result.CategoryLevel = static_cast<Level>(level);
+    }
+
+    return result;
+}
+
+//---------------------------------------------------------------------------
+void TASWCategoryLog::Write(const TASWLogRecord& record) noexcept
+{
+    if (IsEnabled())
+        m_Log.Write(WithCategory(record));
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_CategoryLog.h b/ASWLog/ASWLog_CategoryLog.h
new file mode 100644
index 0000000..6650e74
--- /dev/null
+++ b/ASWLog/ASWLog_CategoryLog.h
@@ -0,0 +1,141 @@
+/* **************************************************************************
+ASWLog_CategoryLog.h
+Author: Anthony S. West - ASW Software
+
+A light-weight logging tool.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_CategoryLogH
+#define ASWLog_CategoryLogH
+//---------------------------------------------------------------------------
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <string_view>
+//---------------------------------------------------------------------------
+#include "ASWLog_Interface.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWCategoryLog
+//
+// A named category of entries, e.g. "Net" or "Db", with a minimum level of its own. It wraps another logger (a file,
+// console or multi-log, or another category) and passes every entry on to it, with the category's name in
+// TASWLogRecord::Category, which the built-in layout shows after the level, e.g. "[Net]" (see
+// TASWLineConfig::ShowCategory):
+//     static ASWLog::TASWCategoryLog NetLog("Net", ASWLog::TASWFileLog::GetInstance());
+//     NetLog.LogDebugFmt("connected to {}", host);
+//
+// Until SetMinimumLevel() is called, the category follows the wrapped logger's minimum level. Once set, its level
+// replaces the wrapped logger's for this category's entries, both ways: with the file logger at Info,
+// NetLog.SetMinimumLevel(Level::Debug) lets Net's Debug entries in, and DbLog.SetMinimumLevel(Level::Warn) keeps Db's
+// Info entries out. The wrapped logger's backtrace still keeps the entries below it (see TASWBacktraceConfig), and a
+// multi-log's loggers still apply their own minimum levels. ResetMinimumLevel() makes it follow again.
+//
+// A category wrapping another category adds its name to that one's, e.g. "Net.Http" for HttpLog("Http", NetLog), and
+// uses its own level if set, else that category's, and so on up to the wrapped logger's.
+//
+// The output belongs to the wrapped logger: GetConfig(), Flush(), IsOpen() and DumpBacktrace() pass on to it, while
+// Initialize(), Reconfigure(), Open() and Close() do nothing and return false, so a category can't reconfigure or close
+// a log the rest of the application uses. SetEnabled(false) silences only this category (and the categories wrapping
+// it); the wrapped logger must be enabled too.
+//
+// Lock-free and thread-safe. The wrapped logger must outlive the category, and must not be a multi-log that holds the
+// category. A logger that keeps an entry beyond the call (e.g. in its backtrace) copies the category's name, so the
+// category may be destroyed meanwhile.
+/////////////////////////////////////////////////////////////////////////////
+class TASWCategoryLog : public IASWLog
+{
+private:
+    typedef IASWLog inherited;
+
+private:
+    // m_Level's value while the category has no level of its own
+    static constexpr std::uint8_t NoOwnLevel = 0xFF;
+
+private:
+    IASWLog& m_Log;
+    const std::string m_Name;
+    std::atomic<std::uint8_t> m_Level{ NoOwnLevel };
+    std::atomic<bool> m_IsEnabled{ true };
+
+private:
+    TASWLogRecord WithCategory(const TASWLogRecord& record) const noexcept;
+
+public:
+    // Shows 'name' as is, or, if 'log' is a category, after that category's name and a '.'. Throws std::bad_alloc if
+    // the name can't be copied.
+    TASWCategoryLog(std::string_view name, IASWLog& log);
+    ~TASWCategoryLog() override = default;
+
+    TASWCategoryLog(const TASWCategoryLog&) = delete;
+    TASWCategoryLog& operator=(const TASWCategoryLog&) = delete;
+
+    // The full name, e.g. "Net.Http"
+    std::string_view GetName() const noexcept;
+    // True once SetMinimumLevel() has given the category a level of its own, until ResetMinimumLevel()
+    bool HasOwnMinimumLevel() const noexcept;
+    // Makes the category follow the wrapped logger's minimum level again
+    void ResetMinimumLevel() noexcept;
+
+    std::string_view GetVersionStr() const noexcept override;
+    std::string GetFullVersionStr() const override;
+
+    // The wrapped logger's
+    std::shared_ptr<const TASWLogConfig> GetConfig() const noexcept override;
+
+    // Do nothing and return false: the wrapped logger's owner initializes, configures, opens and closes it
+    bool Initialize(const TASWLogConfig& config) noexcept override;
+    bool Reconfigure(const TASWLogConfig& config) noexcept override;
+    bool Open() noexcept override;
+    bool Close() noexcept override;
+
+    // Pass on to the wrapped logger (DumpBacktrace() only while this category is enabled)
+    bool Flush() noexcept override;
+    bool IsOpen() const noexcept override;
+    void DumpBacktrace() noexcept override;
+
+    // This category's own: disabled, it passes nothing on, not even forced entries
+    bool IsEnabled() const noexcept override;
+    void SetEnabled(bool enabled) noexcept override;
+
+    // The category's own level if it has one, else the wrapped logger's
+    Level GetMinimumLevel() const noexcept override;
+    // Gives the category a level of its own, which replaces the wrapped logger's minimum level for its entries
+    void SetMinimumLevel(Level level) noexcept override;
+
+    // Whether the wrapped logger would use an entry passed on by this category (see Write())
+    bool ShouldLog(Level level) const noexcept override;
+    bool ShouldLog(const TASWLogRecord& record) const noexcept override;
+
+    // Unless this category is disabled, passes the record on to the wrapped logger with the category's name in Category
+    // and its own level, if set, in CategoryLevel, where a category wrapping this one hasn't set them already
+    void Write(const TASWLogRecord& record) noexcept override;
+};
+
+} // namespace ASWLog
+
+#endif // ASWLog_CategoryLogH
diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 454fb38..e0d9b44 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -229,6 +229,7 @@ struct TASWLineConfig
     // The fields TASWTextFormatter writes before the message
     bool ShowTimestamp      = true; // The entry's time (see TimestampZone and TimestampPrecision)
     bool ShowLevel          = true;
+    bool ShowCategory       = true; // The entry's category, if it has one (see TASWCategoryLog)
     bool ShowProcessId      = true;
     bool ShowThreadId       = true;
     bool ShowWorkingSet     = false; // The process's memory use
diff --git a/ASWLog/ASWLog_CrashHandler.cpp b/ASWLog/ASWLog_CrashHandler.cpp
index 5adae5a..b4d6fbe 100644
--- a/ASWLog/ASWLog_CrashHandler.cpp
+++ b/ASWLog/ASWLog_CrashHandler.cpp
@@ -700,6 +700,13 @@ void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRL
     line.AppendISO8601(record.Timestamp);
     line.Append("][");
     line.Append(Level_ToString(record.LogLevel));
+
+    if (!record.Category.empty())
+    {
+        line.Append("][");
+        line.Append(record.Category);
+    }
+
     line.Append("][P:");
     line.AppendDecimal(record.ProcessId);
     line.Append("][T:");
diff --git a/ASWLog/ASWLog_CrashHandler.h b/ASWLog/ASWLog_CrashHandler.h
index 0d5bda5..d08d6cd 100644
--- a/ASWLog/ASWLog_CrashHandler.h
+++ b/ASWLog/ASWLog_CrashHandler.h
@@ -73,7 +73,7 @@ struct TASWCrashHandlerOptions
 //   file. Its time is UTC with milliseconds whatever TASWLineConfig::TimestampZone and TimestampPrecision say, since
 //   converting to local time isn't async-signal-safe. The buffered entries are flushed only if the logger's lock is free (fflush isn't on POSIX's list of
 //   async-signal-safe functions, but no other thread can use the file then). The backtrace's lines get the same
-//   layout, with their own level, and only if the backtrace's lock is free.
+//   layout, with their own level and category (after the level, as "[Net]"), and only if the backtrace's lock is free.
 // - If a logger's lock stays busy until WaitTimeout has passed (e.g. the crash happened while that thread was
 //   writing an entry), its buffered entries are lost and only the fixed-layout lines (backtrace and crash line) are
 //   written, straight to the file.
diff --git a/ASWLog/ASWLog_Formatter.cpp b/ASWLog/ASWLog_Formatter.cpp
index 9cb06da..fd8d855 100644
--- a/ASWLog/ASWLog_Formatter.cpp
+++ b/ASWLog/ASWLog_Formatter.cpp
@@ -97,6 +97,13 @@ std::string TASWTextFormatter::FormatLine(const TASWLogRecord& record, const TAS
         line += ']';
     }
 
+    if (config.Line.ShowCategory && !record.Category.empty())
+    {
+        line += '[';
+        line.append(record.Category);
+        line += ']';
+    }
+
     if (config.Line.ShowProcessId)
         AppendNumberField(line, "P:", record.ProcessId);
 
diff --git a/ASWLog/ASWLog_Formatter.h b/ASWLog/ASWLog_Formatter.h
index 89cacaa..7b4984e 100644
--- a/ASWLog/ASWLog_Formatter.h
+++ b/ASWLog/ASWLog_Formatter.h
@@ -65,9 +65,10 @@ class IASWLogFormatter
 // TASWTextFormatter
 //
 // The built-in text layout, used when TASWLogConfig::Line.Formatter is empty:
-// "[time][LEVEL][P:pid][T:tid][WS:bytes][PWS:bytes][function][file:line]: message", where each bracketed field is
-// written only if its TASWLineConfig option is on (ShowTimestamp, ShowLevel, ShowProcessId, ShowThreadId,
-// ShowWorkingSet, ShowPeakWorkingSet, ShowFunctionName, ShowSourceLine).
+// "[time][LEVEL][category][P:pid][T:tid][WS:bytes][PWS:bytes][function][file:line]: message", where each bracketed
+// field is written only if its TASWLineConfig option is on (ShowTimestamp, ShowLevel, ShowCategory, ShowProcessId,
+// ShowThreadId, ShowWorkingSet, ShowPeakWorkingSet, ShowFunctionName, ShowSourceLine), and the category only if the
+// entry has one.
 /////////////////////////////////////////////////////////////////////////////
 class TASWTextFormatter : public IASWLogFormatter
 {
diff --git a/ASWLog/ASWLog_Interface.h b/ASWLog/ASWLog_Interface.h
index c8072a6..407735b 100644
--- a/ASWLog/ASWLog_Interface.h
+++ b/ASWLog/ASWLog_Interface.h
@@ -204,8 +204,9 @@ class IASWLog
     virtual bool IsEnabled() const noexcept = 0;
     virtual void SetEnabled(bool enabled) noexcept = 0;
 
-    // The level an entry needs to be written by Log()/LogRaw() (LogForce*() ignores it). Seeded by Initialize() from
-    // TASWLogConfig::InitialMinimumLevel. Lock-free, so it can be changed from any thread at any time.
+    // The level an entry needs to be written by Log()/LogRaw() (LogForce*() ignores it; a category's own level replaces
+    // it, see TASWCategoryLog). Seeded by Initialize() from TASWLogConfig::InitialMinimumLevel. Lock-free, so it can be
+    // changed from any thread at any time.
     virtual Level GetMinimumLevel() const noexcept = 0;
     virtual void SetMinimumLevel(Level level) noexcept = 0;
 
@@ -214,12 +215,16 @@ class IASWLog
     // accept it). The *Fmt methods use it to skip formatting an entry that wouldn't be used; use it the same way to
     // skip building an expensive message.
     virtual bool ShouldLog(Level level) const noexcept = 0;
+    // True if Write() would use 'record': like ShouldLog(Level) for its level, with record.CategoryLevel in place of
+    // the minimum level if set, and only the enabled and Level::Off checks if record.Forced. A category logger (see
+    // TASWCategoryLog) asks the logger it wraps this way.
+    virtual bool ShouldLog(const TASWLogRecord& record) const noexcept = 0;
 
     // Receives every entry: from the logging methods below, or passed on by another logger (e.g. a multi-log). Writes
-    // it unless the logger is disabled, its level is Off, or it is below the minimum level and not record.Forced (the
-    // backtrace may keep such an entry, see TASWBacktraceConfig). A logger that writes or keeps it first fills in the
-    // record's Timestamp, ProcessId and ThreadId if they are still zero, on the calling thread (see TASWLogRecord). An
-    // entry that can't be written (e.g. out of memory) is dropped.
+    // it unless the logger is disabled, its level is Off, or it is below the minimum level (record.CategoryLevel if
+    // set) and not record.Forced (the backtrace may keep such an entry, see TASWBacktraceConfig). A logger that writes
+    // or keeps it first fills in the record's Timestamp, ProcessId and ThreadId if they are still zero, on the calling
+    // thread (see TASWLogRecord). An entry that can't be written (e.g. out of memory) is dropped.
     virtual void Write(const TASWLogRecord& record) noexcept = 0;
 
     // --- Non-virtual Inline Logging Methods ---
diff --git a/ASWLog/ASWLog_MultiLog.cpp b/ASWLog/ASWLog_MultiLog.cpp
index 5bbbd00..fe0a1d2 100644
--- a/ASWLog/ASWLog_MultiLog.cpp
+++ b/ASWLog/ASWLog_MultiLog.cpp
@@ -262,15 +262,29 @@ bool TASWMultiLog::RemoveLogger(IASWLog& logger) noexcept
 //---------------------------------------------------------------------------
 bool TASWMultiLog::ShouldLog(Level level) const noexcept
 {
-    if (!PassesLevelGate(level))
+    TASWLogRecord record;
+    record.LogLevel = level;
+
+    return ShouldLog(record);
+}
+
+//---------------------------------------------------------------------------
+bool TASWMultiLog::ShouldLog(const TASWLogRecord& record) const noexcept
+{
+    if (!PassesLevelGate(record))
         return false;
 
+    // As WriteRecord() passes it on: the sinks apply their own minimum levels
+    TASWLogRecord sinkRecord = record;
+    sinkRecord.CategoryLevel.reset();
+
     // Iterates under the lock instead of copying the list, which could throw. A sink's ShouldLog() must not call back
-    // into this composite (the built-in loggers' ShouldLog() only reads their own level and enabled flag).
+    // into this composite (the built-in loggers' ShouldLog() only reads their own level and enabled flag; a category
+    // logger asks the logger it wraps, which must not be this composite).
     std::lock_guard<std::mutex> lock(m_ListMutex);
     for (const auto* sink : m_Sinks)
     {
-        if (sink->ShouldLog(level))
+        if (sink->ShouldLog(sinkRecord))
             return true;
     }
 
@@ -289,12 +303,16 @@ std::vector<IASWLog*> TASWMultiLog::SnapshotSinks() const
     TASWMultiLog::WriteRecord
 
     Each sink's Write() is noexcept, so a failing sink can't stop the others from getting the entry. If copying the
-    sink list throws (out of memory), TASWLogBase::Write() drops the entry.
+    sink list throws (out of memory), TASWLogBase::Write() drops the entry. A category's level replaced only this
+    composite's minimum level (see TASWLogRecord::CategoryLevel), so the sinks get the record without it.
 */
 void TASWMultiLog::WriteRecord(const TASWLogRecord& record)
 {
+    TASWLogRecord sinkRecord = record;
+    sinkRecord.CategoryLevel.reset();
+
     for (auto* sink : SnapshotSinks())
-        sink->Write(record);
+        sink->Write(sinkRecord);
 }
 
 //---------------------------------------------------------------------------
diff --git a/ASWLog/ASWLog_MultiLog.h b/ASWLog/ASWLog_MultiLog.h
index 6ba7a05..419b880 100644
--- a/ASWLog/ASWLog_MultiLog.h
+++ b/ASWLog/ASWLog_MultiLog.h
@@ -53,7 +53,9 @@ namespace ASWLog
 // acts as an optional composite-level pre-filter gate, checked before fanning
 // Log()/LogRaw() out (default Trace = no extra filtering); LogForce()/
 // LogForceRaw() bypass it, matching force semantics elsewhere. Each sink
-// still applies its own level independently. SetEnabled(false) on the
+// still applies its own level independently. A category logger wrapping
+// this composite (see TASWCategoryLog) with a level of its own replaces this
+// composite's level, not the sinks'. SetEnabled(false) on the
 // composite stops all fan-out, forced entries included. All other
 // settings in this class's config (Line, Startup, Shutdown, File,
 // OnLogEntry) are inert, since the composite performs no I/O of its own.
@@ -87,7 +89,8 @@ class TASWMultiLog : public TASWLogBase
     // TASWBacktraceConfig)
     bool KeepsBacktrace() const noexcept override;
 
-    // Passes the record, stamped once by Write(), to every registered sink's Write(), so they all show the same time
+    // Passes the record, stamped once by Write(), to every registered sink's Write(), so they all show the same time.
+    // Its CategoryLevel is left out: a category's level replaces this composite's minimum level, not the sinks'.
     void WriteRecord(const TASWLogRecord& record) override;
 
 public:
@@ -127,6 +130,9 @@ class TASWMultiLog : public TASWLogBase
     // True if this composite's own gate passes (enabled, not Off, minimum level) and at least one registered sink's
     // ShouldLog() is true (false if none are registered).
     bool ShouldLog(Level level) const noexcept override;
+    // The same for a record: its CategoryLevel, if set, replaces this composite's minimum level, and the sinks are
+    // asked without it (see WriteRecord())
+    bool ShouldLog(const TASWLogRecord& record) const noexcept override;
 };
 
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index 8a7bcc0..cc788c8 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -421,11 +421,13 @@ bool TASWTextLogBase::QueueRecord(const TASWLogRecord& record)
     entry.Line = FormatEntry(record, *config);
     entry.Record = record;
     entry.Record.Message = {};
+    entry.Record.Category = {};
     entry.MustFlush = record.LogLevel >= config->Async.WaitAtLevel;
 
     if (config->OnLogEntry != nullptr && record.LogLevel >= config->OnLogEntryMinimumLevel)
     {
         entry.Message = record.Message;
+        entry.Category = record.Category;
         entry.CallbackConfig = config;
     }
 
@@ -963,7 +965,7 @@ void TASWTextLogBase::WriteInitializationInfo()
 */
 std::string TASWTextLogBase::WriteLogEntry(const TASWLogRecord& record)
 {
-    if (!IsEnabled() || (!record.Forced && record.LogLevel < GetMinimumLevel()))
+    if (!IsEnabled() || (!record.Forced && record.LogLevel < GetMinimumLevelFor(record)))
         return {};
 
     if (!PrepareWriteUnlocked(record.Timestamp))
@@ -1077,6 +1079,7 @@ void TASWTextLogBase::WriteQueuedEntries(std::deque<TQueuedEntry>& entries, std:
 
         auto record = entry.Record;
         record.Message = entry.Message;
+        record.Category = entry.Category;
         DispatchLogCallback(*entry.CallbackConfig, record, entry.Line);
     }
 }
diff --git a/ASWLog/ASWLog_TextLogBase.h b/ASWLog/ASWLog_TextLogBase.h
index 281738b..f7ea9cf 100644
--- a/ASWLog/ASWLog_TextLogBase.h
+++ b/ASWLog/ASWLog_TextLogBase.h
@@ -104,8 +104,9 @@ class TASWTextLogBase : public TASWLogBase
     // An entry queued by an asynchronous logger (see TASWAsyncConfig), for the worker to write
     struct TQueuedEntry
     {
-        TASWLogRecord Record; // Its Message is empty: the text is in Message, if needed
+        TASWLogRecord Record; // Its Message and Category are empty: the texts are in Message and Category, if needed
         std::string Message; // The record's message, copied only if OnLogEntry will be called
+        std::string Category; // The record's category, likewise
         std::string Line; // The line to write: formatted, or the raw text
         std::shared_ptr<const TASWLogConfig> CallbackConfig; // Set only if OnLogEntry will be called
         std::uint64_t Sequence = 0;
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index c3e9b62..eff93db 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -415,21 +415,29 @@ struct TASWLogError
 // callback. The Log* methods fill in the level, message, location and flags. Timestamp, ProcessId and ThreadId stay
 // zero until a logger knows it will write the entry: TASWLogBase::Write() then fills in those still zero, on the
 // calling thread before taking any lock, so they record the moment and thread of the call. A record passed on (e.g.
-// by a multi-log to its loggers) keeps them.
+// by a multi-log to its loggers) keeps them. A category logger (see TASWCategoryLog) fills in Category and, if it has
+// a level of its own, CategoryLevel.
 //
-// Message and Location refer to the caller's data, so they are only valid during the call; a logger, formatter or
-// callback that keeps a record beyond it must copy them.
+// Message, Category and Location refer to the caller's data, so they are only valid during the call; a logger,
+// formatter or callback that keeps a record beyond it must copy them.
 /////////////////////////////////////////////////////////////////////////////
 struct TASWLogRecord
 {
+    // The small fields are together, so a logging call, which builds a record even when its logger filters the entry
+    // out, fills them in with few stores
     std::chrono::system_clock::time_point Timestamp; // UTC (a system_clock time point counts from the UTC epoch)
     Level LogLevel = Level::Info;
+    // The category's own level, which the logger receiving the entry uses in place of its minimum level; empty if the
+    // category has none, or there is no category (see TASWCategoryLog::SetMinimumLevel()). A multi-log uses it for its
+    // own check and empties it before passing the entry on, since its loggers apply their own minimum levels.
+    std::optional<Level> CategoryLevel;
+    bool Raw = false; // Written as is, without the line layout or a line ending (LogRaw(), LogForceRaw())
+    bool Forced = false; // Written whatever the minimum level (LogForce(), LogForceRaw())
     std::string_view Message;
+    std::string_view Category; // The category's name, e.g. "Net" or "Net.Http"; empty if none (see TASWCategoryLog)
     std::source_location Location; // Where the entry was logged
     std::uint32_t ProcessId = 0; // The OS process id (see GetCurrentOSProcessId())
     std::uint32_t ThreadId = 0; // The OS id of the thread that logged the entry (see GetCurrentOSThreadId())
-    bool Raw = false; // Written as is, without the line layout or a line ending (LogRaw(), LogForceRaw())
-    bool Forced = false; // Written whatever the minimum level (LogForce(), LogForceRaw())
 };
 
 //---------------------------------------------------------------------------
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef12703..f30a6af 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,6 +26,31 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   costs a `localtime_s`/`localtime_r` call per line. `Time::WriteISO8601()`
   and `Time::ToISO8601String()` take the zone and precision too, and
   `Time::ToDateString()` the zone.
+- Categories with their own levels: `TASWCategoryLog` (new
+  `ASWLog_CategoryLog.h`) wraps any logger, e.g.
+  `static ASWLog::TASWCategoryLog NetLog("Net", ASWLog::TASWFileLog::GetInstance());`,
+  and passes its entries on with the category's name, which the built-in
+  layout shows after the level (`[2026-10-08T14:31:00.217Z][DEBUG][Net]...`;
+  hide it with the new `Line.ShowCategory`). Entries without a category
+  are written as before. A category follows the wrapped logger's minimum
+  level until `SetMinimumLevel()` gives it one of its own, which then
+  replaces the wrapped logger's for that category's entries, both ways: with
+  the file logger at Info, a `Net` category at Debug writes its Debug
+  entries and a `Db` category at Warn skips its Info entries (the backtrace
+  still keeps them; behind a multi-log, each logger still applies its own
+  level). `ResetMinimumLevel()` makes it follow again, and
+  `SetEnabled(false)` silences only that category. A category wrapping
+  another one is named after both, e.g. `Net.Http`, and inherits its level.
+  `GetConfig()`, `Flush()`, `IsOpen()` and `DumpBacktrace()` pass on to the
+  wrapped logger; `Initialize()`, `Reconfigure()`, `Open()` and `Close()` do
+  nothing and return false. `TASWLogRecord` gains `Category` and
+  `CategoryLevel`, which `OnLogEntry` and custom formatters see, and the
+  fixed-layout crash and backtrace lines show the category too. Breaking
+  for a class that implements `IASWLog` directly: it must now implement
+  `ShouldLog(const TASWLogRecord&)` (classes derived from `TASWLogBase` get
+  it), which tells a category whether an entry with its level would be
+  written. `TASWLogRecord`'s `Raw` and `Forced` now come right after
+  `LogLevel`, so designated initializers must follow the new order.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ab9831b..5f0a8a9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,6 +20,8 @@ set_property(CACHE ASWLOG_SANITIZE PROPERTY STRINGS "" thread address)
 add_library(ASWLog STATIC
     ASWLog/ASWLog_Base.cpp
     ASWLog/ASWLog_Base.h
+    ASWLog/ASWLog_CategoryLog.cpp
+    ASWLog/ASWLog_CategoryLog.h
     ASWLog/ASWLog_Config.cpp
     ASWLog/ASWLog_Config.h
     ASWLog/ASWLog_ConsoleLog.cpp
diff --git a/Deploy.bat b/Deploy.bat
index d2bbbd0..9b38d1d 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -68,6 +68,10 @@ call :CopyFile "ASWLog\ASWLog_Base.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Base.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Base.h" "%TARGET_DIR%\ASWLog\ASWLog_Base.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_CategoryLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_CategoryLog.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_CategoryLog.h" "%TARGET_DIR%\ASWLog\ASWLog_CategoryLog.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Config.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Config.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Config.h" "%TARGET_DIR%\ASWLog\ASWLog_Config.h"
diff --git a/README.md b/README.md
index f16089a..22ddb2d 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,9 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
 - Configurable log levels, metadata, line endings, flushing, file paths, and rotation.
 - ISO 8601 timestamps in UTC (the default) or local time with its offset, to the millisecond, microsecond or
   nanosecond (`Line.TimestampZone`, `Line.TimestampPrecision`); daily rolling and backup names follow the same clock.
+- Categories (`ASWLog::TASWCategoryLog`, in `ASWLog_CategoryLog.h`): a named logger for one part of an application,
+  e.g. `Net`, that wraps any logger and marks its entries `[Net]`. Give one a level of its own to see that part's
+  Debug entries while the rest of the log stays at Info.
 - Formatted, raw, forced, and force-raw logging APIs with source-location support. Format strings are checked
   against their arguments at compile time; wrap one built at run time in `ASWLog::RuntimeFormat()`.
 - Runtime `Open()`, `Close()`, `Flush()` and log rotation controls, and `Reconfigure()` to change settings safely
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index b077c7b..f9f1b73 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -139,6 +139,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Base.h</DependentOn>
             <BuildOrder>2</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_CategoryLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_CategoryLog.h</DependentOn>
+            <BuildOrder>14</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_Config.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_Config.h</DependentOn>
             <BuildOrder>3</BuildOrder>
diff --git a/example/src/main.cpp b/example/src/main.cpp
index edbfe54..4aaa746 100644
--- a/example/src/main.cpp
+++ b/example/src/main.cpp
@@ -25,6 +25,7 @@ limitations under the License.
 #include <string>
 #include <string_view>
 //---------------------------------------------------------------------------
+#include "ASWLog_CategoryLog.h"
 #include "ASWLog_ConsoleLog.h"
 #include "ASWLog_CrashHandler.h"
 #include "ASWLog_FileLog.h"
@@ -203,6 +204,16 @@ int main(int argc, char* argv[])
     multiLogger.LogWarn("This Warn is suppressed by the composite gate before reaching either sink.");
     multiLogger.LogError("This Error clears the composite gate and reaches both sinks.");
 
+    // Example of categories: each entry shows its category after the level, e.g. "[Db]", and a category with a level
+    // of its own uses it instead of the wrapped logger's (Trace here)
+    std::cout << "Testing category loggers...\n";
+    ASWLog::TASWCategoryLog netLogger("Net", globalLogger);
+    ASWLog::TASWCategoryLog dbLogger("Db", globalLogger);
+    dbLogger.SetMinimumLevel(ASWLog::Level::Warn);
+    netLogger.LogDebug("This Net entry follows the file logger's level, so it is written.");
+    dbLogger.LogInfo("This Db entry is below the Db category's own level (Warn), so it is skipped.");
+    dbLogger.LogWarn("This Db entry is at the Db category's own level, so it is written.");
+
     globalLogger.LogInfo("Application terminated naturally via main exit block.");
     std::cout << "Execution completed.\n";
 
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index 5cf83b8..945d06c 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -33,6 +33,7 @@ endif()
 add_executable(ASWLogTests
     ${ASWUNITTESTS_SOURCES}
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Base.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_CategoryLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Config.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_ConsoleLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_CrashHandler.cpp"
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index a506c85..4eb82b6 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -154,6 +154,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Base.h</DependentOn>
             <BuildOrder>0</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_CategoryLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_CategoryLog.h</DependentOn>
+            <BuildOrder>36</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_Config.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_Config.h</DependentOn>
             <BuildOrder>1</BuildOrder>
@@ -206,6 +210,10 @@
             <DependentOn>..\tests\Test_ASWLog_Base.h</DependentOn>
             <BuildOrder>19</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_CategoryLog.cpp">
+            <DependentOn>..\tests\Test_ASWLog_CategoryLog.h</DependentOn>
+            <BuildOrder>37</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_Config.cpp">
             <DependentOn>..\tests\Test_ASWLog_Config.h</DependentOn>
             <BuildOrder>20</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_Base.cpp b/tests/tests/Test_ASWLog_Base.cpp
index df1f9cd..6a84ead 100644
--- a/tests/tests/Test_ASWLog_Base.cpp
+++ b/tests/tests/Test_ASWLog_Base.cpp
@@ -32,6 +32,7 @@ limitations under the License.
 #include <initializer_list>
 #include <iterator>
 #include <memory>
+#include <optional>
 #include <source_location>
 #include <stdexcept>
 #include <string>
@@ -310,6 +311,7 @@ TTest_ASWLog_Base::TTest_ASWLog_Base()
     RegisterTest(&TTest_ASWLog_Base::Test_ReportError_ThrowingHandlerDoesNotEscape, "ReportError_ThrowingHandlerDoesNotEscape");
     RegisterTest(&TTest_ASWLog_Base::Test_ReportError_WritesToStdErrWithoutHandler, "ReportError_WritesToStdErrWithoutHandler");
     RegisterTest(&TTest_ASWLog_Base::Test_SetGetMinimumLevel_RoundTrips, "SetGetMinimumLevel_RoundTrips");
+    RegisterTest(&TTest_ASWLog_Base::Test_ShouldLog_RecordFollowsWritesChecks, "ShouldLog_RecordFollowsWritesChecks");
     RegisterTest(&TTest_ASWLog_Base::Test_ShouldLog_ReflectsEnabledAndLevel, "ShouldLog_ReflectsEnabledAndLevel");
     RegisterTest(&TTest_ASWLog_Base::Test_Write_AppliesEnabledOffAndLevelChecks, "Write_AppliesEnabledOffAndLevelChecks");
     RegisterTest(&TTest_ASWLog_Base::Test_Write_KeepsFieldsAlreadyStamped, "Write_KeepsFieldsAlreadyStamped");
@@ -1033,6 +1035,50 @@ void TTest_ASWLog_Base::Test_SetGetMinimumLevel_RoundTrips()
     CheckEquals(ASWLog::Level::Trace, logger.GetMinimumLevel(), "SetMinimumLevel should update the value returned by GetMinimumLevel immediately");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Base::Test_ShouldLog_RecordFollowsWritesChecks()
+{
+    // Arrange: a logger at Warn keeping a backtrace from Debug, asked through the interface
+    TTestLogger testLogger;
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Warn;
+    config.Backtrace.Capacity = 5;
+    config.Backtrace.LowestLevel = ASWLog::Level::Debug;
+    testLogger.Initialize(config);
+    ASWLog::IASWLog& logger = testLogger;
+
+    const auto makeRecord = [](ASWLog::Level level, std::optional<ASWLog::Level> categoryLevel, bool forced) {
+            ASWLog::TASWLogRecord record;
+            record.LogLevel = level;
+            record.CategoryLevel = categoryLevel;
+            record.Forced = forced;
+            return record;
+        };
+
+    // Act
+    const bool info = logger.ShouldLog(makeRecord(ASWLog::Level::Info, std::nullopt, false));
+    const bool trace = logger.ShouldLog(makeRecord(ASWLog::Level::Trace, std::nullopt, false));
+    const bool forcedTrace = logger.ShouldLog(makeRecord(ASWLog::Level::Trace, std::nullopt, true));
+    const bool forcedOff = logger.ShouldLog(makeRecord(ASWLog::Level::Off, std::nullopt, true));
+    const bool traceAtTraceCategory = logger.ShouldLog(makeRecord(ASWLog::Level::Trace, ASWLog::Level::Trace, false));
+    const bool traceAtErrorCategory = logger.ShouldLog(makeRecord(ASWLog::Level::Trace, ASWLog::Level::Error, false));
+    const bool warnAtOffCategory = logger.ShouldLog(makeRecord(ASWLog::Level::Warn, ASWLog::Level::Off, false));
+
+    logger.SetEnabled(false);
+    const bool forcedWhileDisabled = logger.ShouldLog(makeRecord(ASWLog::Level::Error, std::nullopt, true));
+    const bool categoryWhileDisabled = logger.ShouldLog(makeRecord(ASWLog::Level::Error, ASWLog::Level::Trace, false));
+
+    // Assert
+    CheckTrue(info, "An entry the backtrace keeps should be used");
+    CheckFalse(trace, "An entry below the minimum and backtrace levels should not be used");
+    CheckTrue(forcedTrace, "A forced entry should be used whatever its level");
+    CheckFalse(forcedOff, "A forced entry at Off should not be used");
+    CheckTrue(traceAtTraceCategory, "A category's level should replace the minimum level");
+    CheckFalse(traceAtErrorCategory, "Below a category's level and the backtrace's, an entry should not be used");
+    CheckFalse(warnAtOffCategory, "A category at Off should let nothing in, not even for the backtrace");
+    CheckFalse(forcedWhileDisabled, "A disabled logger should use no entry, not even a forced one");
+    CheckFalse(categoryWhileDisabled, "A disabled logger should use no entry of a category");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Base::Test_ShouldLog_ReflectsEnabledAndLevel()
 {
     // Arrange: everything through the interface, as code holding only an IASWLog& would use it
diff --git a/tests/tests/Test_ASWLog_Base.h b/tests/tests/Test_ASWLog_Base.h
index 5df6f16..5d6c1b5 100644
--- a/tests/tests/Test_ASWLog_Base.h
+++ b/tests/tests/Test_ASWLog_Base.h
@@ -58,6 +58,7 @@ class TTest_ASWLog_Base : public TTestGroupBase
     void Test_ReportError_ThrowingHandlerDoesNotEscape();
     void Test_ReportError_WritesToStdErrWithoutHandler();
     void Test_SetGetMinimumLevel_RoundTrips();
+    void Test_ShouldLog_RecordFollowsWritesChecks();
     void Test_ShouldLog_ReflectsEnabledAndLevel();
     void Test_Write_AppliesEnabledOffAndLevelChecks();
     void Test_Write_KeepsFieldsAlreadyStamped();
diff --git a/tests/tests/Test_ASWLog_CategoryLog.cpp b/tests/tests/Test_ASWLog_CategoryLog.cpp
new file mode 100644
index 0000000..5ce4df1
--- /dev/null
+++ b/tests/tests/Test_ASWLog_CategoryLog.cpp
@@ -0,0 +1,690 @@
+/* **************************************************************************
+Test_ASWLog_CategoryLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_CategoryLog.h"
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <cstdint>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <functional>
+#include <iterator>
+#include <mutex>
+#include <optional>
+#include <source_location>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_CategoryLog.h"
+#include "ASWLog_FileLog.h"
+#include "ASWLog_MultiLog.h"
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+// A value whose formatting is counted in CategoryFormatCount, to check whether a *Fmt call through a category formats
+struct TCategoryCountedValue
+{
+};
+
+int CategoryFormatCount = 0;
+
+} // namespace
+
+template<>
+struct std::formatter<TCategoryCountedValue>
+{
+    constexpr std::format_parse_context::iterator parse(std::format_parse_context& context)
+    {
+        return context.begin();
+    }
+
+    std::format_context::iterator format(const TCategoryCountedValue& /*value*/, std::format_context& context) const
+    {
+        ++CategoryFormatCount;
+        return std::format_to(context.out(), "counted");
+    }
+};
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+const auto GroupBaseTempDir = std::filesystem::temp_directory_path() / "aswlog_categorylog_tests";
+const auto TestTempDir = GroupBaseTempDir / "test";
+
+// Longer than any standard library's small string buffer, so a copy of it is on the heap, and a view of a destroyed
+// one points to freed memory (which AddressSanitizer reports)
+const std::string LongCategoryName = "A_category_name_longer_than_a_small_string_buffer";
+
+constexpr std::chrono::milliseconds WaitTimeout = std::chrono::seconds(5);
+
+// A logger that records "<LEVEL>|<category>|<message>" for each entry it writes ("|forced" added if forced), with the
+// CategoryLevel and source line each came with, and counts the calls a category must not pass on. Like any
+// TASWLogBase logger it applies its own minimum level (Info by default).
+class TRecordingLogger final : public ASWLog::TASWLogBase
+{
+protected:
+    std::string_view GetLoggerClassName() const noexcept override
+    {
+        return "TRecordingLogger";
+    }
+
+    void WriteRecord(const ASWLog::TASWLogRecord& record) override
+    {
+        Written.push_back(std::format("{}|{}|{}{}", ASWLog::Level_ToString(record.LogLevel), record.Category, record.Message,
+            record.Forced ? "|forced" : ""));
+        CategoryLevels.push_back(record.CategoryLevel);
+        SourceLines.push_back(record.Location.line());
+    }
+
+public:
+    std::vector<std::string> Written;
+    std::vector<std::optional<ASWLog::Level> > CategoryLevels;
+    std::vector<std::uint_least32_t> SourceLines;
+    int LifecycleCallCount = 0; // Initialize(), Reconfigure(), Open() and Close() calls
+    int FlushCount = 0;
+
+    bool Initialize(const ASWLog::TASWLogConfig& config) noexcept override
+    {
+        ++LifecycleCallCount;
+        try
+        {
+            [[maybe_unused]] const auto previousConfig = SetConfig(config);
+            SetMinimumLevel(config.InitialMinimumLevel);
+            m_IsInitialized.store(true, std::memory_order_release);
+
+            return true;
+        }
+        catch (...)
+        {
+            return false;
+        }
+    }
+
+    bool Reconfigure(const ASWLog::TASWLogConfig& /*config*/) noexcept override
+    {
+        ++LifecycleCallCount;
+        return true;
+    }
+
+    bool Open() noexcept override
+    {
+        ++LifecycleCallCount;
+        return true;
+    }
+
+    bool Close() noexcept override
+    {
+        ++LifecycleCallCount;
+        return true;
+    }
+
+    bool Flush() noexcept override
+    {
+        ++FlushCount;
+        return true;
+    }
+
+    bool IsOpen() const noexcept override
+    {
+        return true;
+    }
+};
+
+// A config with a backtrace of 'capacity' entries from Trace up, written at Error, and a minimum level of Info
+ASWLog::TASWLogConfig MakeBacktraceConfig(std::size_t capacity)
+{
+    ASWLog::TASWLogConfig config;
+    config.Backtrace.Capacity = capacity;
+    config.Backtrace.LowestLevel = ASWLog::Level::Trace;
+    config.Backtrace.DumpAtLevel = ASWLog::Level::Error;
+    return config;
+}
+
+// A file config for 'file' in TestTempDir whose lines show only the level (and the category), minimum level Info,
+// without the startup and shutdown lines
+ASWLog::TASWLogConfig MakeFileConfig(const std::filesystem::path& file)
+{
+    ASWLog::TASWLogConfig config;
+    config.File.FolderPath = TestTempDir;
+    config.File.FilePath = file;
+    config.File.OpenRetryCount = 1;
+    config.Line.ShowTimestamp = false;
+    config.Line.ShowProcessId = false;
+    config.Line.ShowThreadId = false;
+    config.Shutdown.WriteLine = false;
+    config.Startup.WriteTimeInfo = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+
+    return config;
+}
+
+std::string ReadFileText(const std::filesystem::path& path)
+{
+    std::ifstream stream(path, std::ios::binary);
+    if (!stream)
+        return {};
+
+    return std::string((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
+}
+
+// Checks 'condition' until it is true, for at most WaitTimeout. Returns false if it never was.
+bool WaitUntil(const std::function<bool()>& condition)
+{
+    const auto deadline = std::chrono::steady_clock::now() + WaitTimeout;
+    while (!condition())
+    {
+        if (std::chrono::steady_clock::now() >= deadline)
+            return false;
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(2));
+    }
+
+    return true;
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_CategoryLog
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_CategoryLog::TTest_ASWLog_CategoryLog()
+    : inherited("ASWLog_CategoryLog_Tests")
+{
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_Async_KeepsItsOwnCopyOfTheName, "Async_KeepsItsOwnCopyOfTheName");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_Backtrace_KeepsEntriesBelowTheCategoryLevel, "Backtrace_KeepsEntriesBelowTheCategoryLevel");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_Backtrace_KeepsItsOwnCopyOfTheName, "Backtrace_KeepsItsOwnCopyOfTheName");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_FileLog_WritesTheCategoryAfterTheLevel, "FileLog_WritesTheCategoryAfterTheLevel");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_GetMinimumLevel_FollowsTheWrappedLoggerUntilSet, "GetMinimumLevel_FollowsTheWrappedLoggerUntilSet");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_Lifecycle_LeavesTheWrappedLoggerAlone, "Lifecycle_LeavesTheWrappedLoggerAlone");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_MultiLog_CategoryLevelReplacesOnlyTheCompositeLevel, "MultiLog_CategoryLevelReplacesOnlyTheCompositeLevel");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_Nesting_JoinsNamesAndInheritsLevels, "Nesting_JoinsNamesAndInheritsLevels");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_SetEnabled_SilencesOnlyTheCategory, "SetEnabled_SilencesOnlyTheCategory");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_SetMinimumLevel_OffSilencesAllButForcedEntries, "SetMinimumLevel_OffSilencesAllButForcedEntries");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_SetMinimumLevel_ReplacesTheWrappedLoggersLevel, "SetMinimumLevel_ReplacesTheWrappedLoggersLevel");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_ShouldLog_MatchesWhatIsWritten, "ShouldLog_MatchesWhatIsWritten");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_Write_KeepsACategoryAlreadySet, "Write_KeepsACategoryAlreadySet");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_Write_StampsTheNameAndOwnLevel, "Write_StampsTheNameAndOwnLevel");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_CategoryLog::~TTest_ASWLog_CategoryLog()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::SetUp_Group()
+{
+    Log("Setting up temp group folder: " + GroupBaseTempDir.string());
+    std::filesystem::create_directories(GroupBaseTempDir);
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::SetUp_Test(ITestCase& testCase)
+{
+    Log("  Setting up temp folder for " + testCase.GetName() + ": " + TestTempDir.string());
+    std::filesystem::create_directories(TestTempDir);
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::TearDown_Group()
+{
+    Log("Cleaning up temp group folder:" + GroupBaseTempDir.string());
+    std::filesystem::remove_all(GroupBaseTempDir);
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::TearDown_Test(ITestCase& testCase)
+{
+    Log("  Cleaning up temp folder for " + testCase.GetName() + ": " + TestTempDir.string());
+    std::filesystem::remove_all(TestTempDir);
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_Async_KeepsItsOwnCopyOfTheName()
+{
+    // Arrange: an asynchronous file logger calls OnLogEntry on its own thread, after the call that logged the entry
+    std::mutex callbackMutex;
+    std::vector<std::string> callbackCategories;
+    auto config = MakeFileConfig("async.log");
+    config.Async.Enabled = true;
+    config.OnLogEntryMinimumLevel = ASWLog::Level::Trace;
+    config.OnLogEntry = [&](const ASWLog::TASWLogRecord& record, std::string_view /*line*/) {
+            std::lock_guard<std::mutex> lock(callbackMutex);
+            callbackCategories.emplace_back(record.Category);
+        };
+
+    ASWLog::TASWFileLog logger;
+    const bool initialized = logger.Initialize(config);
+
+    // Act: the category is gone before the logger's thread gets to the entry
+    {
+        ASWLog::TASWCategoryLog category(LongCategoryName, logger);
+        category.LogInfo("queued");
+    }
+
+    const bool wasCalledBack = WaitUntil([&] {
+            std::lock_guard<std::mutex> lock(callbackMutex);
+            return !callbackCategories.empty();
+        });
+
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    AssertTrue(wasCalledBack, "OnLogEntry should be called for the entry");
+    CheckEquals(LongCategoryName, callbackCategories[0], "OnLogEntry should get the category's name, kept with the queued entry");
+    CheckEquals("[INFO][" + LongCategoryName + "]: queued\n", ReadFileText(TestTempDir / "async.log"),
+        "The line should show the category");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_Backtrace_KeepsEntriesBelowTheCategoryLevel()
+{
+    // Arrange: the logger keeps a backtrace from Trace; Db is raised to Warn, Net lowered to Debug
+    TRecordingLogger logger;
+    logger.Initialize(MakeBacktraceConfig(5));
+    ASWLog::TASWCategoryLog dbLog("Db", logger);
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    dbLog.SetMinimumLevel(ASWLog::Level::Warn);
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+
+    // Act
+    dbLog.LogInfo("db_info"); // Below Db's level, so kept
+    netLog.LogTrace("net_trace"); // Below Net's level, so kept
+    netLog.LogDebug("net_debug"); // Written
+    const auto writtenBeforeError = logger.Written;
+    dbLog.LogError("db_error");
+
+    // Assert
+    const std::vector<std::string> expectedBeforeError{ "DEBUG|Net|net_debug" };
+    CheckTrue(writtenBeforeError == expectedBeforeError, "Only the entry at its category's level should be written at first");
+    const std::vector<std::string> expected{
+        "DEBUG|Net|net_debug",
+        "INFO||Backtrace: the last 2 entries below the minimum level|forced",
+        "INFO|Db|db_info|forced",
+        "TRACE|Net|net_trace|forced",
+        "INFO||Backtrace end|forced",
+        "ERROR|Db|db_error"
+    };
+    CheckTrue(logger.Written == expected, "The entries below their category's level should be in the backtrace, with their category");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_Backtrace_KeepsItsOwnCopyOfTheName()
+{
+    // Arrange: a backtrace of one entry, so the second kept entry replaces the first
+    TRecordingLogger logger;
+    logger.Initialize(MakeBacktraceConfig(1));
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    netLog.LogDebug("replaced");
+
+    // Act: the category is gone before the backtrace is written
+    {
+        ASWLog::TASWCategoryLog category(LongCategoryName, logger);
+        category.LogDebug("kept");
+    }
+
+    logger.DumpBacktrace();
+
+    // Assert
+    AssertEquals(3, logger.Written.size(), "The backtrace should be written between its markers");
+    CheckEquals("DEBUG|" + LongCategoryName + "|kept|forced", logger.Written[1],
+        "The kept entry should keep its category's name after the category is gone");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_FileLog_WritesTheCategoryAfterTheLevel()
+{
+    // Arrange: the file logger at Info; Net lowered to Debug
+    const auto logFile = TestTempDir / "category.log";
+    auto config = MakeFileConfig("category.log");
+    ASWLog::TASWFileLog logger;
+    const bool initialized = logger.Initialize(config);
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+
+    // Act
+    netLog.LogDebug("net_debug");
+    logger.LogDebug("plain_debug");
+    logger.LogInfo("plain_info");
+
+    config.Line.ShowCategory = false;
+    const bool reconfigured = logger.Reconfigure(config);
+    netLog.LogInfo("hidden");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(reconfigured, "Reconfigure should succeed");
+    CheckEquals(std::string("[DEBUG][Net]: net_debug\n[INFO]: plain_info\n[INFO]: hidden\n"), ReadFileText(logFile),
+        "The category should follow the level, its own level should let its Debug entry in, and ShowCategory should hide it");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_GetMinimumLevel_FollowsTheWrappedLoggerUntilSet()
+{
+    // Arrange
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+
+    // Act
+    const auto initialLevel = netLog.GetMinimumLevel();
+    const bool initiallyHasOwnLevel = netLog.HasOwnMinimumLevel();
+    logger.SetMinimumLevel(ASWLog::Level::Warn);
+    const auto followedLevel = netLog.GetMinimumLevel();
+
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+    const auto ownLevel = netLog.GetMinimumLevel();
+    const bool hasOwnLevel = netLog.HasOwnMinimumLevel();
+    const auto loggerLevel = logger.GetMinimumLevel();
+
+    netLog.ResetMinimumLevel();
+    const auto levelAfterReset = netLog.GetMinimumLevel();
+    const bool hasOwnLevelAfterReset = netLog.HasOwnMinimumLevel();
+
+    // Assert
+    CheckEquals(ASWLog::Level::Info, initialLevel, "A new category should have the wrapped logger's level");
+    CheckFalse(initiallyHasOwnLevel, "A new category should have no level of its own");
+    CheckEquals(ASWLog::Level::Warn, followedLevel, "The category should follow a change of the wrapped logger's level");
+    CheckEquals(ASWLog::Level::Debug, ownLevel, "SetMinimumLevel should give the category its own level");
+    CheckTrue(hasOwnLevel, "HasOwnMinimumLevel should be true after SetMinimumLevel");
+    CheckEquals(ASWLog::Level::Warn, loggerLevel, "The category's level should not change the wrapped logger's");
+    CheckEquals(ASWLog::Level::Warn, levelAfterReset, "ResetMinimumLevel should make the category follow the wrapped logger again");
+    CheckFalse(hasOwnLevelAfterReset, "HasOwnMinimumLevel should be false after ResetMinimumLevel");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_Lifecycle_LeavesTheWrappedLoggerAlone()
+{
+    // Arrange: a logger with a backtrace, so DumpBacktrace() shows whether it was passed on
+    TRecordingLogger logger;
+    logger.Initialize(MakeBacktraceConfig(5));
+    const int lifecycleCallsBefore = logger.LifecycleCallCount;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    const ASWLog::TASWLogConfig config;
+
+    // Act
+    const bool initialized = netLog.Initialize(config);
+    const bool reconfigured = netLog.Reconfigure(config);
+    const bool opened = netLog.Open();
+    const bool closed = netLog.Close();
+    const bool flushed = netLog.Flush();
+    const bool isOpen = netLog.IsOpen();
+    const auto loggerConfig = logger.GetConfig();
+    const auto categoryConfig = netLog.GetConfig();
+
+    netLog.LogDebug("kept");
+    netLog.SetEnabled(false);
+    netLog.DumpBacktrace(); // Disabled: not passed on
+    const auto writtenWhileDisabled = logger.Written.size();
+    netLog.SetEnabled(true);
+    netLog.DumpBacktrace();
+
+    // Assert
+    CheckFalse(initialized, "Initialize should do nothing and return false");
+    CheckFalse(reconfigured, "Reconfigure should do nothing and return false");
+    CheckFalse(opened, "Open should do nothing and return false");
+    CheckFalse(closed, "Close should do nothing and return false");
+    CheckEquals(lifecycleCallsBefore, logger.LifecycleCallCount, "None of them should reach the wrapped logger");
+    CheckTrue(flushed, "Flush should return the wrapped logger's result");
+    CheckEquals(1, logger.FlushCount, "Flush should be passed on");
+    CheckTrue(isOpen, "IsOpen should return the wrapped logger's result");
+    CheckSame(loggerConfig, categoryConfig, "GetConfig should return the wrapped logger's config");
+    CheckEquals(0, writtenWhileDisabled, "A disabled category should not pass DumpBacktrace on");
+    CheckEquals(3, logger.Written.size(), "DumpBacktrace should be passed on: the kept entry between the markers");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_MultiLog_CategoryLevelReplacesOnlyTheCompositeLevel()
+{
+    // Arrange: a multi-log at Info with one sink at Trace and one at Info; Net lowered to Debug
+    TRecordingLogger traceSink;
+    TRecordingLogger infoSink;
+    traceSink.SetMinimumLevel(ASWLog::Level::Trace);
+    ASWLog::TASWMultiLog multiLog;
+    multiLog.SetMinimumLevel(ASWLog::Level::Info);
+    multiLog.AddLogger(traceSink);
+    multiLog.AddLogger(infoSink);
+    ASWLog::TASWCategoryLog netLog("Net", multiLog);
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+
+    // Act
+    netLog.LogDebug("net_debug");
+    netLog.LogTrace("net_trace");
+    multiLog.LogDebug("plain_debug");
+    const bool shouldLogDebug = netLog.ShouldLog(ASWLog::Level::Debug);
+    const bool shouldLogTrace = netLog.ShouldLog(ASWLog::Level::Trace);
+
+    multiLog.RemoveLogger(traceSink);
+    const bool shouldLogDebugWithInfoSinkOnly = netLog.ShouldLog(ASWLog::Level::Debug);
+
+    // Assert
+    const std::vector<std::string> expected{ "DEBUG|Net|net_debug" };
+    CheckTrue(traceSink.Written == expected, "Net's level should replace the composite's, so its Debug entry reaches the sinks");
+    CheckEmpty(infoSink.Written, "A sink should still apply its own minimum level");
+    AssertEquals(1, traceSink.CategoryLevels.size(), "The Trace sink should get one entry");
+    CheckFalse(traceSink.CategoryLevels[0].has_value(), "The sinks should get the record without the category's level");
+    CheckTrue(shouldLogDebug, "ShouldLog should be true for Net's Debug entries");
+    CheckFalse(shouldLogTrace, "ShouldLog should be false below Net's level");
+    CheckFalse(shouldLogDebugWithInfoSinkOnly, "ShouldLog should be false when no sink takes the entry");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_Nesting_JoinsNamesAndInheritsLevels()
+{
+    // Arrange
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    ASWLog::TASWCategoryLog httpLog("Http", netLog);
+
+    // Act
+    httpLog.LogDebug("below_the_loggers_level");
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+    httpLog.LogDebug("at_nets_level");
+    const auto levelFollowingNet = httpLog.GetMinimumLevel();
+
+    httpLog.SetMinimumLevel(ASWLog::Level::Warn);
+    httpLog.LogInfo("below_https_level");
+    netLog.LogInfo("net_info");
+
+    netLog.SetEnabled(false);
+    httpLog.LogError("net_disabled");
+    const bool shouldLogWhileNetDisabled = httpLog.ShouldLog(ASWLog::Level::Error);
+
+    // Assert
+    CheckEquals(std::string("Net.Http"), std::string(httpLog.GetName()), "A nested category's name should follow its parent's");
+    const std::vector<std::string> expected{ "DEBUG|Net.Http|at_nets_level", "INFO|Net|net_info" };
+    CheckTrue(logger.Written == expected, "A nested category should use its own level if set, else its parent's, else the logger's");
+    CheckEquals(ASWLog::Level::Debug, levelFollowingNet, "A nested category without a level of its own should follow its parent's");
+    CheckFalse(shouldLogWhileNetDisabled, "Disabling a category should silence the categories wrapping it");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_SetEnabled_SilencesOnlyTheCategory()
+{
+    // Arrange
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+
+    // Act
+    netLog.SetEnabled(false);
+    netLog.LogError("disabled_category");
+    netLog.LogForce(ASWLog::Level::Error, "disabled_category_forced");
+    logger.LogInfo("plain");
+    const bool isEnabled = netLog.IsEnabled();
+    const bool shouldLogWhileDisabled = netLog.ShouldLog(ASWLog::Level::Error);
+
+    netLog.SetEnabled(true);
+    logger.SetEnabled(false);
+    netLog.LogError("disabled_logger");
+    const bool shouldLogWhileLoggerDisabled = netLog.ShouldLog(ASWLog::Level::Error);
+
+    // Assert
+    const std::vector<std::string> expected{ "INFO||plain" };
+    CheckTrue(logger.Written == expected, "A disabled category should pass nothing on, not even forced entries");
+    CheckFalse(isEnabled, "IsEnabled should be false after SetEnabled(false)");
+    CheckFalse(shouldLogWhileDisabled, "ShouldLog should be false while the category is disabled");
+    CheckFalse(shouldLogWhileLoggerDisabled, "ShouldLog should be false while the wrapped logger is disabled");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_SetMinimumLevel_OffSilencesAllButForcedEntries()
+{
+    // Arrange
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    netLog.SetMinimumLevel(ASWLog::Level::Off);
+
+    // Act
+    netLog.LogCritical("critical");
+    netLog.LogForce(ASWLog::Level::Warn, "forced");
+    logger.LogInfo("plain");
+
+    // Assert
+    const std::vector<std::string> expected{ "WARN|Net|forced|forced", "INFO||plain" };
+    CheckTrue(logger.Written == expected, "A category at Off should write only forced entries, and leave other entries alone");
+    CheckEquals(ASWLog::Level::Info, logger.GetMinimumLevel(), "The wrapped logger's level should not change");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_SetMinimumLevel_ReplacesTheWrappedLoggersLevel()
+{
+    // Arrange: the logger at Info; Net lowered to Debug, Db raised to Warn, UI following the logger
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    ASWLog::TASWCategoryLog dbLog("Db", logger);
+    ASWLog::TASWCategoryLog uiLog("UI", logger);
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+    dbLog.SetMinimumLevel(ASWLog::Level::Warn);
+
+    // Act
+    netLog.LogTrace("net_trace");
+    netLog.LogDebug("net_debug");
+    dbLog.LogInfo("db_info");
+    dbLog.LogWarn("db_warn");
+    uiLog.LogDebug("ui_debug");
+    uiLog.LogInfo("ui_info");
+    logger.LogDebug("plain_debug");
+
+    // Assert
+    const std::vector<std::string> expected{ "DEBUG|Net|net_debug", "WARN|Db|db_warn", "INFO|UI|ui_info" };
+    CheckTrue(logger.Written == expected, "Each category's own level should replace the logger's, both ways, for its entries only");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_ShouldLog_MatchesWhatIsWritten()
+{
+    // Arrange: one logger without a backtrace, one keeping a backtrace from Debug, both at Info
+    TRecordingLogger plainLogger;
+    TRecordingLogger backtraceLogger;
+    auto backtraceConfig = MakeBacktraceConfig(5);
+    backtraceConfig.Backtrace.LowestLevel = ASWLog::Level::Debug;
+    backtraceLogger.Initialize(backtraceConfig);
+
+    ASWLog::TASWCategoryLog dbLog("Db", plainLogger);
+    ASWLog::TASWCategoryLog netLog("Net", plainLogger);
+    ASWLog::TASWCategoryLog keptDbLog("Db", backtraceLogger);
+    dbLog.SetMinimumLevel(ASWLog::Level::Warn);
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+    keptDbLog.SetMinimumLevel(ASWLog::Level::Warn);
+    CategoryFormatCount = 0;
+
+    // Act
+    const bool dbInfo = dbLog.ShouldLog(ASWLog::Level::Info);
+    const bool dbWarn = dbLog.ShouldLog(ASWLog::Level::Warn);
+    const bool netDebug = netLog.ShouldLog(ASWLog::Level::Debug);
+    const bool netTrace = netLog.ShouldLog(ASWLog::Level::Trace);
+    const bool keptDbDebug = keptDbLog.ShouldLog(ASWLog::Level::Debug);
+    const bool keptDbTrace = keptDbLog.ShouldLog(ASWLog::Level::Trace);
+
+    dbLog.LogInfoFmt("db {}", TCategoryCountedValue{});
+    const int formatCountBelowLevel = CategoryFormatCount;
+    netLog.LogDebugFmt("net {}", TCategoryCountedValue{});
+    const int formatCountAtLevel = CategoryFormatCount;
+
+    // Assert
+    CheckFalse(dbInfo, "ShouldLog should be false below a raised category level");
+    CheckTrue(dbWarn, "ShouldLog should be true at a raised category level");
+    CheckTrue(netDebug, "ShouldLog should be true at a lowered category level");
+    CheckFalse(netTrace, "ShouldLog should be false below a lowered category level");
+    CheckTrue(keptDbDebug, "ShouldLog should be true for an entry the backtrace keeps");
+    CheckFalse(keptDbTrace, "ShouldLog should be false below the backtrace's lowest level");
+    CheckEquals(0, formatCountBelowLevel, "A *Fmt call below the category's level should not format");
+    CheckEquals(1, formatCountAtLevel, "A *Fmt call at the category's level should format once");
+    const std::vector<std::string> expected{ "DEBUG|Net|net counted" };
+    CheckTrue(plainLogger.Written == expected, "Only the entry at Net's level should be written");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_Write_KeepsACategoryAlreadySet()
+{
+    // Arrange: a record that already has a category and a level, as from a category wrapping this one
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    netLog.SetMinimumLevel(ASWLog::Level::Warn);
+    ASWLog::TASWLogRecord record;
+    record.LogLevel = ASWLog::Level::Info;
+    record.Message = "from_elsewhere";
+    record.Category = "Other";
+    record.CategoryLevel = ASWLog::Level::Info;
+
+    // Act
+    netLog.Write(record);
+
+    // Assert
+    const std::vector<std::string> expected{ "INFO|Other|from_elsewhere" };
+    CheckTrue(logger.Written == expected, "The record's own category and level should be kept");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_Write_StampsTheNameAndOwnLevel()
+{
+    // Arrange
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    const auto location = std::source_location::current();
+
+    // Act
+    netLog.LogInfo("without_own_level");
+    netLog.SetMinimumLevel(ASWLog::Level::Debug);
+    netLog.Log(ASWLog::Level::Info, "with_own_level", location);
+
+    // Assert
+    CheckEquals(std::string("Net"), std::string(netLog.GetName()), "GetName should return the name");
+    const std::vector<std::string> expected{ "INFO|Net|without_own_level", "INFO|Net|with_own_level" };
+    CheckTrue(logger.Written == expected, "Each entry should carry the category's name");
+    AssertEquals(2, logger.CategoryLevels.size(), "Both entries should be written");
+    CheckFalse(logger.CategoryLevels[0].has_value(), "Without a level of its own, the category should pass none");
+    CheckTrue(logger.CategoryLevels[1] == ASWLog::Level::Debug, "With a level of its own, the category should pass it");
+    CheckEquals(location.line(), logger.SourceLines[1], "The caller's location should be kept");
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_CategoryLog)
diff --git a/tests/tests/Test_ASWLog_CategoryLog.h b/tests/tests/Test_ASWLog_CategoryLog.h
new file mode 100644
index 0000000..a2e5c37
--- /dev/null
+++ b/tests/tests/Test_ASWLog_CategoryLog.h
@@ -0,0 +1,69 @@
+/* **************************************************************************
+Test_ASWLog_CategoryLog.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_CategoryLogH
+#define Test_ASWLog_CategoryLogH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_CategoryLog
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_CategoryLog : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_Async_KeepsItsOwnCopyOfTheName();
+    void Test_Backtrace_KeepsEntriesBelowTheCategoryLevel();
+    void Test_Backtrace_KeepsItsOwnCopyOfTheName();
+    void Test_FileLog_WritesTheCategoryAfterTheLevel();
+    void Test_GetMinimumLevel_FollowsTheWrappedLoggerUntilSet();
+    void Test_Lifecycle_LeavesTheWrappedLoggerAlone();
+    void Test_MultiLog_CategoryLevelReplacesOnlyTheCompositeLevel();
+    void Test_Nesting_JoinsNamesAndInheritsLevels();
+    void Test_SetEnabled_SilencesOnlyTheCategory();
+    void Test_SetMinimumLevel_OffSilencesAllButForcedEntries();
+    void Test_SetMinimumLevel_ReplacesTheWrappedLoggersLevel();
+    void Test_ShouldLog_MatchesWhatIsWritten();
+    void Test_Write_KeepsACategoryAlreadySet();
+    void Test_Write_StampsTheNameAndOwnLevel();
+
+public:
+    TTest_ASWLog_CategoryLog();
+    ~TTest_ASWLog_CategoryLog() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_CategoryLogH
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 6aaa48e..0a2d15c 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -93,6 +93,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     CheckEquals(ASWLog::TimePrecision::Milliseconds, config.Line.TimestampPrecision, "Line.TimestampPrecision should default to Milliseconds");
     CheckTrue(config.Line.ShowTimestamp, "Line.ShowTimestamp should default to true");
     CheckTrue(config.Line.ShowLevel, "Line.ShowLevel should default to true");
+    CheckTrue(config.Line.ShowCategory, "Line.ShowCategory should default to true");
     CheckTrue(config.Line.ShowProcessId, "Line.ShowProcessId should default to true");
     CheckTrue(config.Line.ShowThreadId, "Line.ShowThreadId should default to true");
     CheckFalse(config.Line.ShowWorkingSet, "Line.ShowWorkingSet should default to false");
diff --git a/tests/tests/Test_ASWLog_CrashHandler.cpp b/tests/tests/Test_ASWLog_CrashHandler.cpp
index 775d850..8d9ae1b 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.cpp
+++ b/tests/tests/Test_ASWLog_CrashHandler.cpp
@@ -519,6 +519,7 @@ TTest_ASWLog_CrashHandler::TTest_ASWLog_CrashHandler()
     : inherited("ASWLog_CrashHandler_Tests")
 {
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding, "AppendCrashLine_CutsALongMessageButKeepsTheEnding");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheCategory, "AppendCrashLine_ShowsTheCategory");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_UsesTheFixedLayout, "AppendCrashLine_UsesTheFixedLayout");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_CrashProcess_AbortWritesTheCrashLine, "CrashProcess_AbortWritesTheCrashLine");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_CrashProcess_AsyncQueueIsWrittenBeforeTheCrashLine, "CrashProcess_AsyncQueueIsWrittenBeforeTheCrashLine");
@@ -615,6 +616,27 @@ void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_UsesTheFixedLayout()
         "The time should be written like the formatter writes it");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheCategory()
+{
+    // Arrange: a backtrace entry from a category, as a crash handler writes it in the fixed layout
+    using namespace std::chrono;
+    ASWLog::TASWLogRecord record;
+    record.Timestamp = sys_days{ year{ 2026 } / 10 / 8 } + hours(1) + minutes(2) + seconds(3) + milliseconds(4);
+    record.LogLevel = ASWLog::Level::Debug;
+    record.Category = "Net.Http";
+    record.Message = "kept";
+    record.ProcessId = 12;
+    record.ThreadId = 345;
+
+    // Act
+    ASWLog::Detail::TCrashText line;
+    ASWLog::Detail::AppendCrashLine(line, record, false);
+
+    // Assert
+    CheckEquals(std::string("[2026-10-08T01:02:03.004Z][DEBUG][Net.Http][P:12][T:345]: kept\n"), std::string(line.View()),
+        "The category should follow the level, as in the built-in layout");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_CrashProcess_AbortWritesTheCrashLine()
 {
     // Act
diff --git a/tests/tests/Test_ASWLog_CrashHandler.h b/tests/tests/Test_ASWLog_CrashHandler.h
index 869d865..8be103a 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.h
+++ b/tests/tests/Test_ASWLog_CrashHandler.h
@@ -41,6 +41,7 @@ class TTest_ASWLog_CrashHandler : public TTestGroupBase
 
 private: // Test methods
     void Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding();
+    void Test_AppendCrashLine_ShowsTheCategory();
     void Test_AppendCrashLine_UsesTheFixedLayout();
     void Test_CrashProcess_AbortWritesTheCrashLine();
     void Test_CrashProcess_AsyncQueueIsWrittenBeforeTheCrashLine();
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index 49219ab..22adaa5 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -171,6 +171,7 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
 {
     RegisterTest(&TTest_ASWLog_Formatter::Test_Format_MatchesFormatLine, "Format_MatchesFormatLine");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_AllFieldsInOrder, "FormatLine_AllFieldsInOrder");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_CategoryOnlyWhenSetAndShown, "FormatLine_CategoryOnlyWhenSetAndShown");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_LargestIdsAndEachLevel, "FormatLine_LargestIdsAndEachLevel");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_MemoryFields, "FormatLine_MemoryFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_NoFields, "FormatLine_NoFields");
@@ -238,17 +239,39 @@ void TTest_ASWLog_Formatter::Test_FormatLine_AllFieldsInOrder()
     config.Line.ShowFunctionName = true;
     config.Line.ShowSourceLine = true;
     const auto location = std::source_location::current();
-    const auto record = MakeRecord("all fields", location);
+    auto record = MakeRecord("all fields", location);
+    record.Category = "Net";
 
     // Act
     const auto line = ASWLog::TASWTextFormatter::FormatLine(record, config);
 
     // Assert
-    const auto expected = std::format("[2026-09-21T14:13:20.123Z][WARN][P:1234][T:5678][{}][{}:{}]: all fields",
+    const auto expected = std::format("[2026-09-21T14:13:20.123Z][WARN][Net][P:1234][T:5678][{}][{}:{}]: all fields",
         location.function_name(), std::filesystem::path(location.file_name()).filename().string(), location.line());
     CheckEquals(expected, line, "Each field should be written from the record, in the documented order");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_FormatLine_CategoryOnlyWhenSetAndShown()
+{
+    // Arrange: the level and the category only
+    auto config = MakeConfigWithoutFields("unused.log");
+    config.Line.ShowLevel = true;
+    auto categorized = MakeRecord("categorized");
+    categorized.Category = "Net.Http";
+    const auto uncategorized = MakeRecord("uncategorized");
+
+    // Act
+    const auto categorizedLine = ASWLog::TASWTextFormatter::FormatLine(categorized, config);
+    const auto uncategorizedLine = ASWLog::TASWTextFormatter::FormatLine(uncategorized, config);
+    config.Line.ShowCategory = false;
+    const auto hiddenLine = ASWLog::TASWTextFormatter::FormatLine(categorized, config);
+
+    // Assert
+    CheckEquals(std::string("[WARN][Net.Http]: categorized"), categorizedLine, "The category should follow the level");
+    CheckEquals(std::string("[WARN]: uncategorized"), uncategorizedLine, "An entry without a category should show no field for it");
+    CheckEquals(std::string("[WARN]: categorized"), hiddenLine, "ShowCategory false should hide the category");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_FormatLine_LargestIdsAndEachLevel()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_Formatter.h b/tests/tests/Test_ASWLog_Formatter.h
index 55e6495..b9b93e4 100644
--- a/tests/tests/Test_ASWLog_Formatter.h
+++ b/tests/tests/Test_ASWLog_Formatter.h
@@ -38,6 +38,7 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
 private: // Test methods
     void Test_Format_MatchesFormatLine();
     void Test_FormatLine_AllFieldsInOrder();
+    void Test_FormatLine_CategoryOnlyWhenSetAndShown();
     void Test_FormatLine_LargestIdsAndEachLevel();
     void Test_FormatLine_MemoryFields();
     void Test_FormatLine_NoFields();
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index a1fa5a9..e46a4c1 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -192,6 +192,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Base.h</DependentOn>
             <BuildOrder>2</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_CategoryLog.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_CategoryLog.h</DependentOn>
+            <BuildOrder>47</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_Config.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Config.h</DependentOn>
             <BuildOrder>3</BuildOrder>
@@ -240,6 +244,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_Base.h</DependentOn>
             <BuildOrder>27</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_CategoryLog.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_CategoryLog.h</DependentOn>
+            <BuildOrder>48</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_Config.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_Config.h</DependentOn>
             <BuildOrder>28</BuildOrder>

From 67319a512421ee0c18f61d3f8f2847183ab5df27 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Thu, 8 Oct 2026 06:59:54 -0700
Subject: [PATCH 06/38] Add a line pattern formatter

---
 ASWLog/ASWLog_Config.h                |   5 +-
 ASWLog/ASWLog_Formatter.cpp           | 344 ++++++++++++++++++++++++++
 ASWLog/ASWLog_Formatter.h             |  79 +++++-
 CHANGELOG.md                          |  14 ++
 README.md                             |   2 +
 tests/tests/Test_ASWLog_Formatter.cpp | 213 ++++++++++++++++
 tests/tests/Test_ASWLog_Formatter.h   |   8 +
 7 files changed, 662 insertions(+), 3 deletions(-)

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index e0d9b44..aa765ba 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -214,7 +214,8 @@ struct TASWFileConfig
 struct TASWLineConfig
 {
     // Formats each entry's line (not LogRaw entries). Empty: TASWTextFormatter's layout, from the Show* options below.
-    // One formatter can be shared by several loggers.
+    // For a layout of your own, assign a TASWPatternFormatter (e.g. "{time} {level:5} {message}") or your own
+    // formatter. One formatter can be shared by several loggers.
     std::shared_ptr<const IASWLogFormatter> Formatter;
     LineEnding Ending = LineEnding::LF; // Added after each line (not after LogRaw entries)
 
@@ -226,7 +227,7 @@ struct TASWLineConfig
     TimeZone TimestampZone = TimeZone::UTC;
     TimePrecision TimestampPrecision = TimePrecision::Milliseconds;
 
-    // The fields TASWTextFormatter writes before the message
+    // The fields TASWTextFormatter writes before the message (a TASWPatternFormatter's pattern decides its own)
     bool ShowTimestamp      = true; // The entry's time (see TimestampZone and TimestampPrecision)
     bool ShowLevel          = true;
     bool ShowCategory       = true; // The entry's category, if it has one (see TASWCategoryLog)
diff --git a/ASWLog/ASWLog_Formatter.cpp b/ASWLog/ASWLog_Formatter.cpp
index fd8d855..66a682f 100644
--- a/ASWLog/ASWLog_Formatter.cpp
+++ b/ASWLog/ASWLog_Formatter.cpp
@@ -25,12 +25,15 @@ limitations under the License.
 #include "ASWLog_Formatter.h"
 //---------------------------------------------------------------------------
 // System includes here
+#include <algorithm>
 #include <charconv>
 #include <cstdint>
 #include <filesystem>
 #include <format>
 #include <iterator>
+#include <stdexcept>
 #include <string_view>
+#include <utility>
 //---------------------------------------------------------------------------
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
@@ -41,10 +44,42 @@ namespace ASWLog
 namespace
 {
 
+// The widest placeholder width a pattern may ask for
+constexpr std::size_t MaxPatternWidth = 1000;
+
+//---------------------------------------------------------------------------
+
+void AppendField(std::string& line, std::string_view value, std::string_view prefix, std::string_view suffix,
+    std::size_t width);
 void AppendNumberField(std::string& line, std::string_view label, std::uint64_t value);
+bool IsASCIIDigit(char character) noexcept;
+bool IsASCIILetter(char character) noexcept;
+std::invalid_argument MakePatternError(std::string_view problem, std::size_t index, std::string_view pattern);
+std::string_view ToDecimal(char (& buffer)[Time::ISO8601BufferSize], std::uint64_t value) noexcept;
 
 //---------------------------------------------------------------------------
 
+/*
+  AppendField
+
+  Appends a pattern's field: nothing if 'value' is empty, else the prefix, the value padded with spaces on the right
+  to 'width', and the suffix
+*/
+void AppendField(std::string& line, std::string_view value, std::string_view prefix, std::string_view suffix,
+    std::size_t width)
+{
+    if (value.empty())
+        return;
+
+    line.append(prefix);
+    line.append(value);
+
+    if (value.size() < width)
+        line.append(width - value.size(), ' ');
+
+    line.append(suffix);
+}
+
 /*
   AppendNumberField
 
@@ -61,10 +96,319 @@ void AppendNumberField(std::string& line, std::string_view label, std::uint64_t
     line += ']';
 }
 
+/*
+  IsASCIIDigit
+
+  True for '0' to '9' (unlike std::isdigit, whatever the C locale)
+*/
+bool IsASCIIDigit(char character) noexcept
+{
+    return character >= '0' && character <= '9';
+}
+
+/*
+  IsASCIILetter
+
+  True for 'a' to 'z' and 'A' to 'Z' (unlike std::isalpha, whatever the C locale)
+*/
+bool IsASCIILetter(char character) noexcept
+{
+    return (character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z');
+}
+
+/*
+  MakePatternError
+
+  The exception for an invalid line pattern: the problem, where it is, and the pattern
+*/
+std::invalid_argument MakePatternError(std::string_view problem, std::size_t index, std::string_view pattern)
+{
+    return std::invalid_argument(std::format("{} at index {} of the line pattern \"{}\"", problem, index, pattern));
+}
+
+/*
+  ToDecimal
+
+  Writes 'value' in decimal into 'buffer' and returns the digits
+*/
+std::string_view ToDecimal(char (& buffer)[Time::ISO8601BufferSize], std::uint64_t value) noexcept
+{
+    static_assert(Time::ISO8601BufferSize >= 20, "The buffer must hold the largest 64-bit number");
+    const auto result = std::to_chars(buffer, buffer + Time::ISO8601BufferSize, value);
+    return std::string_view(buffer, static_cast<std::size_t>(result.ptr - buffer));
+}
+
 } // namespace
 
 //---------------------------------------------------------------------------
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWPatternFormatter
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWPatternFormatter::TASWPatternFormatter(std::string_view pattern)
+    : m_Pattern(pattern)
+{
+    std::string text; // Literal text since the last placeholder
+    std::size_t index = 0;
+
+    while (index < pattern.size())
+    {
+        const char character = pattern[index];
+        const bool isDoubled = index + 1 < pattern.size() && pattern[index + 1] == character;
+        if ((character == '{' || character == '}') && isDoubled)
+        {
+            text += character;
+            index += 2;
+        }
+        else if (character == '{')
+        {
+            if (!text.empty())
+            {
+                m_Parts.push_back(TPart{ TField::Text, 0, std::move(text), {} });
+                text.clear();
+            }
+
+            index = ParsePlaceholder(index);
+        }
+        else if (character == '}')
+        {
+            throw MakePatternError("Unmatched '}'", index, pattern);
+        }
+        else
+        {
+            text += character;
+            ++index;
+        }
+    }
+
+    if (!text.empty())
+        m_Parts.push_back(TPart{ TField::Text, 0, std::move(text), {} });
+}
+
+//---------------------------------------------------------------------------
+std::string TASWPatternFormatter::Format(const TASWLogRecord& record, const TASWLogConfig& config) const
+{
+    std::string line;
+    line.reserve(record.Message.size() + 256);
+
+    const TMemoryUsage memoryUsage = m_UsesMemoryUsage ? GetMemoryUsage() : TMemoryUsage{};
+    std::string fileName;
+
+    for (const auto& part : m_Parts)
+    {
+        char buffer[Time::ISO8601BufferSize];
+        std::string_view value;
+
+        switch (part.Field)
+        {
+            case TField::Text:
+                line.append(part.Prefix);
+                continue;
+
+            case TField::Time:
+                value = std::string_view(buffer, Time::WriteISO8601(buffer, record.Timestamp, config.Line.TimestampZone,
+                    config.Line.TimestampPrecision));
+                break;
+
+            case TField::Level:
+                value = Level_ToString(record.LogLevel);
+                break;
+
+            case TField::Category:
+                value = record.Category;
+                break;
+
+            case TField::ProcessId:
+                value = ToDecimal(buffer, record.ProcessId);
+                break;
+
+            case TField::ThreadId:
+                value = ToDecimal(buffer, record.ThreadId);
+                break;
+
+            case TField::WorkingSet:
+                value = ToDecimal(buffer, memoryUsage.WorkingSetBytes);
+                break;
+
+            case TField::PeakWorkingSet:
+                value = ToDecimal(buffer, memoryUsage.PeakWorkingSetBytes);
+                break;
+
+            case TField::Function:
+                value = record.Location.function_name();
+                break;
+
+            case TField::File:
+                // As TASWTextFormatter writes it
+                fileName = std::filesystem::path(record.Location.file_name()).filename().string();
+                value = fileName;
+                break;
+
+            case TField::Line:
+                value = ToDecimal(buffer, record.Location.line());
+                break;
+
+            case TField::Message:
+                value = record.Message;
+                break;
+        }
+
+        AppendField(line, value, part.Prefix, part.Suffix, part.Width);
+    }
+
+    return line;
+}
+
+//---------------------------------------------------------------------------
+std::string_view TASWPatternFormatter::GetPattern() const noexcept
+{
+    return m_Pattern;
+}
+
+//---------------------------------------------------------------------------
+/*
+    TASWPatternFormatter::ParsePlaceholder
+
+    Parses the placeholder whose '{' is at 'start' in m_Pattern, adds it to m_Parts, and returns the index after its
+    '}'. Inside the braces: the affix before the name, the name, an optional ":<width>", and the affix after it. An
+    affix is punctuation and spaces, or text in single quotes ('' for a quote), in any mix; spaces next to quoted text
+    only separate it from the rest and aren't part of the affix.
+*/
+std::size_t TASWPatternFormatter::ParsePlaceholder(std::size_t start)
+{
+    struct TName
+    {
+        std::string_view Name;
+        TField Field;
+    };
+
+    static constexpr TName Names[] = {
+        { "time", TField::Time }, { "level", TField::Level }, { "category", TField::Category },
+        { "pid", TField::ProcessId }, { "tid", TField::ThreadId }, { "ws", TField::WorkingSet },
+        { "pws", TField::PeakWorkingSet }, { "function", TField::Function }, { "file", TField::File },
+        { "line", TField::Line }, { "message", TField::Message }
+    };
+
+    const std::string_view pattern = m_Pattern;
+    TPart part;
+    std::string* affix = &part.Prefix;
+    bool hasName = false;
+    bool isAfterQuote = false; // Unquoted spaces right after quoted text separate it from what follows
+    std::size_t unquotedSpaces = 0; // How many unquoted spaces end the affix; dropped if quoted text follows
+    std::size_t index = start + 1;
+
+    while (true)
+    {
+        if (index >= pattern.size())
+            throw MakePatternError("Unclosed '{'", start, pattern);
+
+        const char character = pattern[index];
+        if (character == '}')
+            break;
+
+        if (character == '\'')
+        {
+            affix->resize(affix->size() - unquotedSpaces);
+            unquotedSpaces = 0;
+            const std::size_t quoteStart = index++;
+
+            while (true)
+            {
+                if (index >= pattern.size())
+                    throw MakePatternError("Unclosed quote", quoteStart, pattern);
+
+                if (pattern[index] == '\'')
+                {
+                    if (index + 1 < pattern.size() && pattern[index + 1] == '\'')
+                    {
+                        *affix += '\'';
+                        index += 2;
+                        continue;
+                    }
+
+                    ++index;
+                    break;
+                }
+
+                *affix += pattern[index++];
+            }
+
+            isAfterQuote = true;
+        }
+        else if (character == ' ' && isAfterQuote)
+        {
+            ++index;
+        }
+        else if (IsASCIILetter(character))
+        {
+            isAfterQuote = false;
+            unquotedSpaces = 0;
+
+            if (hasName)
+                throw MakePatternError("Letters around a placeholder name must be in quotes", index, pattern);
+
+            const std::size_t nameStart = index;
+
+            while (index < pattern.size() && IsASCIILetter(pattern[index]))
+                ++index;
+
+            const auto name = pattern.substr(nameStart, index - nameStart);
+            const auto* found = std::find_if(std::begin(Names), std::end(Names), [name](const TName& entry) {
+                    return entry.Name == name;
+                });
+            if (found == std::end(Names))
+                throw MakePatternError(std::format("Unknown placeholder name '{}'", name), nameStart, pattern);
+
+            part.Field = found->Field;
+            hasName = true;
+            affix = &part.Suffix;
+
+            if (index < pattern.size() && pattern[index] == ':')
+            {
+                const std::size_t widthStart = ++index;
+                std::size_t width = 0;
+
+                while (index < pattern.size() && IsASCIIDigit(pattern[index]) && width <= MaxPatternWidth)
+                    width = width * 10 + static_cast<std::size_t>(pattern[index++] - '0');
+
+                if (index == widthStart || width == 0 || width > MaxPatternWidth)
+                {
+                    const auto problem = std::format("A width must be 1 to {}", MaxPatternWidth);
+                    throw MakePatternError(problem, widthStart, pattern);
+                }
+
+                part.Width = width;
+            }
+        }
+        else if (IsASCIIDigit(character) || character == ':' || character == '{')
+        {
+            throw MakePatternError(std::format("'{}' around a placeholder name must be in quotes", character), index,
+                pattern);
+        }
+        else
+        {
+            isAfterQuote = false;
+            unquotedSpaces = character == ' ' ? unquotedSpaces + 1 : 0;
+            *affix += character;
+            ++index;
+        }
+    }
+
+    if (!hasName)
+        throw MakePatternError("Missing placeholder name", start, pattern);
+
+    if (part.Field == TField::WorkingSet || part.Field == TField::PeakWorkingSet)
+        m_UsesMemoryUsage = true;
+
+    m_Parts.push_back(std::move(part));
+
+    return index + 1;
+}
+
+//---------------------------------------------------------------------------
+
 /////////////////////////////////////////////////////////////////////////////
 // TASWTextFormatter
 /////////////////////////////////////////////////////////////////////////////
diff --git a/ASWLog/ASWLog_Formatter.h b/ASWLog/ASWLog_Formatter.h
index 7b4984e..59b787d 100644
--- a/ASWLog/ASWLog_Formatter.h
+++ b/ASWLog/ASWLog_Formatter.h
@@ -29,7 +29,11 @@ limitations under the License.
 #ifndef ASWLog_FormatterH
 #define ASWLog_FormatterH
 //---------------------------------------------------------------------------
+#include <cstddef>
+#include <cstdint>
 #include <string>
+#include <string_view>
+#include <vector>
 //---------------------------------------------------------------------------
 #include "ASWLog_Config.h"
 #include "ASWLog_Types.h"
@@ -61,6 +65,79 @@ class IASWLogFormatter
 };
 
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWPatternFormatter
+//
+// A line layout given as a pattern, parsed once when the formatter is made:
+//     const auto pattern = "{time} {level:5} {[category] }{message}";
+//     config.Line.Formatter = std::make_shared<const ASWLog::TASWPatternFormatter>(pattern);
+// writes "2026-10-08T14:31:00.217Z DEBUG [Net] connected". Text outside braces is written as is; "{{" and "}}" write a
+// brace. Each placeholder writes one field of the entry:
+//   {time}          the timestamp, in TASWLineConfig::TimestampZone and TimestampPrecision
+//   {level}         TRACE, DEBUG, INFO, WARN, ERROR or CRITICAL
+//   {category}      the category's name, e.g. Net.Http (see TASWCategoryLog), or nothing
+//   {pid}, {tid}    the process and thread ids
+//   {ws}, {pws}     the process's working set and peak working set in bytes (the memory is read once per line)
+//   {function}      the function that logged the entry
+//   {file}, {line}  its source file's name (without folders) and line
+//   {message}       the message
+// A minimum width after the name, e.g. {level:5}, pads the field with spaces on the right (counted in bytes). Text
+// inside the braces around the name is written only when the field isn't empty: punctuation and spaces as they are,
+// e.g. {[category] }, or anything in single quotes, with '' for a quote, e.g. {'cat=' category ' '}; letters, digits,
+// braces and ':' need the quotes. Spaces next to quoted text only separate it from the name and aren't written. An
+// empty field writes nothing at all, not even its width's padding.
+//
+// Unlike TASWTextFormatter, it ignores TASWLineConfig's Show* options: the pattern decides which fields are written.
+// The logger adds the line ending (TASWLineConfig::Ending). Thread-safe, so loggers can share one.
+/////////////////////////////////////////////////////////////////////////////
+class TASWPatternFormatter : public IASWLogFormatter
+{
+private:
+    // What a part of the pattern writes
+    enum class TField : std::uint8_t
+    {
+        Text, // Literal text
+        Time,
+        Level,
+        Category,
+        ProcessId,
+        ThreadId,
+        WorkingSet,
+        PeakWorkingSet,
+        Function,
+        File,
+        Line,
+        Message,
+    };
+
+    // A part of the pattern: literal text (in Prefix), or a placeholder's field with its affixes and minimum width
+    struct TPart
+    {
+        TField Field = TField::Text;
+        std::size_t Width = 0;
+        std::string Prefix;
+        std::string Suffix;
+    };
+
+    std::string m_Pattern;
+    std::vector<TPart> m_Parts;
+    bool m_UsesMemoryUsage = false; // Has {ws} or {pws}
+
+private:
+    std::size_t ParsePlaceholder(std::size_t start);
+
+public:
+    // Throws std::invalid_argument if 'pattern' is invalid (e.g. an unknown placeholder, or an unclosed brace or
+    // quote), naming the problem and its index in the pattern
+    explicit TASWPatternFormatter(std::string_view pattern);
+
+    [[nodiscard]] std::string Format(const TASWLogRecord& record, const TASWLogConfig& config) const override;
+
+    // The pattern it was made with
+    [[nodiscard]] std::string_view GetPattern() const noexcept;
+};
+
+
 /////////////////////////////////////////////////////////////////////////////
 // TASWTextFormatter
 //
@@ -68,7 +145,7 @@ class IASWLogFormatter
 // "[time][LEVEL][category][P:pid][T:tid][WS:bytes][PWS:bytes][function][file:line]: message", where each bracketed
 // field is written only if its TASWLineConfig option is on (ShowTimestamp, ShowLevel, ShowCategory, ShowProcessId,
 // ShowThreadId, ShowWorkingSet, ShowPeakWorkingSet, ShowFunctionName, ShowSourceLine), and the category only if the
-// entry has one.
+// entry has one. For another layout, see TASWPatternFormatter.
 /////////////////////////////////////////////////////////////////////////////
 class TASWTextFormatter : public IASWLogFormatter
 {
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f30a6af..6382771 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -51,6 +51,20 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   it), which tells a category whether an entry with its level would be
   written. `TASWLogRecord`'s `Raw` and `Forced` now come right after
   `LogLevel`, so designated initializers must follow the new order.
+- Line patterns: `TASWPatternFormatter` writes each line from a pattern,
+  e.g. `config.Line.Formatter = std::make_shared<const ASWLog::TASWPatternFormatter>("{time} {level:5} {[category] }{message}");`
+  for `2026-10-08T14:31:00.217Z DEBUG [Net] connected`. The placeholders are
+  `{time}` (in `Line.TimestampZone` and `Line.TimestampPrecision`),
+  `{level}`, `{category}`, `{pid}`, `{tid}`, `{ws}`, `{pws}`, `{function}`,
+  `{file}` (the name without folders), `{line}` and `{message}`; `{{` and
+  `}}` write a brace. `{level:5}` pads a field to a minimum width. Text
+  inside the braces around the name is written only when the field isn't
+  empty: punctuation and spaces as they are (`{[category] }`), anything else
+  in single quotes, with `''` for a quote (`{'cat=' category ' '}`). The
+  pattern is parsed once, when the formatter is made, and an invalid one
+  throws `std::invalid_argument` naming the problem and where it is. The
+  `Line.Show*` options don't apply to a pattern, and the logger still adds
+  `Line.Ending` after each line.
 
 ### Changed
 
diff --git a/README.md b/README.md
index 22ddb2d..a1e4a9b 100644
--- a/README.md
+++ b/README.md
@@ -37,6 +37,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
 - Backup cleanup after each rotation, by age, count and total size, plus wildcard-based cleanup of files older than a
   specified age (`TASWFileLog::DeleteOldLogs()`). An event for each new backup (`File.OnBackupCreated`) lets the
   application compress, upload or move it.
+- Your own line layout as a pattern, e.g. `"{time} {level:5} {[category] }{message}"` (`ASWLog::TASWPatternFormatter`,
+  assigned to `TASWLogConfig::Line.Formatter`).
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
   or derive a new text logger from `TASWTextLogBase` and implement only its output.
 
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index 22adaa5..0ca5d0a 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -35,12 +35,15 @@ limitations under the License.
 #include <limits>
 #include <memory>
 #include <source_location>
+#include <stdexcept>
 #include <string>
+#include <string_view>
 #include <thread>
 #include <vector>
 //---------------------------------------------------------------------------
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
+#include "ASWLog_CategoryLog.h"
 #include "ASWLog_FileLog.h"
 #include "ASWLog_Formatter.h"
 #include "ASWLog_Utils.h"
@@ -178,6 +181,14 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_TimestampFollowsZoneAndPrecision, "FormatLine_TimestampFollowsZoneAndPrecision");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread, "Formatter_ReceivesRecordFromLoggingThread");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_SharedByTwoLoggers, "Formatter_SharedByTwoLoggers");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_AffixesOnlyAroundAValue, "PatternFormatter_AffixesOnlyAroundAValue");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_BracesAndPlainText, "PatternFormatter_BracesAndPlainText");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_DefaultLayoutMatchesTextFormatter, "PatternFormatter_DefaultLayoutMatchesTextFormatter");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_EachPlaceholder, "PatternFormatter_EachPlaceholder");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_FileLoggerWritesItsLines, "PatternFormatter_FileLoggerWritesItsLines");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_InvalidPatternThrows, "PatternFormatter_InvalidPatternThrows");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_MemoryFields, "PatternFormatter_MemoryFields");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_WidthPadsShortValues, "PatternFormatter_WidthPadsShortValues");
 }
 //---------------------------------------------------------------------------
 TTest_ASWLog_Formatter::~TTest_ASWLog_Formatter()
@@ -417,6 +428,208 @@ void TTest_ASWLog_Formatter::Test_Formatter_SharedByTwoLoggers()
         "Logger B's file should have its 100 lines in the shared format");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_AffixesOnlyAroundAValue()
+{
+    // Arrange: one record with a category and a function, one without (a default source location has empty names)
+    auto withValues = MakeRecord("msg");
+    withValues.Category = "Net";
+    auto withoutValues = MakeRecord("msg");
+    withoutValues.Location = std::source_location();
+    const ASWLog::TASWLogConfig config;
+
+    const auto formatBoth = [&](std::string_view pattern) {
+            const ASWLog::TASWPatternFormatter formatter(pattern);
+            return std::format("{}|{}", formatter.Format(withValues, config), formatter.Format(withoutValues, config));
+        };
+
+    // Act & Assert
+    CheckEquals(std::string("[Net] msg|msg"), formatBoth("{[category] }{message}"), "Unquoted punctuation and spaces should be written only with a value");
+    CheckEquals(std::string("cat=Net msg|msg"), formatBoth("{'cat=' category ' '}{message}"), "Quoted text should be written only with a value");
+    CheckEquals(std::string("it's Net|"), formatBoth("{'it''s ' category}"), "'' should write a quote inside quoted text");
+    CheckEquals(std::string("[cat:Net] msg|msg"), formatBoth("{['cat:'category] }{message}"), "Quoted and unquoted text should mix");
+    CheckEquals(std::string("Net | msg|msg"), formatBoth("{category ' | '}{message}"), "Spaces next to quoted text should only separate it");
+    CheckEquals(std::string(" | Net msg|msg"), formatBoth("{ | category }{message}"), "Unquoted spaces away from quotes should be written");
+    CheckEquals(std::format("({}) msg|msg", withValues.Location.function_name()), formatBoth("{(function) }{message}"),
+        "A field without a value, like an empty function name, should write nothing at all");
+    CheckEquals(std::string("[Net]msg|[]msg"), formatBoth("[{category}]{message}"), "Text outside the braces should always be written");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_BracesAndPlainText()
+{
+    // Arrange
+    const ASWLog::TASWLogConfig config;
+    const auto record = MakeRecord("msg");
+
+    // Act
+    const auto escaped = ASWLog::TASWPatternFormatter("{{{level}}} }} {{").Format(record, config);
+    const auto plain = ASWLog::TASWPatternFormatter("plain text").Format(record, config);
+    const auto empty = ASWLog::TASWPatternFormatter("").Format(record, config);
+
+    // Assert
+    CheckEquals(std::string("{WARN} } {"), escaped, "{{ and }} should write a brace");
+    CheckEquals(std::string("plain text"), plain, "A pattern without placeholders should write its text");
+    CheckEmpty(empty, "An empty pattern should write an empty line");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_DefaultLayoutMatchesTextFormatter()
+{
+    // Arrange: the patterns spelling the built-in layout, with the default fields and with every field but memory use
+    const ASWLog::TASWPatternFormatter defaultFields("[{time}][{level}]{[category]}[P:{pid}][T:{tid}]: {message}");
+    const ASWLog::TASWPatternFormatter allFields("[{time}][{level}]{[category]}[P:{pid}][T:{tid}][{function}][{file}:{line}]: {message}");
+
+    ASWLog::TASWLogConfig defaultConfig;
+    ASWLog::TASWLogConfig localConfig;
+    localConfig.Line.TimestampZone = ASWLog::TimeZone::Local;
+    localConfig.Line.TimestampPrecision = ASWLog::TimePrecision::Microseconds;
+    ASWLog::TASWLogConfig allConfig;
+    allConfig.Line.ShowFunctionName = true;
+    allConfig.Line.ShowSourceLine = true;
+
+    std::vector<ASWLog::TASWLogRecord> records;
+
+    for (int level = 0; level < static_cast<int>(ASWLog::LevelCount); ++level)
+    {
+        auto record = MakeRecord("entry");
+        record.LogLevel = static_cast<ASWLog::Level>(level);
+        records.push_back(record);
+    }
+
+    auto categorized = MakeRecord("categorized");
+    categorized.Category = "Net.Http";
+    records.push_back(categorized);
+    auto largestIds = MakeRecord("largest ids");
+    largestIds.ProcessId = 4294967295;
+    largestIds.ThreadId = 0;
+    records.push_back(largestIds);
+
+    // Act & Assert
+    for (const auto& record : records)
+    {
+        const auto what = std::format(" ({} {})", ASWLog::Level_ToString(record.LogLevel), record.Message);
+        CheckEquals(ASWLog::TASWTextFormatter::FormatLine(record, defaultConfig), defaultFields.Format(record, defaultConfig),
+            "The default layout's pattern should write the same line" + what);
+        CheckEquals(ASWLog::TASWTextFormatter::FormatLine(record, localConfig), defaultFields.Format(record, localConfig),
+            "{time} should follow the configured zone and precision, as the default layout does" + what);
+        CheckEquals(ASWLog::TASWTextFormatter::FormatLine(record, allConfig), allFields.Format(record, allConfig),
+            "The pattern with the function and source line should write the same line" + what);
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_EachPlaceholder()
+{
+    // Arrange
+    const std::string pattern = "{time}|{level}|{category}|{pid}|{tid}|{function}|{file}|{line}|{message}";
+    const ASWLog::TASWPatternFormatter formatter(pattern);
+    const auto location = std::source_location::current();
+    auto record = MakeRecord("the message", location);
+    record.Category = "Net";
+
+    // Act
+    const auto line = formatter.Format(record, ASWLog::TASWLogConfig());
+
+    // Assert
+    const auto expected = std::format("2026-09-21T14:13:20.123Z|WARN|Net|1234|5678|{}|{}|{}|the message", location.function_name(),
+        std::filesystem::path(location.file_name()).filename().string(), location.line());
+    CheckEquals(expected, line, "Each placeholder should write its field");
+    CheckEquals(pattern, std::string(formatter.GetPattern()), "GetPattern should return the pattern");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_FileLoggerWritesItsLines()
+{
+    // Arrange: CRLF, so the line ending shows that the logger still adds it
+    auto config = MakeConfigWithoutFields("pattern.log");
+    config.Line.Ending = ASWLog::LineEnding::CRLF;
+    config.Line.ShowLevel = true; // Ignored by the pattern
+    config.Line.Formatter = std::make_shared<const ASWLog::TASWPatternFormatter>("{level:5} {[category] }{message}");
+    ASWLog::TASWFileLog logger;
+    const bool initialized = logger.Initialize(config);
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+
+    // Act
+    netLog.LogWarn("from_net");
+    logger.LogInfo("plain");
+    logger.LogRaw(ASWLog::Level::Info, "raw\n");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(std::string("WARN  [Net] from_net\r\nINFO  plain\r\nraw\n"), ReadFileText(TestTempDir / "pattern.log"),
+        "Each line should follow the pattern, then the line ending; a raw entry is written as is");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_InvalidPatternThrows()
+{
+    // Arrange: each pattern, and the start of the error message it should give
+    struct TCase
+    {
+        std::string Pattern;
+        std::string Error;
+    };
+
+    const std::vector<TCase> cases{
+        { "{time} {lvl}", "Unknown placeholder name 'lvl' at index 8 of the line pattern \"{time} {lvl}\"" },
+        { "{time", "Unclosed '{' at index 0" },
+        { "[{level]", "Unclosed '{' at index 1" },
+        { "a } b", "Unmatched '}' at index 2" },
+        { "{{level}", "Unmatched '}' at index 7" },
+        { "{'x category}", "Unclosed quote at index 1" },
+        { "{}", "Missing placeholder name at index 0" },
+        { "{ [ ] }", "Missing placeholder name at index 0" },
+        { "{category x}", "Letters around a placeholder name must be in quotes at index 10" },
+        { "{level level}", "Letters around a placeholder name must be in quotes at index 7" },
+        { "{2 level}", "'2' around a placeholder name must be in quotes at index 1" },
+        { "{a{level}", "Unknown placeholder name 'a' at index 1" },
+        { "{[{level}", "'{' around a placeholder name must be in quotes at index 2" },
+        { "{:level}", "':' around a placeholder name must be in quotes at index 1" },
+        { "{level:}", "A width must be 1 to 1000 at index 7" },
+        { "{level:0}", "A width must be 1 to 1000 at index 7" },
+        { "{level:1001}", "A width must be 1 to 1000 at index 7" },
+        { "{level:99999999999999999999}", "A width must be 1 to 1000 at index 7" }
+    };
+
+    // Act & Assert
+    for (const auto& testCase : cases)
+    {
+        CheckThrows<std::invalid_argument>([&] {
+                [[maybe_unused]] const ASWLog::TASWPatternFormatter formatter(testCase.Pattern);
+            }, "The pattern " + testCase.Pattern + " should be rejected", testCase.Error);
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_MemoryFields()
+{
+    // Arrange
+    const ASWLog::TASWPatternFormatter formatter("{ws} {pws}: {message}");
+
+    // Act
+    const auto line = formatter.Format(MakeRecord("memory"), ASWLog::TASWLogConfig());
+
+    // Assert
+    CheckMatches(line, "[1-9][0-9]* [1-9][0-9]*: memory", "The working set and peak working set should be read, as decimal numbers");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_WidthPadsShortValues()
+{
+    // Arrange
+    const ASWLog::TASWLogConfig config;
+    const ASWLog::TASWPatternFormatter padded("{level:5}|");
+    const ASWLog::TASWPatternFormatter withAffixes("{[level:6]}|");
+    const ASWLog::TASWPatternFormatter emptyField("{category:8}|");
+    auto info = MakeRecord("msg");
+    info.LogLevel = ASWLog::Level::Info;
+    auto error = MakeRecord("msg");
+    error.LogLevel = ASWLog::Level::Error;
+    auto critical = MakeRecord("msg");
+    critical.LogLevel = ASWLog::Level::Critical;
+
+    // Act & Assert
+    CheckEquals(std::string("INFO |"), padded.Format(info, config), "A shorter value should be padded on the right");
+    CheckEquals(std::string("ERROR|"), padded.Format(error, config), "A value of the width should be written as is");
+    CheckEquals(std::string("CRITICAL|"), padded.Format(critical, config), "A longer value should not be cut");
+    CheckEquals(std::string("[INFO  ]|"), withAffixes.Format(info, config), "The affixes should go around the padded value");
+    CheckEquals(std::string("|"), emptyField.Format(info, config), "An empty field should not be padded");
+}
+//---------------------------------------------------------------------------
 
 } // namespace ASWUnitTests
 
diff --git a/tests/tests/Test_ASWLog_Formatter.h b/tests/tests/Test_ASWLog_Formatter.h
index b9b93e4..53184b4 100644
--- a/tests/tests/Test_ASWLog_Formatter.h
+++ b/tests/tests/Test_ASWLog_Formatter.h
@@ -45,6 +45,14 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
     void Test_FormatLine_TimestampFollowsZoneAndPrecision();
     void Test_Formatter_ReceivesRecordFromLoggingThread();
     void Test_Formatter_SharedByTwoLoggers();
+    void Test_PatternFormatter_AffixesOnlyAroundAValue();
+    void Test_PatternFormatter_BracesAndPlainText();
+    void Test_PatternFormatter_DefaultLayoutMatchesTextFormatter();
+    void Test_PatternFormatter_EachPlaceholder();
+    void Test_PatternFormatter_FileLoggerWritesItsLines();
+    void Test_PatternFormatter_InvalidPatternThrows();
+    void Test_PatternFormatter_MemoryFields();
+    void Test_PatternFormatter_WidthPadsShortValues();
 
 public:
     TTest_ASWLog_Formatter();

From d7285dcec11ea5774f0924736fd8573b1b0fe263 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Thu, 8 Oct 2026 23:09:15 -0700
Subject: [PATCH 07/38] Update ASWUnitTests to 1.2.1

---
 third_party/asw-unit-tests | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/third_party/asw-unit-tests b/third_party/asw-unit-tests
index cb3b248..0304a70 160000
--- a/third_party/asw-unit-tests
+++ b/third_party/asw-unit-tests
@@ -1 +1 @@
-Subproject commit cb3b248f3bdcceb4a1962311accfdc41750b5414
+Subproject commit 0304a7095a41a14f725c45b31126bba201c42ca6

From f593a73ef5aab0777160307e27c960b58647e2e7 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Fri, 9 Oct 2026 00:43:07 -0700
Subject: [PATCH 08/38] Add a JSON Lines formatter

---
 ASWLog/ASWLog_Config.h                        |  12 +-
 ASWLog/ASWLog_CrashHandler.cpp                |  75 ++++
 ASWLog/ASWLog_CrashHandler.h                  |  19 +-
 ASWLog/ASWLog_Formatter.cpp                   | 113 ++++++
 ASWLog/ASWLog_Formatter.h                     |  46 ++-
 ASWLog/ASWLog_Interface.h                     |   3 +-
 ASWLog/ASWLog_TextLogBase.cpp                 |  56 ++-
 ASWLog/ASWLog_TextLogBase.h                   |   8 +-
 ASWLog/ASWLog_Types.h                         |   4 +-
 ASWLog/ASWLog_Utils.cpp                       | 225 ++++++++++++
 ASWLog/ASWLog_Utils.h                         |  39 +++
 CHANGELOG.md                                  |  18 +
 README.md                                     |   2 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   4 +
 tests/tests/Test_ASWLog_CrashHandler.cpp      | 217 ++++++++++--
 tests/tests/Test_ASWLog_CrashHandler.h        |   3 +
 tests/tests/Test_ASWLog_Formatter.cpp         | 179 ++++++++++
 tests/tests/Test_ASWLog_Formatter.h           |   6 +
 tests/tests/Test_ASWLog_TextLogBase.cpp       |  50 +++
 tests/tests/Test_ASWLog_TextLogBase.h         |   1 +
 tests/tests/Test_ASWLog_Utils.cpp             | 141 ++++++++
 tests/tests/Test_ASWLog_Utils.h               |   4 +
 tests/tests/UT_Helper_JSON.cpp                | 325 ++++++++++++++++++
 tests/tests/UT_Helper_JSON.h                  |  40 +++
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   4 +
 26 files changed, 1533 insertions(+), 62 deletions(-)
 create mode 100644 tests/tests/UT_Helper_JSON.cpp
 create mode 100644 tests/tests/UT_Helper_JSON.h

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index aa765ba..8f40655 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -213,11 +213,12 @@ struct TASWFileConfig
 /////////////////////////////////////////////////////////////////////////////
 struct TASWLineConfig
 {
-    // Formats each entry's line (not LogRaw entries). Empty: TASWTextFormatter's layout, from the Show* options below.
-    // For a layout of your own, assign a TASWPatternFormatter (e.g. "{time} {level:5} {message}") or your own
-    // formatter. One formatter can be shared by several loggers.
+    // Formats each entry's line (LogRaw entries only if the formatter says so, as TASWJSONFormatter does). Empty:
+    // TASWTextFormatter's layout, from the Show* options below. For a layout of your own, assign a TASWPatternFormatter
+    // (e.g. "{time} {level:5} {message}") or your own formatter; for JSON Lines, a TASWJSONFormatter. One formatter can
+    // be shared by several loggers.
     std::shared_ptr<const IASWLogFormatter> Formatter;
-    LineEnding Ending = LineEnding::LF; // Added after each line (not after LogRaw entries)
+    LineEnding Ending = LineEnding::LF; // Added after each formatted line (not after LogRaw entries written as is)
 
     // The clock and precision of the timestamps, e.g. 2026-09-28T21:02:44.342Z (the defaults) or, with
     // TimeZone::Local and TimePrecision::Microseconds, 2026-09-28T16:02:44.342519-05:00. The zone also sets when daily
@@ -227,7 +228,8 @@ struct TASWLineConfig
     TimeZone TimestampZone = TimeZone::UTC;
     TimePrecision TimestampPrecision = TimePrecision::Milliseconds;
 
-    // The fields TASWTextFormatter writes before the message (a TASWPatternFormatter's pattern decides its own)
+    // The fields TASWTextFormatter and TASWJSONFormatter write before the message (a TASWPatternFormatter's pattern
+    // decides its own)
     bool ShowTimestamp      = true; // The entry's time (see TimestampZone and TimestampPrecision)
     bool ShowLevel          = true;
     bool ShowCategory       = true; // The entry's category, if it has one (see TASWCategoryLog)
diff --git a/ASWLog/ASWLog_CrashHandler.cpp b/ASWLog/ASWLog_CrashHandler.cpp
index b4d6fbe..2b0d794 100644
--- a/ASWLog/ASWLog_CrashHandler.cpp
+++ b/ASWLog/ASWLog_CrashHandler.cpp
@@ -598,6 +598,42 @@ void TCrashText::AppendISO8601(std::chrono::system_clock::time_point time) noexc
     Append(std::string_view(buffer, Time::WriteISO8601(buffer, time)));
 }
 
+//---------------------------------------------------------------------------
+void TCrashText::AppendJSONString(std::string_view text, std::size_t reserved) noexcept
+{
+    // The text ends before the closing quote and 'reserved'
+    const std::size_t limit = Capacity - std::min(Capacity, reserved + 1);
+    char escape[6];
+    std::size_t index = 0;
+
+    Append("\"");
+
+    while (index < text.size())
+    {
+        const auto piece = NextJSONPiece(text, index, escape);
+        const std::size_t room = limit > m_Size ? limit - m_Size : 0;
+        if (piece.Text.size() <= room)
+        {
+            Append(piece.Text);
+            continue;
+        }
+
+        // A run of plain characters is cut between UTF-8 sequences; an escape or U+FFFD is left out whole
+        if (!piece.IsEscape)
+        {
+            std::size_t count = room;
+            while (count > 0 && (static_cast<unsigned char>(piece.Text[count]) & 0xC0) == 0x80)
+                --count;
+
+            Append(piece.Text.substr(0, count));
+        }
+
+        break;
+    }
+
+    Append("\"");
+}
+
 //---------------------------------------------------------------------------
 std::size_t TCrashText::GetSize() const noexcept
 {
@@ -691,6 +727,45 @@ void AppendBacktraceBeginText(TCrashText& text, std::size_t count) noexcept
     text.Append(" below the minimum level");
 }
 
+//---------------------------------------------------------------------------
+void AppendCrashJSONLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF) noexcept
+{
+    // The room kept after the category: the ids, "raw", an empty message, the closing brace and the line ending
+    constexpr std::size_t CategoryReserved = 64;
+    const std::string_view ending = usesCRLF ? "\r\n" : "\n";
+
+    char digits[24];
+    const auto sinceEpoch = std::chrono::floor<std::chrono::milliseconds>(record.Timestamp.time_since_epoch());
+    const auto result = std::to_chars(digits, digits + sizeof(digits), static_cast<std::int64_t>(sinceEpoch.count()));
+
+    line.Append("{\"time\":\"");
+    line.AppendISO8601(record.Timestamp);
+    line.Append("\",\"epoch_ms\":");
+    line.Append(std::string_view(digits, static_cast<std::size_t>(result.ptr - digits)));
+    line.Append(",\"level\":\"");
+    line.Append(Level_ToString(record.LogLevel));
+    line.Append("\"");
+
+    if (!record.Category.empty())
+    {
+        line.Append(",\"category\":");
+        line.AppendJSONString(record.Category, CategoryReserved);
+    }
+
+    line.Append(",\"pid\":");
+    line.AppendDecimal(record.ProcessId);
+    line.Append(",\"tid\":");
+    line.AppendDecimal(record.ThreadId);
+
+    if (record.Raw)
+        line.Append(",\"raw\":true");
+
+    line.Append(",\"message\":");
+    line.AppendJSONString(record.Message, 1 + ending.size());
+    line.Append("}");
+    line.Append(ending);
+}
+
 //---------------------------------------------------------------------------
 void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF) noexcept
 {
diff --git a/ASWLog/ASWLog_CrashHandler.h b/ASWLog/ASWLog_CrashHandler.h
index d08d6cd..dc507af 100644
--- a/ASWLog/ASWLog_CrashHandler.h
+++ b/ASWLog/ASWLog_CrashHandler.h
@@ -70,10 +70,13 @@ struct TASWCrashHandlerOptions
 //   costs at most the line.
 // - A POSIX signal handler may only do async-signal-safe work, so there the line has a fixed layout,
 //   "[<UTC time>][CRITICAL][P:<pid>][T:<tid>]: Crash: <reason>", built without allocating and written straight to the
-//   file. Its time is UTC with milliseconds whatever TASWLineConfig::TimestampZone and TimestampPrecision say, since
-//   converting to local time isn't async-signal-safe. The buffered entries are flushed only if the logger's lock is free (fflush isn't on POSIX's list of
-//   async-signal-safe functions, but no other thread can use the file then). The backtrace's lines get the same
-//   layout, with their own level and category (after the level, as "[Net]"), and only if the backtrace's lock is free.
+//   file. A logger whose formatter is a TASWJSONFormatter gets it as JSON instead, {"time":"<UTC time>",
+//   "epoch_ms":<ms>,"level":"CRITICAL","pid":<pid>,"tid":<tid>,"message":"Crash: <reason>"}, whatever its Show*
+//   options say. Its time is UTC with milliseconds whatever TASWLineConfig::TimestampZone and TimestampPrecision say,
+//   since converting to local time isn't async-signal-safe. The buffered entries are flushed only if the logger's lock
+//   is free (fflush isn't on POSIX's list of async-signal-safe functions, but no other thread can use the file then).
+//   The backtrace's lines get the same layout, with their own level and category (after the level, as "[Net]", or as
+//   "category" in JSON), and only if the backtrace's lock is free.
 // - If a logger's lock stays busy until WaitTimeout has passed (e.g. the crash happened while that thread was
 //   writing an entry), its buffered entries are lost and only the fixed-layout lines (backtrace and crash line) are
 //   written, straight to the file.
@@ -139,6 +142,9 @@ class TCrashText
     void AppendDecimal(std::uint64_t value, int minDigits = 1) noexcept; // Padded with leading zeros to 'minDigits'
     void AppendHex(std::uint64_t value, int minDigits) noexcept; // "0x" and at least 'minDigits' upper case digits
     void AppendISO8601(std::chrono::system_clock::time_point time) noexcept; // "YYYY-MM-DDTHH:mm:ss.mmmZ"
+    // 'text' as a JSON string (see JSON::AppendString()), cut between characters if needed so that 'reserved'
+    // characters stay free after it; the string is always closed
+    void AppendJSONString(std::string_view text, std::size_t reserved) noexcept;
     std::size_t GetSize() const noexcept;
     void Truncate(std::size_t size) noexcept; // Cuts the text to 'size' characters, if it is longer
     std::string_view View() const noexcept;
@@ -171,6 +177,11 @@ inline constexpr std::string_view BacktraceEndText = "Backtrace end";
 // the minimum level". Doesn't allocate, so a crash handler can use it too.
 void AppendBacktraceBeginText(TCrashText& text, std::size_t count) noexcept;
 
+// Appends the fixed-layout crash line for 'record' as a JSON object, for a logger that uses TASWJSONFormatter (see
+// the crash handling notes above), with a CRLF or LF ending. A text too long for the buffer is cut off, but the line
+// is always a whole JSON object, followed by the line ending.
+void AppendCrashJSONLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF) noexcept;
+
 // Appends the fixed-layout crash line for 'record' (see the crash handling notes above), with a CRLF or LF ending. A
 // message too long for the buffer is cut off, but the line always ends with the line ending.
 void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF) noexcept;
diff --git a/ASWLog/ASWLog_Formatter.cpp b/ASWLog/ASWLog_Formatter.cpp
index 66a682f..0b94285 100644
--- a/ASWLog/ASWLog_Formatter.cpp
+++ b/ASWLog/ASWLog_Formatter.cpp
@@ -27,6 +27,7 @@ limitations under the License.
 // System includes here
 #include <algorithm>
 #include <charconv>
+#include <chrono>
 #include <cstdint>
 #include <filesystem>
 #include <format>
@@ -51,6 +52,9 @@ constexpr std::size_t MaxPatternWidth = 1000;
 
 void AppendField(std::string& line, std::string_view value, std::string_view prefix, std::string_view suffix,
     std::size_t width);
+template<typename TInteger>
+void AppendJSONNumber(std::string& line, std::string_view name, TInteger value);
+void AppendJSONString(std::string& line, std::string_view name, std::string_view value);
 void AppendNumberField(std::string& line, std::string_view label, std::uint64_t value);
 bool IsASCIIDigit(char character) noexcept;
 bool IsASCIILetter(char character) noexcept;
@@ -80,6 +84,38 @@ void AppendField(std::string& line, std::string_view value, std::string_view pre
     line.append(suffix);
 }
 
+/*
+  AppendJSONNumber
+
+  Appends a JSON object's member "<name>":<value>, followed by a comma
+*/
+template<typename TInteger>
+void AppendJSONNumber(std::string& line, std::string_view name, TInteger value)
+{
+    char digits[24];
+    const auto result = std::to_chars(digits, digits + sizeof(digits), value);
+
+    line += '"';
+    line.append(name);
+    line += "\":";
+    line.append(digits, result.ptr);
+    line += ',';
+}
+
+/*
+  AppendJSONString
+
+  Appends a JSON object's member "<name>":"<value>", the value escaped, followed by a comma
+*/
+void AppendJSONString(std::string& line, std::string_view name, std::string_view value)
+{
+    line += '"';
+    line.append(name);
+    line += "\":";
+    JSON::AppendString(line, value);
+    line += ',';
+}
+
 /*
   AppendNumberField
 
@@ -142,6 +178,83 @@ std::string_view ToDecimal(char (& buffer)[Time::ISO8601BufferSize], std::uint64
 
 //---------------------------------------------------------------------------
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWJSONFormatter
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+std::string TASWJSONFormatter::Format(const TASWLogRecord& record, const TASWLogConfig& config) const
+{
+    std::string line;
+    line.reserve(record.Message.size() + 256);
+    line += '{';
+
+    // Each member is followed by a comma, since "message" always comes last
+    if (config.Line.ShowTimestamp)
+    {
+        char timestamp[Time::ISO8601BufferSize];
+        line += "\"time\":\"";
+        line.append(timestamp, Time::WriteISO8601(timestamp, record.Timestamp, config.Line.TimestampZone, config.Line.TimestampPrecision));
+        line += "\",";
+
+        const auto sinceEpoch = std::chrono::floor<std::chrono::milliseconds>(record.Timestamp.time_since_epoch());
+        AppendJSONNumber(line, "epoch_ms", static_cast<std::int64_t>(sinceEpoch.count()));
+    }
+
+    if (config.Line.ShowLevel)
+    {
+        line += "\"level\":\"";
+        line.append(Level_ToString(record.LogLevel));
+        line += "\",";
+    }
+
+    if (config.Line.ShowCategory && !record.Category.empty())
+        AppendJSONString(line, "category", record.Category);
+
+    if (config.Line.ShowProcessId)
+        AppendJSONNumber(line, "pid", record.ProcessId);
+
+    if (config.Line.ShowThreadId)
+        AppendJSONNumber(line, "tid", record.ThreadId);
+
+    if (config.Line.ShowWorkingSet || config.Line.ShowPeakWorkingSet)
+    {
+        const auto memoryUsage = GetMemoryUsage();
+        if (config.Line.ShowWorkingSet)
+            AppendJSONNumber(line, "ws", memoryUsage.WorkingSetBytes);
+
+        if (config.Line.ShowPeakWorkingSet)
+            AppendJSONNumber(line, "pws", memoryUsage.PeakWorkingSetBytes);
+    }
+
+    if (config.Line.ShowFunctionName)
+        AppendJSONString(line, "function", record.Location.function_name());
+
+    if (config.Line.ShowSourceLine)
+    {
+        // As TASWTextFormatter writes it
+        AppendJSONString(line, "file", std::filesystem::path(record.Location.file_name()).filename().string());
+        AppendJSONNumber(line, "line", record.Location.line());
+    }
+
+    if (record.Raw)
+        line += "\"raw\":true,";
+
+    line += "\"message\":";
+    JSON::AppendString(line, record.Message);
+    line += '}';
+
+    return line;
+}
+
+//---------------------------------------------------------------------------
+bool TASWJSONFormatter::FormatsRawEntries() const noexcept
+{
+    return true;
+}
+
+//---------------------------------------------------------------------------
+
 /////////////////////////////////////////////////////////////////////////////
 // TASWPatternFormatter
 /////////////////////////////////////////////////////////////////////////////
diff --git a/ASWLog/ASWLog_Formatter.h b/ASWLog/ASWLog_Formatter.h
index 59b787d..814b790 100644
--- a/ASWLog/ASWLog_Formatter.h
+++ b/ASWLog/ASWLog_Formatter.h
@@ -59,9 +59,51 @@ class IASWLogFormatter
     virtual ~IASWLogFormatter() = default;
 
     // Returns the line for 'record', without its line ending (the logger adds TASWLogConfig::Line.Ending).
-    // 'config' is the calling logger's config. Not called for a Raw record (LogRaw()/LogForceRaw()), whose message is written as is.
+    // 'config' is the calling logger's config. Not called for a Raw record (LogRaw()/LogForceRaw()), whose message is
+    // written as is, unless FormatsRawEntries() says so.
     // May throw, e.g. std::bad_alloc: the entry is then dropped.
     [[nodiscard]] virtual std::string Format(const TASWLogRecord& record, const TASWLogConfig& config) const = 0;
+
+    // True if Format() is called for a Raw record too, whose line the logger then ends with the line ending like any
+    // other (e.g. for a format in which every line must be a whole entry, such as JSON Lines). False by default: the
+    // logger writes a Raw record's message as is, without a line ending.
+    [[nodiscard]] virtual bool FormatsRawEntries() const noexcept
+    {
+        return false;
+    }
+};
+
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWJSONFormatter
+//
+// Writes each entry as a JSON object on one line (JSON Lines), e.g.
+//     config.Line.Formatter = std::make_shared<const ASWLog::TASWJSONFormatter>();
+// writes {"time":"2026-10-08T14:31:00.217Z","epoch_ms":1791469860217,"level":"DEBUG","category":"Net","pid":4120,
+// "tid":7788,"message":"connected"}. Like TASWTextFormatter, it writes the fields whose TASWLineConfig Show* option
+// is on, in the same order:
+//   "time", "epoch_ms"  the timestamp, as TASWTextFormatter writes it (TimestampZone and TimestampPrecision), and as
+//                       whole milliseconds since 1970-01-01 UTC (ShowTimestamp)
+//   "level"             TRACE, DEBUG, INFO, WARN, ERROR or CRITICAL (ShowLevel)
+//   "category"          the category's name, if the entry has one (ShowCategory; see TASWCategoryLog)
+//   "pid", "tid"        the process and thread ids, as numbers (ShowProcessId, ShowThreadId)
+//   "ws", "pws"         the process's working set and peak working set in bytes, as numbers (ShowWorkingSet,
+//                       ShowPeakWorkingSet)
+//   "function"          the function that logged the entry (ShowFunctionName)
+//   "file", "line"      its source file's name (without folders) and line, a number (ShowSourceLine)
+//   "raw"               true for a LogRaw()/LogForceRaw() entry, which gets a line of its own like any other
+//   "message"           the message, always
+// Texts are escaped as RFC 8259 asks, with each invalid UTF-8 sequence replaced by U+FFFD (see JSON::AppendString()),
+// so a multi-line message stays on one line. The logger adds the line ending (TASWLineConfig::Ending): LF, as JSON
+// Lines asks, or CRLF, which JSON readers accept too. A crash line written in a POSIX signal handler, or when the
+// logger's lock stays busy, is a JSON object too, with fixed fields (see ASWLog_CrashHandler.h). Thread-safe, so
+// loggers can share one.
+/////////////////////////////////////////////////////////////////////////////
+class TASWJSONFormatter : public IASWLogFormatter
+{
+public:
+    [[nodiscard]] std::string Format(const TASWLogRecord& record, const TASWLogConfig& config) const override;
+    [[nodiscard]] bool FormatsRawEntries() const noexcept override; // True
 };
 
 
@@ -145,7 +187,7 @@ class TASWPatternFormatter : public IASWLogFormatter
 // "[time][LEVEL][category][P:pid][T:tid][WS:bytes][PWS:bytes][function][file:line]: message", where each bracketed
 // field is written only if its TASWLineConfig option is on (ShowTimestamp, ShowLevel, ShowCategory, ShowProcessId,
 // ShowThreadId, ShowWorkingSet, ShowPeakWorkingSet, ShowFunctionName, ShowSourceLine), and the category only if the
-// entry has one. For another layout, see TASWPatternFormatter.
+// entry has one. For another layout, see TASWPatternFormatter; for JSON Lines, TASWJSONFormatter.
 /////////////////////////////////////////////////////////////////////////////
 class TASWTextFormatter : public IASWLogFormatter
 {
diff --git a/ASWLog/ASWLog_Interface.h b/ASWLog/ASWLog_Interface.h
index 407735b..ddf5da7 100644
--- a/ASWLog/ASWLog_Interface.h
+++ b/ASWLog/ASWLog_Interface.h
@@ -229,7 +229,8 @@ class IASWLog
 
     // --- Non-virtual Inline Logging Methods ---
     // Each passes a record with the caller's source location to Write(). LogRaw() writes the message as is, without the
-    // line layout or a line ending (e.g. a multi-line HTTP body); LogForce() writes it whatever the minimum level.
+    // line layout or a line ending (e.g. a multi-line HTTP body; a TASWJSONFormatter logger writes it as a JSON object
+    // with "raw":true instead); LogForce() writes it whatever the minimum level.
     inline void Log(Level level, std::string_view msg, std::source_location loc = std::source_location::current()) noexcept
     {
         Write(MakeRecord(level, msg, loc, false, false));
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index cc788c8..5221756 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -72,6 +72,19 @@ void TASWTextLogBase::AfterQueuedEntriesUnlocked(bool mustFlush)
         FlushUnlocked();
 }
 
+//---------------------------------------------------------------------------
+// The fixed-layout crash line for 'record', as text or, for a TASWJSONFormatter logger, as JSON (see
+// StoreCrashLineSettingsUnlocked()). Allocates nothing.
+void TASWTextLogBase::AppendCrashLine(Detail::TCrashText& line, const TASWLogRecord& record) const noexcept
+{
+    const bool usesCRLF = m_CrashLineUsesCRLF.load(std::memory_order_relaxed);
+
+    if (m_CrashLineUsesJSON.load(std::memory_order_relaxed))
+        Detail::AppendCrashJSONLine(line, record, usesCRLF);
+    else
+        Detail::AppendCrashLine(line, record, usesCRLF);
+}
+
 //---------------------------------------------------------------------------
 bool TASWTextLogBase::Close() noexcept
 {
@@ -184,14 +197,14 @@ void TASWTextLogBase::FlushForCrashUnlocked() noexcept
 /*
     TASWTextLogBase::FormatEntry
 
-    The line written for 'record' with 'config': its message as is for a Raw record, otherwise the formatter's line
-    followed by the line ending.
+    The line written for 'record' with 'config': the formatter's line followed by the line ending, or, for a Raw record
+    that the formatter doesn't format (see IsFormatted()), its message as is.
 */
 std::string TASWTextLogBase::FormatEntry(const TASWLogRecord& record, const TASWLogConfig& config)
 {
     std::string line;
 
-    if (record.Raw)
+    if (!IsFormatted(record, config))
     {
         line.reserve(record.Message.size() + 2);
         line.append(record.Message);
@@ -269,6 +282,23 @@ bool TASWTextLogBase::Initialize(const TASWLogConfig& config) noexcept
     }
 }
 
+//---------------------------------------------------------------------------
+/*
+    TASWTextLogBase::IsFormatted
+
+    True if 'record' gets the formatter's line and the line ending: every record but a Raw one, unless the formatter
+    formats Raw records too (IASWLogFormatter::FormatsRawEntries()).
+*/
+bool TASWTextLogBase::IsFormatted(const TASWLogRecord& record, const TASWLogConfig& config) noexcept
+{
+    if (!record.Raw)
+        return true;
+
+    const auto* formatter = config.Line.Formatter.get();
+
+    return formatter != nullptr && formatter->FormatsRawEntries();
+}
+
 //---------------------------------------------------------------------------
 bool TASWTextLogBase::IsOpen() const noexcept
 {
@@ -369,7 +399,7 @@ void TASWTextLogBase::OnCrash(std::string_view message, bool isInSignalHandler,
     if (!isLineWritten)
     {
         Detail::TCrashText line;
-        Detail::AppendCrashLine(line, record, m_CrashLineUsesCRLF.load(std::memory_order_relaxed));
+        AppendCrashLine(line, record);
         WriteCrashLineDirect(line.View());
     }
 }
@@ -422,6 +452,7 @@ bool TASWTextLogBase::QueueRecord(const TASWLogRecord& record)
     entry.Record = record;
     entry.Record.Message = {};
     entry.Record.Category = {};
+    entry.EndsLine = IsFormatted(record, *config);
     entry.MustFlush = record.LogLevel >= config->Async.WaitAtLevel;
 
     if (config->OnLogEntry != nullptr && record.LogLevel >= config->OnLogEntryMinimumLevel)
@@ -661,6 +692,8 @@ void TASWTextLogBase::StoreCrashLineSettingsUnlocked() noexcept
 {
     const auto& config = GetConfigUnlocked();
     m_CrashLineUsesCRLF.store(config.Line.Ending == LineEnding::CRLF, std::memory_order_relaxed);
+    const bool usesJSON = dynamic_cast<const TASWJSONFormatter*>(config.Line.Formatter.get()) != nullptr;
+    m_CrashLineUsesJSON.store(usesJSON, std::memory_order_relaxed);
     m_WritesCrashLine.store(config.Shutdown.WriteCrashLine, std::memory_order_relaxed);
 }
 
@@ -881,10 +914,9 @@ void TASWTextLogBase::WriteBacktraceForCrash(const TWriteLine& writeLine, bool m
 */
 void TASWTextLogBase::WriteBacktraceForCrashDirect(bool mustClear, std::chrono::steady_clock::time_point deadline) noexcept
 {
-    const bool usesCRLF = m_CrashLineUsesCRLF.load(std::memory_order_relaxed);
-    WriteBacktraceForCrash([this, usesCRLF](const TASWLogRecord& record) {
+    WriteBacktraceForCrash([this](const TASWLogRecord& record) {
             Detail::TCrashText line;
-            Detail::AppendCrashLine(line, record, usesCRLF);
+            AppendCrashLine(line, record);
             WriteCrashLineDirect(line.View());
         }, mustClear, deadline);
 }
@@ -902,7 +934,7 @@ void TASWTextLogBase::WriteBacktraceForCrashUnlocked(std::chrono::steady_clock::
     const auto& config = GetConfigUnlocked();
     WriteBacktraceForCrash([this, &config](const TASWLogRecord& record) {
             const auto line = FormatEntry(record, config);
-            WriteLineUnlocked(record.LogLevel, line, !record.Raw);
+            WriteLineUnlocked(record.LogLevel, line, IsFormatted(record, config));
         }, true, deadline);
 }
 
@@ -971,8 +1003,10 @@ std::string TASWTextLogBase::WriteLogEntry(const TASWLogRecord& record)
     if (!PrepareWriteUnlocked(record.Timestamp))
         return {};
 
-    auto line = FormatEntry(record, GetConfigUnlocked());
-    WriteLineUnlocked(record.LogLevel, line, !record.Raw);
+    const auto& config = GetConfigUnlocked();
+    auto line = FormatEntry(record, config);
+    WriteLineUnlocked(record.LogLevel, line, IsFormatted(record, config));
+
     return line;
 }
 
@@ -1013,7 +1047,7 @@ void TASWTextLogBase::WriteQueuedEntries(std::deque<TQueuedEntry>& entries, std:
                 if (!EnsureReadyUnlocked() || !PrepareWriteUnlocked(entry.Record.Timestamp))
                     continue;
 
-                WriteLineUnlocked(entry.Record.LogLevel, entry.Line, !entry.Record.Raw);
+                WriteLineUnlocked(entry.Record.LogLevel, entry.Line, entry.EndsLine);
                 AfterEntryUnlocked();
                 entry.IsWritten = true;
                 mustFlush = mustFlush || entry.MustFlush;
diff --git a/ASWLog/ASWLog_TextLogBase.h b/ASWLog/ASWLog_TextLogBase.h
index f7ea9cf..1c5da6c 100644
--- a/ASWLog/ASWLog_TextLogBase.h
+++ b/ASWLog/ASWLog_TextLogBase.h
@@ -53,6 +53,7 @@ namespace Detail
 {
 
 class TCrashHandling; // See ASWLog_CrashHandler.h
+class TCrashText;
 
 } // namespace Detail
 
@@ -110,6 +111,7 @@ class TASWTextLogBase : public TASWLogBase
         std::string Line; // The line to write: formatted, or the raw text
         std::shared_ptr<const TASWLogConfig> CallbackConfig; // Set only if OnLogEntry will be called
         std::uint64_t Sequence = 0;
+        bool EndsLine = true; // Line ends with the line ending (see IsFormatted())
         bool MustFlush = false; // At or above TASWAsyncConfig::WaitAtLevel: its caller waits until it is flushed
         bool IsWritten = false;
     };
@@ -146,6 +148,7 @@ class TASWTextLogBase : public TASWLogBase
 
     // From the config (see StoreCrashLineSettingsUnlocked()), for a crash handler that doesn't get the lock
     std::atomic<bool> m_CrashLineUsesCRLF{ false };
+    std::atomic<bool> m_CrashLineUsesJSON{ false }; // The formatter is a TASWJSONFormatter
     std::atomic<bool> m_WritesCrashLine{ true };
 
 private:
@@ -175,8 +178,10 @@ class TASWTextLogBase : public TASWLogBase
 
 private:
     static std::string FormatEntry(const TASWLogRecord& record, const TASWLogConfig& config);
+    static bool IsFormatted(const TASWLogRecord& record, const TASWLogConfig& config) noexcept;
 
 private:
+    void AppendCrashLine(Detail::TCrashText& line, const TASWLogRecord& record) const noexcept;
     void DispatchLogCallback(const TASWLogConfig& config, const TASWLogRecord& record, std::string_view formattedLine) const noexcept;
     TASWLogRecord MakeBacktraceMarker(std::string_view message) const noexcept;
     void OnCrash(std::string_view message, bool isInSignalHandler, std::chrono::steady_clock::time_point deadline) noexcept;
@@ -316,7 +321,8 @@ class TASWTextLogBase : public TASWLogBase
     // state m_Mutex guards being consistent. Does nothing by default.
     virtual void WriteCrashLineDirect(std::string_view line) noexcept;
 
-    // Writes a finished line. 'endsLine' is true if 'line' ends with the line ending (false for a Raw record).
+    // Writes a finished line. 'endsLine' is true if 'line' ends with the line ending (false for a Raw record written
+    // as is; see IASWLogFormatter::FormatsRawEntries()).
     virtual void WriteLineUnlocked(Level level, std::string_view line, bool endsLine) = 0;
 
 protected: // TASWLogBase hook
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index eff93db..c7e9b3c 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -431,7 +431,9 @@ struct TASWLogRecord
     // category has none, or there is no category (see TASWCategoryLog::SetMinimumLevel()). A multi-log uses it for its
     // own check and empties it before passing the entry on, since its loggers apply their own minimum levels.
     std::optional<Level> CategoryLevel;
-    bool Raw = false; // Written as is, without the line layout or a line ending (LogRaw(), LogForceRaw())
+    // Written as is, without the line layout or a line ending (LogRaw(), LogForceRaw()), unless the formatter formats
+    // it (see IASWLogFormatter::FormatsRawEntries())
+    bool Raw = false;
     bool Forced = false; // Written whatever the minimum level (LogForce(), LogForceRaw())
     std::string_view Message;
     std::string_view Category; // The category's name, e.g. "Net" or "Net.Http"; empty if none (see TASWCategoryLog)
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index d4d9b3f..583a000 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -29,6 +29,7 @@ limitations under the License.
 #include <cerrno>
 #include <charconv>
 #include <chrono>
+#include <cstring>
 #include <ctime>
 #include <filesystem>
 #include <format>
@@ -616,6 +617,230 @@ std::error_code RenameWithoutReplacing(const std::filesystem::path& from, const
 
 //---------------------------------------------------------------------------
 
+namespace Detail
+{
+
+namespace
+{
+
+// U+FFFD, the replacement character, in UTF-8
+constexpr std::string_view ReplacementCharacter = "\xEF\xBF\xBD";
+
+//---------------------------------------------------------------------------
+
+bool IsPlainJSONCharacter(unsigned char character) noexcept;
+bool IsPlainJSONWord(const char* data) noexcept;
+std::size_t MeasureUTF8Sequence(std::string_view text, std::size_t index, std::size_t& invalidLength) noexcept;
+
+//---------------------------------------------------------------------------
+
+/*
+  IsPlainJSONCharacter
+
+  True for an ASCII character a JSON string holds as it is: not a control character, '"' or '\'
+*/
+bool IsPlainJSONCharacter(unsigned char character) noexcept
+{
+    return character >= 0x20 && character < 0x80 && character != '"' && character != '\\';
+}
+
+/*
+  IsPlainJSONWord
+
+  True if all 8 characters at 'data' are plain (see IsPlainJSONCharacter()), tested together in a 64-bit word, which
+  is several times faster than one at a time for the usual messages
+*/
+bool IsPlainJSONWord(const char* data) noexcept
+{
+    constexpr std::uint64_t Ones = 0x0101010101010101;
+    constexpr std::uint64_t HighBits = 0x8080808080808080;
+
+    std::uint64_t word;
+    std::memcpy(&word, data, sizeof(word));
+
+    // A byte's high bit ends up set if it is 0x80 or above, or (for the bytes below 0x80) below 0x20, or equal to '"'
+    // or '\' (the usual test for a zero byte, on the word XORed with them); the order of the bytes doesn't matter
+    const std::uint64_t quotes = word ^ (Ones * '"');
+    const std::uint64_t backslashes = word ^ (Ones * '\\');
+    const std::uint64_t special = word | ((word - Ones * 0x20) & ~word) | ((quotes - Ones) & ~quotes) |
+        ((backslashes - Ones) & ~backslashes);
+
+    return (special & HighBits) == 0;
+}
+
+/*
+  MeasureUTF8Sequence
+
+  The length of the UTF-8 sequence of a character above U+007F that starts at 'index', if it is valid (see the Unicode
+  standard's table of well-formed byte sequences); otherwise 0, and 'invalidLength' gets the length of its longest start
+  that could begin a valid sequence, at least 1, which U+FFFD replaces
+*/
+std::size_t MeasureUTF8Sequence(std::string_view text, std::size_t index, std::size_t& invalidLength) noexcept
+{
+    const auto lead = static_cast<unsigned char>(text[index]);
+    std::size_t length = 0;
+    unsigned char low = 0x80; // The range of the second byte, which some lead bytes narrow
+    unsigned char high = 0xBF;
+
+    if (lead >= 0xC2 && lead <= 0xDF)
+    {
+        length = 2;
+    }
+    else if (lead >= 0xE0 && lead <= 0xEF)
+    {
+        length = 3;
+        low = lead == 0xE0 ? 0xA0 : 0x80; // No overlong forms
+        high = lead == 0xED ? 0x9F : 0xBF; // No surrogates
+    }
+    else if (lead >= 0xF0 && lead <= 0xF4)
+    {
+        length = 4;
+        low = lead == 0xF0 ? 0x90 : 0x80; // No overlong forms
+        high = lead == 0xF4 ? 0x8F : 0xBF; // Nothing above U+10FFFF
+    }
+    else
+    {
+        invalidLength = 1;
+        return 0;
+    }
+
+    std::size_t count = 1;
+
+    while (count < length && index + count < text.size())
+    {
+        const auto byte = static_cast<unsigned char>(text[index + count]);
+        if (byte < low || byte > high)
+            break;
+
+        low = 0x80;
+        high = 0xBF;
+        ++count;
+    }
+
+    if (count == length)
+        return length;
+
+    invalidLength = count;
+
+    return 0;
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+TJSONPiece NextJSONPiece(std::string_view text, std::size_t& index, char (& escape)[6]) noexcept
+{
+    const std::size_t start = index;
+    std::size_t invalidLength = 0;
+
+    while (index < text.size())
+    {
+        if (text.size() - index >= 8 && IsPlainJSONWord(text.data() + index))
+        {
+            index += 8;
+            continue;
+        }
+
+        const auto character = static_cast<unsigned char>(text[index]);
+        if (IsPlainJSONCharacter(character))
+        {
+            ++index;
+            continue;
+        }
+
+        if (character < 0x80)
+            break;
+
+        const auto length = MeasureUTF8Sequence(text, index, invalidLength);
+        if (length == 0)
+            break;
+
+        index += length;
+    }
+
+    if (index > start)
+        return TJSONPiece{ text.substr(start, index - start), false };
+
+    if (index >= text.size())
+        return TJSONPiece{};
+
+    if (invalidLength > 0)
+    {
+        index += invalidLength;
+        return TJSONPiece{ ReplacementCharacter, true };
+    }
+
+    const char character = text[index++];
+    escape[0] = '\\';
+
+    switch (character)
+    {
+        case '"':
+        case '\\':
+            escape[1] = character;
+            break;
+
+        case '\b':
+            escape[1] = 'b';
+            break;
+
+        case '\f':
+            escape[1] = 'f';
+            break;
+
+        case '\n':
+            escape[1] = 'n';
+            break;
+
+        case '\r':
+            escape[1] = 'r';
+            break;
+
+        case '\t':
+            escape[1] = 't';
+            break;
+
+        default:
+        {
+            constexpr std::string_view HexDigits = "0123456789abcdef";
+            const auto code = static_cast<unsigned char>(character);
+            escape[1] = 'u';
+            escape[2] = '0';
+            escape[3] = '0';
+            escape[4] = HexDigits[code >> 4];
+            escape[5] = HexDigits[code & 0xF];
+            return TJSONPiece{ std::string_view(escape, 6), true };
+        }
+    }
+
+    return TJSONPiece{ std::string_view(escape, 2), true };
+}
+
+} // namespace Detail
+
+//---------------------------------------------------------------------------
+
+namespace JSON
+{
+
+//---------------------------------------------------------------------------
+void AppendString(std::string& output, std::string_view text)
+{
+    char escape[6];
+    std::size_t index = 0;
+
+    output += '"';
+
+    while (index < text.size())
+        output.append(Detail::NextJSONPiece(text, index, escape).Text);
+
+    output += '"';
+}
+
+} // namespace JSON
+
+//---------------------------------------------------------------------------
+
 namespace Time
 {
 
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index 76cc4d6..b6cc2e8 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -136,6 +136,45 @@ struct TSystemMemoryUsage
 */
 [[nodiscard]] std::error_code RenameWithoutReplacing(const std::filesystem::path& from, const std::filesystem::path& to) noexcept;
 
+namespace Detail
+{
+
+// A piece of a JSON string's text (see NextJSONPiece())
+struct TJSONPiece
+{
+    std::string_view Text;
+    bool IsEscape = false; // An escape or U+FFFD, which must not be cut; otherwise ASCII and valid UTF-8, as they are
+};
+
+//---------------------------------------------------------------------------
+
+/*
+    NextJSONPiece
+
+    The next piece of 'text', from 'index' on, as JSON::AppendString() writes it between the quotes, and moves 'index'
+    past it: a run of characters written as they are (a view of 'text', which can be cut between UTF-8 sequences), or
+    one escape or U+FFFD, written into 'escape'. An empty piece at the end of 'text'. Allocates nothing, so a crash
+    handler can write a JSON string piece by piece into a fixed buffer.
+*/
+[[nodiscard]] TJSONPiece NextJSONPiece(std::string_view text, std::size_t& index, char (& escape)[6]) noexcept;
+
+} // namespace Detail
+
+namespace JSON
+{
+
+/*
+    AppendString
+
+    Appends 'text' to 'output' as a JSON string, in double quotes, escaped as RFC 8259 asks: '"' and '\' with a
+    backslash, the control characters below 0x20 as \b, \f, \n, \r, \t or \u00XX. Valid UTF-8 is written as it is, and
+    each invalid UTF-8 sequence (the longest start of a valid sequence, or else one byte, as Unicode recommends) is
+    replaced with U+FFFD, so the result is always valid UTF-8 JSON.
+*/
+void AppendString(std::string& output, std::string_view text);
+
+} // namespace JSON
+
 namespace Time
 {
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6382771..484cd2b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -65,6 +65,24 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   throws `std::invalid_argument` naming the problem and where it is. The
   `Line.Show*` options don't apply to a pattern, and the logger still adds
   `Line.Ending` after each line.
+- JSON Lines output: `TASWJSONFormatter` writes each entry as a JSON object
+  on one line, e.g.
+  `config.Line.Formatter = std::make_shared<const ASWLog::TASWJSONFormatter>();`
+  for
+  `{"time":"2026-10-08T14:31:00.217Z","epoch_ms":1791469860217,"level":"DEBUG","category":"Net","pid":4120,"tid":7788,"message":"connected"}`.
+  It writes the fields that the `Line.Show*` options turn on, in the
+  built-in layout's order: `time` (in `Line.TimestampZone` and
+  `Line.TimestampPrecision`) with `epoch_ms` (whole milliseconds since 1970
+  UTC), `level`, `category`, `pid`, `tid`, `ws`, `pws`, `function`, `file`
+  and `line`, then always `message`. Texts are escaped as RFC 8259 asks,
+  and invalid UTF-8 is replaced with U+FFFD, so a multi-line message stays
+  on its line. A `LogRaw()` entry gets an object of its own with
+  `"raw":true` instead of being written as is, and the startup, shutdown
+  and crash lines are objects too, including the fixed-layout crash line
+  (in a POSIX signal handler, or when the logger's lock stays busy). A
+  custom formatter can format raw entries too by overriding the new
+  `IASWLogFormatter::FormatsRawEntries()` (false by default), and
+  `JSON::AppendString()` writes a text as an escaped JSON string.
 
 ### Changed
 
diff --git a/README.md b/README.md
index a1e4a9b..1b82163 100644
--- a/README.md
+++ b/README.md
@@ -39,6 +39,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   application compress, upload or move it.
 - Your own line layout as a pattern, e.g. `"{time} {level:5} {[category] }{message}"` (`ASWLog::TASWPatternFormatter`,
   assigned to `TASWLogConfig::Line.Formatter`).
+- JSON Lines output for log shippers and tools such as `jq`: one escaped JSON object per entry
+  (`ASWLog::TASWJSONFormatter`, assigned to `TASWLogConfig::Line.Formatter`).
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
   or derive a new text logger from `TASWTextLogBase` and implement only its output.
 
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index 945d06c..bdeb847 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -45,6 +45,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Utils.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Version.cpp"
     "${ASWLOG_TESTS_DIR}/UT_Helper_DateTime.cpp"
+    "${ASWLOG_TESTS_DIR}/UT_Helper_JSON.cpp"
 )
 
 target_include_directories(ASWLogTests PRIVATE
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index 4eb82b6..1a58a4b 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -258,6 +258,10 @@
             <DependentOn>..\tests\UT_Helper_DateTime.h</DependentOn>
             <BuildOrder>35</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\UT_Helper_JSON.cpp">
+            <DependentOn>..\tests\UT_Helper_JSON.h</DependentOn>
+            <BuildOrder>38</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\third_party\asw-unit-tests\src\ASWUnitTests_CLI.cpp">
             <DependentOn>..\..\third_party\asw-unit-tests\src\ASWUnitTests_CLI.h</DependentOn>
             <BuildOrder>8</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_CrashHandler.cpp b/tests/tests/Test_ASWLog_CrashHandler.cpp
index 8d9ae1b..dcd64cc 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.cpp
+++ b/tests/tests/Test_ASWLog_CrashHandler.cpp
@@ -68,6 +68,8 @@ limitations under the License.
 #include "ASWLog_Formatter.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
+#include "UT_Helper_JSON.h"
+//---------------------------------------------------------------------------
 
 // The sanitizers replace or watch the signal handlers and the stack, which a stack overflow test can't work with
 #if defined(__SANITIZE_ADDRESS__) || defined(__SANITIZE_THREAD__)
@@ -173,6 +175,48 @@ void ExitAsPassedOnFromSignal(int signalNumber, siginfo_t* /*info*/, void* /*con
 }
 #endif
 
+// Calls HandleCrash(reason), with a 50 ms WaitTimeout, while another thread holds the lock of 'log', so the crash lines
+// are written straight to its file in the fixed layout. Returns how long HandleCrash() took.
+std::chrono::milliseconds HandleCrashWhileLocked(TLockableFileLog& log, std::string_view reason)
+{
+    std::mutex mutex;
+    std::condition_variable changed;
+    bool isLocked = false;
+    bool mayUnlock = false;
+    std::thread holder([&] {
+        std::lock_guard<std::mutex> logLock(log.GetMutex());
+        std::unique_lock<std::mutex> lock(mutex);
+        isLocked = true;
+        changed.notify_all();
+        changed.wait(lock, [&] {
+            return mayUnlock;
+                    });
+                });
+
+    {
+        std::unique_lock<std::mutex> lock(mutex);
+        changed.wait(lock, [&] {
+                    return isLocked;
+                });
+    }
+
+    ASWLog::TASWCrashHandlerOptions options;
+    options.WaitTimeout = std::chrono::milliseconds(50);
+    const auto start = std::chrono::steady_clock::now();
+    ASWLog::HandleCrash(reason, options);
+    const auto elapsed = std::chrono::steady_clock::now() - start;
+
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        mayUnlock = true;
+    }
+
+    changed.notify_all();
+    holder.join();
+
+    return std::chrono::duration_cast<std::chrono::milliseconds>(elapsed);
+}
+
 // An OnError handler for the tests that cause failures on purpose, so their reports don't go to stderr
 void IgnoreError(const ASWLog::TASWLogError& /*error*/)
 {
@@ -518,6 +562,8 @@ std::string TCrashingFormatter::Format(const ASWLog::TASWLogRecord& record, cons
 TTest_ASWLog_CrashHandler::TTest_ASWLog_CrashHandler()
     : inherited("ASWLog_CrashHandler_Tests")
 {
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_CutsALongTextButStaysValid, "AppendCrashJSONLine_CutsALongTextButStaysValid");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_UsesTheFixedLayout, "AppendCrashJSONLine_UsesTheFixedLayout");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding, "AppendCrashLine_CutsALongMessageButKeepsTheEnding");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheCategory, "AppendCrashLine_ShowsTheCategory");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_UsesTheFixedLayout, "AppendCrashLine_UsesTheFixedLayout");
@@ -532,6 +578,7 @@ TTest_ASWLog_CrashHandler::TTest_ASWLog_CrashHandler()
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_ConsoleLogWritesTheLineToStdErr, "HandleCrash_ConsoleLogWritesTheLineToStdErr");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_DisabledLoggerIsOnlyFlushed, "HandleCrash_DisabledLoggerIsOnlyFlushed");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_FlushesAndWritesTheCrashLine, "HandleCrash_FlushesAndWritesTheCrashLine");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy, "HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_SkipsClosedAndDestroyedLoggers, "HandleCrash_SkipsClosedAndDestroyedLoggers");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_SyncsTheLineAtSyncToDiskAtLevel, "HandleCrash_SyncsTheLineAtSyncToDiskAtLevel");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_ThrowingFormatterGetsTheFixedLayoutLine, "HandleCrash_ThrowingFormatterGetsTheFixedLayoutLine");
@@ -571,6 +618,96 @@ void TTest_ASWLog_CrashHandler::TearDown_Test(ITestCase& /*testCase*/)
 
 // /////// Begin tests after this line ///////////////////////
 
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_CutsALongTextButStaysValid()
+{
+    // Arrange: a category that alone would fill the buffer, and messages of two-byte characters and quotes, each
+    // escaped as two characters, too long for the buffer; 0 to 3 leading characters move the cut through every
+    // position in the repeating 4-byte unit
+    ASWLog::TASWLogRecord categorized;
+    const std::string category(3000, 'c');
+    categorized.Category = category;
+    categorized.Message = "after";
+
+    std::vector<std::string> messages;
+
+    for (std::size_t offset = 0; offset < 4; ++offset)
+    {
+        std::string message(offset, 'x');
+
+        for (int unit = 0; unit < 1000; ++unit)
+            message += "\xCE\xBB\"";
+
+        messages.push_back(message);
+    }
+
+    // Act
+    ASWLog::Detail::TCrashText categoryLine;
+    ASWLog::Detail::AppendCrashJSONLine(categoryLine, categorized, true);
+
+    std::vector<std::string> messageLines;
+
+    for (const auto& message : messages)
+    {
+        ASWLog::TASWLogRecord record;
+        record.Message = message;
+        ASWLog::Detail::TCrashText line;
+        ASWLog::Detail::AppendCrashJSONLine(line, record, true);
+        messageLines.emplace_back(line.View());
+    }
+
+    // Assert
+    const std::string categoryText(categoryLine.View());
+    CheckEndsWith(categoryText, R"(,"pid":0,"tid":0,"message":"after"})" "\r\n", "A cut category should leave room for the rest");
+    CheckTrue(IsJSONObjectLine(categoryText.substr(0, categoryText.size() - 2)), "The line with a cut category should be one JSON object");
+
+    for (const auto& text : messageLines)
+    {
+        CheckLessThanOrEqual(text.size(), ASWLog::Detail::TCrashText::Capacity, "The line should fit the buffer");
+        CheckGreaterThan(text.size(), ASWLog::Detail::TCrashText::Capacity - 8, "The message should fill the buffer");
+        CheckEndsWith(text, "\"}\r\n", "The cut line should still close the message, the object and the line");
+        CheckTrue(IsJSONObjectLine(text.substr(0, text.size() - 2)),
+            "The cut line should be one JSON object, with no character or escape cut in two: " + text.substr(text.size() - 12));
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_UsesTheFixedLayout()
+{
+    // Arrange: a crash line, and a raw backtrace entry from a category
+    using namespace std::chrono;
+    ASWLog::TASWLogRecord record;
+    record.Timestamp = sys_days{ year{ 2026 } / 10 / 4 } + hours(12) + minutes(34) + seconds(56) + milliseconds(789);
+    record.LogLevel = ASWLog::Level::Critical;
+    record.Message = "Crash: \"test\"";
+    record.ProcessId = 12;
+    record.ThreadId = 345;
+    auto categorizedRaw = record;
+    categorizedRaw.LogLevel = ASWLog::Level::Debug;
+    categorizedRaw.Category = "Net.Http";
+    categorizedRaw.Raw = true;
+    categorizedRaw.Message = "kept\n";
+
+    // Act
+    ASWLog::Detail::TCrashText lfLine;
+    ASWLog::Detail::AppendCrashJSONLine(lfLine, record, false);
+    ASWLog::Detail::TCrashText crlfLine;
+    ASWLog::Detail::AppendCrashJSONLine(crlfLine, record, true);
+    ASWLog::Detail::TCrashText categorizedLine;
+    ASWLog::Detail::AppendCrashJSONLine(categorizedLine, categorizedRaw, false);
+
+    // Assert
+    CheckEquals(std::string(R"({"time":"2026-10-04T12:34:56.789Z","epoch_ms":1791117296789,"level":"CRITICAL","pid":12,"tid":345,)"
+        R"("message":"Crash: \"test\""})" "\n"), std::string(lfLine.View()), "The line should have the fixed layout");
+    CheckEndsWith(std::string(crlfLine.View()), "\"}\r\n", "The line should end with the configured line ending");
+    CheckEquals(std::string(R"({"time":"2026-10-04T12:34:56.789Z","epoch_ms":1791117296789,"level":"DEBUG","category":"Net.Http",)"
+        R"("pid":12,"tid":345,"raw":true,"message":"kept\n"})" "\n"), std::string(categorizedLine.View()),
+        "The category and the raw mark should be written like the JSON formatter writes them");
+
+    const ASWLog::TASWJSONFormatter formatter;
+    const ASWLog::TASWLogConfig defaultConfig;
+    CheckEquals(formatter.Format(categorizedRaw, defaultConfig) + "\n", std::string(categorizedLine.View()),
+        "The fixed layout should match the JSON formatter's default fields");
+}
 //---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding()
 {
@@ -845,6 +982,46 @@ void TTest_ASWLog_CrashHandler::Test_HandleCrash_FlushesAndWritesTheCrashLine()
         "The buffered entry should be flushed, then the formatted crash line written and flushed");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy()
+{
+    // Arrange: a JSON logger with a backtrace entry (HandleCrashWhileLocked() holds its lock on another thread meanwhile)
+    auto config = MakeCrashTestConfig("busy.json");
+    config.Backtrace.Capacity = 5;
+    config.Backtrace.LowestLevel = ASWLog::Level::Debug;
+    config.Line.Formatter = std::make_shared<const ASWLog::TASWJSONFormatter>();
+    TLockableFileLog log;
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+    log.LogDebug("debug_1");
+
+    // Act
+    const auto elapsed = HandleCrashWhileLocked(log, "busy \"json\"");
+    const auto contents = ReadFileText(TestTempDir / "busy.json");
+
+    // Assert
+    std::vector<std::string> lines;
+
+    for (std::size_t start = 0; start < contents.size();)
+    {
+        const auto end = contents.find('\n', start);
+        lines.push_back(contents.substr(start, end - start));
+        start = end == std::string::npos ? contents.size() : end + 1;
+    }
+
+    CheckLessThan(elapsed.count(), 5000, "HandleCrash() should give up waiting for the lock");
+    CheckEndsWith(contents, "}\n", "The file should end with a whole line");
+    AssertEquals(std::size_t(4), lines.size(), "The backtrace's markers, its entry and the crash line should be written");
+
+    for (const auto& line : lines)
+        CheckTrue(IsJSONObjectLine(line), "Each line should be one JSON object: " + line);
+
+    const auto ids = std::format(R"("pid":{},"tid":{},)", ASWLog::GetCurrentOSProcessId(), ASWLog::GetCurrentOSThreadId());
+    CheckEndsWith(lines[0], R"("level":"INFO",)" + ids + R"("message":"Backtrace: the last 1 entry below the minimum level"})",
+        "The backtrace should start with its marker, in the fixed JSON layout");
+    CheckEndsWith(lines[1], R"("level":"DEBUG",)" + ids + R"("message":"debug_1"})", "The kept entry should follow");
+    CheckEndsWith(lines[2], R"("level":"INFO",)" + ids + R"("message":"Backtrace end"})", "Then the end marker");
+    CheckEndsWith(lines[3], R"("level":"CRITICAL",)" + ids + R"("message":"Crash: busy \"json\""})", "Then the crash line, escaped");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_HandleCrash_SkipsClosedAndDestroyedLoggers()
 {
     // Arrange: one logger closed, one destroyed (a crash handler must not touch it)
@@ -1013,7 +1190,7 @@ void TTest_ASWLog_CrashHandler::Test_HandleCrash_WritesTheBacktraceBeforeTheCras
 //---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_HandleCrash_WritesTheLineDirectlyWhenTheLockStaysBusy()
 {
-    // Arrange: another thread holds the logger's lock until the test lets it go
+    // Arrange: a backtrace entry (HandleCrashWhileLocked() holds the logger's lock on another thread meanwhile)
     auto config = MakeCrashTestConfig("busy.log");
     config.Line.Ending = ASWLog::LineEnding::CRLF;
     config.Backtrace.Capacity = 5;
@@ -1022,46 +1199,12 @@ void TTest_ASWLog_CrashHandler::Test_HandleCrash_WritesTheLineDirectlyWhenTheLoc
     CheckTrue(log.Initialize(config), "Initialize should succeed");
     log.LogDebug("debug_1");
 
-    std::mutex mutex;
-    std::condition_variable changed;
-    bool isLocked = false;
-    bool mayUnlock = false;
-    std::thread holder([&] {
-        std::lock_guard<std::mutex> logLock(log.GetMutex());
-        std::unique_lock<std::mutex> lock(mutex);
-        isLocked = true;
-        changed.notify_all();
-        changed.wait(lock, [&] {
-            return mayUnlock;
-                });
-            });
-
-    {
-        std::unique_lock<std::mutex> lock(mutex);
-        changed.wait(lock, [&] {
-                return isLocked;
-            });
-    }
-
     // Act
-    ASWLog::TASWCrashHandlerOptions options;
-    options.WaitTimeout = std::chrono::milliseconds(50);
-    const auto start = std::chrono::steady_clock::now();
-    ASWLog::HandleCrash("busy", options);
-    const auto elapsed = std::chrono::steady_clock::now() - start;
+    const auto elapsed = HandleCrashWhileLocked(log, "busy");
     const auto contents = ReadFileText(TestTempDir / "busy.log");
 
-    {
-        std::lock_guard<std::mutex> lock(mutex);
-        mayUnlock = true;
-    }
-
-    changed.notify_all();
-    holder.join();
-
     // Assert
-    CheckLessThan(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count(), 5000,
-        "HandleCrash() should give up waiting for the lock");
+    CheckLessThan(elapsed.count(), 5000, "HandleCrash() should give up waiting for the lock");
     CheckStartsWith(contents, "[", "The crash line should start with the time");
     CheckEndsWith(contents, std::format("][CRITICAL][P:{}][T:{}]: Crash: busy\r\n", ASWLog::GetCurrentOSProcessId(),
         ASWLog::GetCurrentOSThreadId()), "The fixed-layout crash line should be written straight to the file");
diff --git a/tests/tests/Test_ASWLog_CrashHandler.h b/tests/tests/Test_ASWLog_CrashHandler.h
index 8be103a..6f1dbd7 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.h
+++ b/tests/tests/Test_ASWLog_CrashHandler.h
@@ -40,6 +40,8 @@ class TTest_ASWLog_CrashHandler : public TTestGroupBase
     typedef TTestGroupBase inherited;
 
 private: // Test methods
+    void Test_AppendCrashJSONLine_CutsALongTextButStaysValid();
+    void Test_AppendCrashJSONLine_UsesTheFixedLayout();
     void Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding();
     void Test_AppendCrashLine_ShowsTheCategory();
     void Test_AppendCrashLine_UsesTheFixedLayout();
@@ -54,6 +56,7 @@ class TTest_ASWLog_CrashHandler : public TTestGroupBase
     void Test_HandleCrash_ConsoleLogWritesTheLineToStdErr();
     void Test_HandleCrash_DisabledLoggerIsOnlyFlushed();
     void Test_HandleCrash_FlushesAndWritesTheCrashLine();
+    void Test_HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy();
     void Test_HandleCrash_SkipsClosedAndDestroyedLoggers();
     void Test_HandleCrash_SyncsTheLineAtSyncToDiskAtLevel();
     void Test_HandleCrash_ThrowingFormatterGetsTheFixedLayoutLine();
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index 0ca5d0a..3b90e64 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -49,6 +49,7 @@ limitations under the License.
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
 #include "UT_Helper_DateTime.h"
+#include "UT_Helper_JSON.h"
 //---------------------------------------------------------------------------
 
 namespace ASWUnitTests
@@ -181,6 +182,12 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_TimestampFollowsZoneAndPrecision, "FormatLine_TimestampFollowsZoneAndPrecision");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread, "Formatter_ReceivesRecordFromLoggingThread");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_SharedByTwoLoggers, "Formatter_SharedByTwoLoggers");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_DefaultFields, "JSONFormatter_DefaultFields");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EachShowOption, "JSONFormatter_EachShowOption");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EscapesTheTexts, "JSONFormatter_EscapesTheTexts");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_FileLoggerWritesJSONLines, "JSONFormatter_FileLoggerWritesJSONLines");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_RawEntries, "JSONFormatter_RawEntries");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_TimeFollowsZoneAndPrecision, "JSONFormatter_TimeFollowsZoneAndPrecision");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_AffixesOnlyAroundAValue, "PatternFormatter_AffixesOnlyAroundAValue");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_BracesAndPlainText, "PatternFormatter_BracesAndPlainText");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_DefaultLayoutMatchesTextFormatter, "PatternFormatter_DefaultLayoutMatchesTextFormatter");
@@ -428,6 +435,178 @@ void TTest_ASWLog_Formatter::Test_Formatter_SharedByTwoLoggers()
         "Logger B's file should have its 100 lines in the shared format");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_DefaultFields()
+{
+    // Arrange
+    const ASWLog::TASWJSONFormatter formatter;
+    const ASWLog::TASWLogConfig config;
+    auto categorized = MakeRecord("from net");
+    categorized.Category = "Net";
+
+    // Act
+    const auto line = formatter.Format(MakeRecord("msg"), config);
+    const auto categorizedLine = formatter.Format(categorized, config);
+
+    // Assert
+    CheckEquals(std::string(R"({"time":"2026-09-21T14:13:20.123Z","epoch_ms":1790000000123,"level":"WARN","pid":1234,"tid":5678,"message":"msg"})"),
+        line, "The default fields should be written as members, in the built-in layout's order");
+    CheckEquals(std::string(R"({"time":"2026-09-21T14:13:20.123Z","epoch_ms":1790000000123,"level":"WARN","category":"Net","pid":1234,"tid":5678,"message":"from net"})"),
+        categorizedLine, "The category should follow the level");
+    CheckTrue(IsJSONObjectLine(line) && IsJSONObjectLine(categorizedLine), "Each line should be one JSON object");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_EachShowOption()
+{
+    // Arrange: every field but memory use, memory use only, and no fields at all
+    ASWLog::TASWLogConfig allConfig;
+    allConfig.Line.ShowFunctionName = true;
+    allConfig.Line.ShowSourceLine = true;
+    auto memoryConfig = MakeConfigWithoutFields("unused.log");
+    memoryConfig.Line.ShowWorkingSet = true;
+    memoryConfig.Line.ShowPeakWorkingSet = true;
+    auto noFieldsConfig = MakeConfigWithoutFields("unused.log");
+    noFieldsConfig.Line.ShowCategory = false;
+
+    const auto location = std::source_location::current();
+    auto record = MakeRecord("all fields", location);
+    record.Category = "Net";
+    record.ProcessId = std::numeric_limits<std::uint32_t>::max();
+    record.ThreadId = 0;
+    const ASWLog::TASWJSONFormatter formatter;
+
+    // Act
+    const auto allLine = formatter.Format(record, allConfig);
+    const auto memoryLine = formatter.Format(MakeRecord("memory"), memoryConfig);
+    const auto noFieldsLine = formatter.Format(record, noFieldsConfig);
+
+    // Assert
+    const auto expected = std::format(R"({{"time":"2026-09-21T14:13:20.123Z","epoch_ms":1790000000123,"level":"WARN","category":"Net",)"
+        R"("pid":4294967295,"tid":0,"function":"{}","file":"{}","line":{},"message":"all fields"}})", location.function_name(),
+        std::filesystem::path(location.file_name()).filename().string(), location.line());
+    CheckEquals(expected, allLine, "Each field should be written, in the built-in layout's order");
+    CheckMatches(memoryLine, R"(\{"ws":[1-9][0-9]*,"pws":[1-9][0-9]*,"message":"memory"\})",
+        "The working set and peak working set should be numbers");
+    CheckEquals(std::string(R"({"message":"all fields"})"), noFieldsLine, "With every field off, only the message should remain");
+    CheckTrue(IsJSONObjectLine(allLine) && IsJSONObjectLine(memoryLine) && IsJSONObjectLine(noFieldsLine), "Each line should be one JSON object");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_EscapesTheTexts()
+{
+    // Arrange: quotes, a backslash, control characters and invalid UTF-8 in the category and the message
+    const auto config = MakeConfigWithoutFields("unused.log");
+    auto record = MakeRecord("say \"hi\" \\ \n\x01 \xCE\xBB \xFF" "end");
+    record.Category = "N\"et\t";
+
+    // Act
+    const auto line = ASWLog::TASWJSONFormatter().Format(record, config);
+
+    // Assert
+    CheckEquals(std::string(R"({"category":"N\"et\t","message":"say \"hi\" \\ \n\u0001 )" "\xCE\xBB " "\xEF\xBF\xBD" R"(end"})"), line,
+        "The texts should be escaped, valid UTF-8 kept and invalid UTF-8 replaced with U+FFFD");
+    CheckTrue(IsJSONObjectLine(line), "The line should be one JSON object");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_FileLoggerWritesJSONLines()
+{
+    // Arrange: every startup line (on Windows the drive and application info hold backslashes) and the shutdown line
+    ASWLog::TASWLogConfig config;
+    config.File.FolderPath = TestTempDir;
+    config.File.FilePath = "json.log";
+    config.File.OpenRetryCount = 1;
+    config.Startup.Banner = "Banner \"quoted\"";
+    config.Shutdown.Banner = "Bye";
+    config.Line.Formatter = std::make_shared<const ASWLog::TASWJSONFormatter>();
+    bool initialized = false;
+
+    // Act
+    {
+        ASWLog::TASWFileLog logger;
+        initialized = logger.Initialize(config);
+        ASWLog::TASWCategoryLog netLog("Net", logger);
+
+        netLog.LogWarn("from \"net\"");
+        logger.LogInfo("first line\nsecond line\r\n\ttabbed");
+        logger.LogRaw(ASWLog::Level::Info, "partial ");
+        logger.LogForceRaw(ASWLog::Level::Trace, "body\nmore\n");
+    }
+
+    const auto contents = ReadFileText(TestTempDir / "json.log");
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEndsWith(contents, "}\n", "The file should end with a whole line");
+
+    std::vector<std::string> lines;
+
+    for (std::size_t start = 0; start < contents.size();)
+    {
+        const auto end = contents.find('\n', start);
+        lines.push_back(contents.substr(start, end - start));
+        start = end == std::string::npos ? contents.size() : end + 1;
+    }
+
+    AssertGreaterThanOrEqual(lines.size(), std::size_t(7), "The startup lines, four entries and the shutdown line should be written");
+
+    for (const auto& line : lines)
+        CheckTrue(IsJSONObjectLine(line), "Each line should be one JSON object: " + line);
+
+    CheckContains(lines.front(), R"("level":"INFO",)", "The startup lines should be JSON entries too");
+    CheckContains(contents, R"("message":"Banner \"quoted\""})", "The banner should be escaped");
+    CheckContains(contents, R"("level":"WARN","category":"Net","pid":)", "The category should be a member");
+    CheckContains(contents, R"("message":"from \"net\""})", "The message should be escaped");
+    CheckContains(contents, R"("message":"first line\nsecond line\r\n\ttabbed"})", "A multi-line message should stay on its line");
+    CheckContains(contents, R"("level":"INFO","pid":)", "A raw entry should have the default fields");
+    CheckContains(contents, R"(,"raw":true,"message":"partial "})" "\n", "A raw entry should be marked and end its line");
+    CheckContains(contents, R"("level":"TRACE",)", "A forced raw entry should keep its level");
+    CheckContains(contents, R"(,"raw":true,"message":"body\nmore\n"})" "\n", "A raw entry's line breaks should be escaped");
+    CheckContains(lines.back(), "Logger shutdown: ", "The shutdown line should be the last line");
+    CheckEndsWith(lines.back(), R"(, Bye"})", "The shutdown line should have its banner");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_RawEntries()
+{
+    // Arrange
+    const ASWLog::TASWJSONFormatter formatter;
+    const auto config = MakeConfigWithoutFields("unused.log");
+    auto record = MakeRecord("partial ");
+    record.Raw = true;
+
+    // Act
+    const auto line = formatter.Format(record, config);
+
+    // Assert
+    CheckTrue(formatter.FormatsRawEntries(), "The JSON formatter should format raw entries, so each line is a whole entry");
+    CheckFalse(ASWLog::TASWTextFormatter().FormatsRawEntries(), "The built-in layout should leave raw entries as they are");
+    CheckFalse(ASWLog::TASWPatternFormatter("{message}").FormatsRawEntries(), "A pattern should leave raw entries as they are");
+    CheckEquals(std::string(R"({"raw":true,"message":"partial "})"), line, "A raw entry should be marked before the message");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_TimeFollowsZoneAndPrecision()
+{
+    // Arrange: FixedTime in US Eastern daylight time with microseconds, and a time 1.49975 s before 1970 (the epoch
+    // milliseconds round down, like the time's)
+    auto localConfig = MakeConfigWithoutFields("unused.log");
+    localConfig.Line.ShowTimestamp = true;
+    localConfig.Line.TimestampZone = ASWLog::TimeZone::Local;
+    localConfig.Line.TimestampPrecision = ASWLog::TimePrecision::Microseconds;
+    auto utcConfig = MakeConfigWithoutFields("unused.log");
+    utcConfig.Line.ShowTimestamp = true;
+    auto before1970 = MakeRecord("old");
+    before1970.Timestamp = std::chrono::system_clock::time_point(std::chrono::microseconds(-1499750));
+    const ASWLog::TASWJSONFormatter formatter;
+    const TScopedTimeZone timeZone("EST5EDT");
+
+    // Act
+    const auto localLine = formatter.Format(MakeRecord("local"), localConfig);
+    const auto oldLine = formatter.Format(before1970, utcConfig);
+
+    // Assert
+    CheckEquals(std::string(R"({"time":"2026-09-21T10:13:20.123000-04:00","epoch_ms":1790000000123,"message":"local"})"), localLine,
+        "The time should follow the zone and precision; the epoch milliseconds don't depend on them");
+    CheckEquals(std::string(R"({"time":"1969-12-31T23:59:58.500Z","epoch_ms":-1500,"message":"old"})"), oldLine,
+        "A time before 1970 should have negative epoch milliseconds, rounded down");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_PatternFormatter_AffixesOnlyAroundAValue()
 {
     // Arrange: one record with a category and a function, one without (a default source location has empty names)
diff --git a/tests/tests/Test_ASWLog_Formatter.h b/tests/tests/Test_ASWLog_Formatter.h
index 53184b4..39b9af0 100644
--- a/tests/tests/Test_ASWLog_Formatter.h
+++ b/tests/tests/Test_ASWLog_Formatter.h
@@ -45,6 +45,12 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
     void Test_FormatLine_TimestampFollowsZoneAndPrecision();
     void Test_Formatter_ReceivesRecordFromLoggingThread();
     void Test_Formatter_SharedByTwoLoggers();
+    void Test_JSONFormatter_DefaultFields();
+    void Test_JSONFormatter_EachShowOption();
+    void Test_JSONFormatter_EscapesTheTexts();
+    void Test_JSONFormatter_FileLoggerWritesJSONLines();
+    void Test_JSONFormatter_RawEntries();
+    void Test_JSONFormatter_TimeFollowsZoneAndPrecision();
     void Test_PatternFormatter_AffixesOnlyAroundAValue();
     void Test_PatternFormatter_BracesAndPlainText();
     void Test_PatternFormatter_DefaultLayoutMatchesTextFormatter();
diff --git a/tests/tests/Test_ASWLog_TextLogBase.cpp b/tests/tests/Test_ASWLog_TextLogBase.cpp
index 7053fa3..e5c15a6 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.cpp
+++ b/tests/tests/Test_ASWLog_TextLogBase.cpp
@@ -255,6 +255,21 @@ class TPipeFormatter final : public ASWLog::IASWLogFormatter
     }
 };
 
+// A formatter that formats raw entries too, as "raw|message", and the others as "line|message"
+class TRawFormattingFormatter final : public ASWLog::IASWLogFormatter
+{
+public:
+    std::string Format(const ASWLog::TASWLogRecord& record, const ASWLog::TASWLogConfig& /*config*/) const override
+    {
+        return std::string(record.Raw ? "raw|" : "line|").append(record.Message);
+    }
+
+    bool FormatsRawEntries() const noexcept override
+    {
+        return true;
+    }
+};
+
 // A faulty user formatter: throws for every line (IASWLogFormatter::Format() may throw; the line is then dropped)
 class TThrowingFormatter final : public ASWLog::IASWLogFormatter
 {
@@ -409,6 +424,7 @@ TTest_ASWLog_TextLogBase::TTest_ASWLog_TextLogBase()
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Log_FormatsFiltersAndCallsAfterEntry, "Log_FormatsFiltersAndCallsAfterEntry");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Log_MinimumLevelOffAllowsOnlyForcedEntries, "Log_MinimumLevelOffAllowsOnlyForcedEntries");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Log_ThrowingWriteDoesNotEscape, "Log_ThrowingWriteDoesNotEscape");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_LogRaw_FormatterCanFormatRawEntries, "LogRaw_FormatterCanFormatRawEntries");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_LogRaw_WritesMessageAsIs, "LogRaw_WritesMessageAsIs");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_OnLogEntry_CallbackCanReconfigureTheLogger, "OnLogEntry_CallbackCanReconfigureTheLogger");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Reconfigure_AppliesNewConfigButKeepsLevel, "Reconfigure_AppliesNewConfigButKeepsLevel");
@@ -1258,6 +1274,40 @@ void TTest_ASWLog_TextLogBase::Test_Log_ThrowingWriteDoesNotEscape()
         "Each dropped entry should be reported");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_LogRaw_FormatterCanFormatRawEntries()
+{
+    // Arrange: a synchronous and an asynchronous logger whose formatter formats raw entries too
+    TMemoryOutput syncOutput;
+    TMemoryOutput asyncOutput;
+    auto syncConfig = MakeQuietConfig();
+    syncConfig.Line.Formatter = std::make_shared<const TRawFormattingFormatter>();
+    auto asyncConfig = MakeAsyncConfig();
+    asyncConfig.Line.Formatter = syncConfig.Line.Formatter;
+    TMemoryTextLog syncLog(syncOutput);
+    TMemoryTextLog asyncLog(asyncOutput);
+    CheckTrue(syncLog.Initialize(syncConfig), "Initialize should succeed");
+    CheckTrue(asyncLog.Initialize(asyncConfig), "Initialize should succeed (async)");
+
+    const auto logEntries = [](TMemoryTextLog& log) {
+            log.LogRaw(ASWLog::Level::Debug, "filtered_raw");
+            log.LogRaw(ASWLog::Level::Info, "partial");
+            log.LogForceRaw(ASWLog::Level::Trace, "forced\n");
+            log.LogInfo("formatted");
+        };
+
+    // Act
+    logEntries(syncLog);
+    logEntries(asyncLog);
+    asyncLog.Flush(); // Waits for the queued entries
+
+    // Assert
+    const std::vector<std::string> expected{ "raw|partial\n", "raw|forced\n\n", "line|formatted\n" };
+    CheckTrue(syncOutput.Lines == expected, "Raw entries should be formatted and get the line ending");
+    CheckTrue(syncOutput.EndsLine == std::vector<bool>{ true, true, true }, "A formatted raw entry should end its line");
+    CheckTrue(asyncOutput.Lines == expected, "Queued raw entries should be formatted and get the line ending");
+    CheckTrue(asyncOutput.EndsLine == std::vector<bool>{ true, true, true }, "A queued formatted raw entry should end its line");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_TextLogBase::Test_LogRaw_WritesMessageAsIs()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_TextLogBase.h b/tests/tests/Test_ASWLog_TextLogBase.h
index 697a6f9..594adf1 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.h
+++ b/tests/tests/Test_ASWLog_TextLogBase.h
@@ -61,6 +61,7 @@ class TTest_ASWLog_TextLogBase : public TTestGroupBase
     void Test_Log_FormatsFiltersAndCallsAfterEntry();
     void Test_Log_MinimumLevelOffAllowsOnlyForcedEntries();
     void Test_Log_ThrowingWriteDoesNotEscape();
+    void Test_LogRaw_FormatterCanFormatRawEntries();
     void Test_LogRaw_WritesMessageAsIs();
     void Test_OnLogEntry_CallbackCanReconfigureTheLogger();
     void Test_Reconfigure_AppliesNewConfigButKeepsLevel();
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index 7a0fbeb..a71b97a 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -31,12 +31,15 @@ limitations under the License.
 #include <cstdlib>
 #include <ctime>
 #include <filesystem>
+#include <format>
 #include <fstream>
 #include <iterator>
 #include <ratio>
 #include <string>
+#include <string_view>
 #include <system_error>
 #include <thread>
+#include <vector>
 
 #if defined(_WIN32)
 #include <windows.h>
@@ -65,6 +68,25 @@ std::string ReadText(const std::filesystem::path& path)
     return std::string((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
 }
 
+// The bytes of 'text' in hex, e.g. "E2 82", for a check's message
+std::string ToHex(std::string_view text)
+{
+    std::string hex;
+    for (const char character : text)
+        hex += std::format("{}{:02X}", hex.empty() ? "" : " ", static_cast<unsigned char>(character));
+
+    return hex;
+}
+
+// 'text' as JSON::AppendString() writes it
+std::string ToJSONString(std::string_view text)
+{
+    std::string output;
+    ASWLog::JSON::AppendString(output, text);
+
+    return output;
+}
+
 } // namespace
 
 //---------------------------------------------------------------------------
@@ -82,6 +104,10 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_GetWindowsEditionName_ProductTypes, "GetWindowsEditionName_ProductTypes");
     RegisterTest(&TTest_ASWLog_Utils::Test_IsRootFolder_DetectsRootFolders, "IsRootFolder_DetectsRootFolders");
     RegisterTest(&TTest_ASWLog_Utils::Test_IsRootFolder_ResolvesRelativePaths, "IsRootFolder_ResolvesRelativePaths");
+    RegisterTest(&TTest_ASWLog_Utils::Test_JSON_AppendString_EscapesQuotesBackslashAndControls, "JSON_AppendString_EscapesQuotesBackslashAndControls");
+    RegisterTest(&TTest_ASWLog_Utils::Test_JSON_AppendString_FindsSpecialCharactersAnywhereInALongText, "JSON_AppendString_FindsSpecialCharactersAnywhereInALongText");
+    RegisterTest(&TTest_ASWLog_Utils::Test_JSON_AppendString_KeepsValidUTF8, "JSON_AppendString_KeepsValidUTF8");
+    RegisterTest(&TTest_ASWLog_Utils::Test_JSON_AppendString_ReplacesInvalidUTF8, "JSON_AppendString_ReplacesInvalidUTF8");
     RegisterTest(&TTest_ASWLog_Utils::Test_MatchesWildcard_Patterns, "MatchesWildcard_Patterns");
     RegisterTest(&TTest_ASWLog_Utils::Test_RenameWithoutReplacing_KeepsExistingTarget, "RenameWithoutReplacing_KeepsExistingTarget");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime, "Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime");
@@ -325,6 +351,121 @@ void TTest_ASWLog_Utils::Test_IsRootFolder_ResolvesRelativePaths()
         CheckFalse(ASWLog::IsRootFolder("."), "\".\" should not be a root folder when the current folder isn't one");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_JSON_AppendString_EscapesQuotesBackslashAndControls()
+{
+    // Arrange: each control character's escape, the short form where JSON has one
+    std::string appended = "key:";
+
+    // Act
+    ASWLog::JSON::AppendString(appended, "value");
+
+    // Assert
+    CheckEquals(std::string("key:\"value\""), appended, "The string should be appended, in quotes");
+    CheckEquals(std::string("\"\""), ToJSONString(""), "An empty text should be an empty string");
+    CheckEquals(std::string(R"("say \"hi\" \\ there")"), ToJSONString(R"(say "hi" \ there)"), "Quotes and backslashes should be escaped");
+    CheckEquals(std::string(R"("a / b ~)" "\x7F" R"(")"), ToJSONString("a / b ~\x7F"), "'/' and DEL should be written as they are");
+    CheckEquals(std::string(R"("line1\nline2\r\n\tend")"), ToJSONString("line1\nline2\r\n\tend"), "Line breaks should be escaped");
+
+    for (int code = 0; code < 0x20; ++code)
+    {
+        std::string expected;
+        switch (code)
+        {
+            case 0x08: expected = "\\b"; break;
+            case 0x09: expected = "\\t"; break;
+            case 0x0A: expected = "\\n"; break;
+            case 0x0C: expected = "\\f"; break;
+            case 0x0D: expected = "\\r"; break;
+            default: expected = std::format("\\u{:04x}", code); break;
+        }
+
+        CheckEquals("\"" + expected + "\"", ToJSONString(std::string(1, static_cast<char>(code))),
+            std::format("Control character 0x{:02X} should be escaped", code));
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_JSON_AppendString_FindsSpecialCharactersAnywhereInALongText()
+{
+    // Arrange: plain text is scanned 8 bytes at a time, so each special character goes at every position of the first
+    // two 8-byte words of a longer text, with what it should become
+    struct TCase
+    {
+        std::string Text;
+        std::string Expected;
+    };
+
+    const std::vector<TCase> specials{
+        { "\"", "\\\"" }, { "\\", "\\\\" }, { std::string(1, '\0'), "\\u0000" }, { "\n", "\\n" }, { "\x1F", "\\u001f" },
+        { " ", " " }, { "\x7F", "\x7F" }, { "\xCE\xBB", "\xCE\xBB" }, { "\xF0\x9F\x98\x80", "\xF0\x9F\x98\x80" },
+        { "\x80", "\xEF\xBF\xBD" }, { "\xFF", "\xEF\xBF\xBD" }, { "\xE2\x82", "\xEF\xBF\xBD" }
+    };
+
+    // Act & Assert
+    for (const auto& special : specials)
+    {
+        for (std::size_t position = 0; position < 16; ++position)
+        {
+            const std::string before(position, 'a');
+            const std::string after(24 - position, 'z');
+            CheckEquals("\"" + before + special.Expected + after + "\"", ToJSONString(before + special.Text + after),
+                std::format("{} at index {} should be found", ToHex(special.Text), position));
+        }
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_JSON_AppendString_KeepsValidUTF8()
+{
+    // Arrange: the first and last character of each UTF-8 length, the characters around the surrogates, and a few
+    // common ones
+    const std::vector<std::string> texts{
+        "\xC2\x80", "\xDF\xBF", "\xE0\xA0\x80", "\xED\x9F\xBF", "\xEE\x80\x80", "\xEF\xBF\xBF", "\xF0\x90\x80\x80",
+        "\xF4\x8F\xBF\xBF", "\xCE\xBB", "\xE2\x82\xAC", "\xF0\x9F\x98\x80", "a\xCE\xBB" "b\xE2\x82\xAC" "c"
+    };
+
+    // Act & Assert
+    for (const auto& text : texts)
+        CheckEquals("\"" + text + "\"", ToJSONString(text), "Valid UTF-8 should be written as it is: " + ToHex(text));
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_JSON_AppendString_ReplacesInvalidUTF8()
+{
+    // Arrange: each invalid text and what it should become, U+FFFD (R) for each longest start of a valid sequence, or
+    // else each byte
+    const std::string R = "\xEF\xBF\xBD";
+    struct TCase
+    {
+        std::string Text;
+        std::string Expected;
+    };
+
+    const std::vector<TCase> cases{
+        { "\x80", R }, // A continuation byte without a lead byte
+        { "a\xBF" "b", "a" + R + "b" },
+        { "\xC0\xAF", R + R }, // Overlong forms: C0 and C1 never start a valid sequence
+        { "\xC1\xBF", R + R },
+        { "\xE0\x80\xAF", R + R + R }, // Overlong: E0 needs A0-BF next
+        { "\xF0\x80\x80\x80", R + R + R + R }, // Overlong: F0 needs 90-BF next
+        { "\xED\xA0\x80", R + R + R }, // A surrogate (U+D800)
+        { "\xF4\x90\x80\x80", R + R + R + R }, // Above U+10FFFF
+        { "\xF5\x80", R + R }, // F5-FF never start a valid sequence
+        { "\xFF", R },
+        { "\xC2", R }, // Cut off at the end
+        { "\xE2\x82", R }, // A cut off sequence is one U+FFFD
+        { "\xE2\x82" "X", R + "X" },
+        { "\xF0\x9F\x98", R },
+        { "\xF0\x9F\x98" "a", R + "a" },
+        { "\xC2\"", R + "\\\"" }, // The character after a cut off sequence is written as usual
+        { "\xCE\xBB\xCE", "\xCE\xBB" + R }
+    };
+
+    // Act & Assert
+    for (const auto& testCase : cases)
+    {
+        CheckEquals("\"" + testCase.Expected + "\"", ToJSONString(testCase.Text),
+            "Invalid UTF-8 should be replaced with U+FFFD: " + ToHex(testCase.Text));
+    }
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_MatchesWildcard_Patterns()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index cf38644..28e8c4f 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -45,6 +45,10 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_GetWindowsEditionName_ProductTypes();
     void Test_IsRootFolder_DetectsRootFolders();
     void Test_IsRootFolder_ResolvesRelativePaths();
+    void Test_JSON_AppendString_EscapesQuotesBackslashAndControls();
+    void Test_JSON_AppendString_FindsSpecialCharactersAnywhereInALongText();
+    void Test_JSON_AppendString_KeepsValidUTF8();
+    void Test_JSON_AppendString_ReplacesInvalidUTF8();
     void Test_MatchesWildcard_Patterns();
     void Test_RenameWithoutReplacing_KeepsExistingTarget();
     void Test_Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime();
diff --git a/tests/tests/UT_Helper_JSON.cpp b/tests/tests/UT_Helper_JSON.cpp
new file mode 100644
index 0000000..00ff8f6
--- /dev/null
+++ b/tests/tests/UT_Helper_JSON.cpp
@@ -0,0 +1,325 @@
+/* **************************************************************************
+UT_Helper_JSON.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "UT_Helper_JSON.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstddef>
+#include <cstdint>
+#include <string_view>
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+// Deeper nesting is rejected, so a malformed line can't exhaust the stack
+constexpr int MaxDepth = 32;
+
+//---------------------------------------------------------------------------
+
+// A strict reader that only checks whether the text is well-formed
+class TJSONChecker
+{
+private:
+    std::string_view m_Text;
+    std::size_t m_Index = 0;
+    int m_Depth = 0;
+
+private:
+    bool IsAtEnd() const
+    {
+        return m_Index >= m_Text.size();
+    }
+
+    unsigned char Peek() const
+    {
+        return IsAtEnd() ? 0 : static_cast<unsigned char>(m_Text[m_Index]);
+    }
+
+    bool Take(char expected)
+    {
+        if (IsAtEnd() || m_Text[m_Index] != expected)
+            return false;
+
+        ++m_Index;
+        return true;
+    }
+
+    void SkipWhitespace()
+    {
+        while (!IsAtEnd() && (Peek() == ' ' || Peek() == '\t' || Peek() == '\n' || Peek() == '\r'))
+            ++m_Index;
+    }
+
+    bool ReadArray()
+    {
+        ++m_Index; // '['
+        SkipWhitespace();
+        if (Take(']'))
+            return true;
+
+        while (true)
+        {
+            if (!ReadValue())
+                return false;
+
+            SkipWhitespace();
+            if (Take(']'))
+                return true;
+
+            if (!Take(','))
+                return false;
+        }
+    }
+
+    bool ReadDigits()
+    {
+        const auto start = m_Index;
+        while (Peek() >= '0' && Peek() <= '9')
+            ++m_Index;
+
+        return m_Index > start;
+    }
+
+    bool ReadLiteral(std::string_view literal)
+    {
+        if (m_Text.substr(m_Index, literal.size()) != literal)
+            return false;
+
+        m_Index += literal.size();
+        return true;
+    }
+
+    bool ReadNumber()
+    {
+        Take('-');
+        if (Take('0'))
+        {
+            if (Peek() >= '0' && Peek() <= '9')
+                return false; // No leading zeros
+        }
+        else if (!ReadDigits())
+        {
+            return false;
+        }
+
+        if (Take('.') && !ReadDigits())
+            return false;
+
+        if (Take('e') || Take('E'))
+        {
+            if (!Take('+'))
+                Take('-');
+
+            if (!ReadDigits())
+                return false;
+        }
+
+        return true;
+    }
+
+    bool ReadObject()
+    {
+        ++m_Index; // '{'
+        SkipWhitespace();
+        if (Take('}'))
+            return true;
+
+        while (true)
+        {
+            SkipWhitespace();
+            if (Peek() != '"' || !ReadString())
+                return false;
+
+            SkipWhitespace();
+            if (!Take(':') || !ReadValue())
+                return false;
+
+            SkipWhitespace();
+            if (Take('}'))
+                return true;
+
+            if (!Take(','))
+                return false;
+        }
+    }
+
+    bool ReadString()
+    {
+        ++m_Index; // '"'
+
+        while (!IsAtEnd())
+        {
+            const unsigned char character = Peek();
+            if (character == '"')
+            {
+                ++m_Index;
+                return true;
+            }
+
+            if (character < 0x20)
+                return false;
+
+            if (character == '\\')
+            {
+                ++m_Index;
+                const char escaped = static_cast<char>(Peek());
+                ++m_Index;
+
+                if (escaped == 'u')
+                {
+                    for (int digit = 0; digit < 4; ++digit, ++m_Index)
+                    {
+                        const unsigned char hex = Peek();
+                        if (!((hex >= '0' && hex <= '9') || (hex >= 'a' && hex <= 'f') || (hex >= 'A' && hex <= 'F')))
+                            return false;
+                    }
+                }
+                else if (std::string_view("\"\\/bfnrt").find(escaped) == std::string_view::npos)
+                {
+                    return false;
+                }
+            }
+            else if (character >= 0x80)
+            {
+                if (!ReadUTF8Character())
+                    return false;
+            }
+            else
+            {
+                ++m_Index;
+            }
+        }
+
+        return false; // Unclosed
+    }
+
+    // Decodes one multi-byte UTF-8 character and checks it: the right number of continuation bytes, the shortest form,
+    // no surrogate and nothing above U+10FFFF
+    bool ReadUTF8Character()
+    {
+        const unsigned char lead = Peek();
+        int length = 0;
+        std::uint32_t codePoint = 0;
+
+        if ((lead & 0xE0) == 0xC0)
+        {
+            length = 2;
+            codePoint = lead & 0x1F;
+        }
+        else if ((lead & 0xF0) == 0xE0)
+        {
+            length = 3;
+            codePoint = lead & 0x0F;
+        }
+        else if ((lead & 0xF8) == 0xF0)
+        {
+            length = 4;
+            codePoint = lead & 0x07;
+        }
+        else
+        {
+            return false;
+        }
+
+        ++m_Index;
+
+        for (int count = 1; count < length; ++count, ++m_Index)
+        {
+            if ((Peek() & 0xC0) != 0x80)
+                return false;
+
+            codePoint = (codePoint << 6) | (Peek() & 0x3F);
+        }
+
+        constexpr std::uint32_t Smallest[] = { 0, 0, 0x80, 0x800, 0x10000 };
+        return codePoint >= Smallest[length] && codePoint <= 0x10FFFF && (codePoint < 0xD800 || codePoint > 0xDFFF);
+    }
+
+    bool ReadValue()
+    {
+        SkipWhitespace();
+        if (++m_Depth > MaxDepth)
+            return false;
+
+        bool isValid = false;
+        switch (Peek())
+        {
+            case '{':
+                isValid = ReadObject();
+                break;
+
+            case '[':
+                isValid = ReadArray();
+                break;
+
+            case '"':
+                isValid = ReadString();
+                break;
+
+            case 't':
+                isValid = ReadLiteral("true");
+                break;
+
+            case 'f':
+                isValid = ReadLiteral("false");
+                break;
+
+            case 'n':
+                isValid = ReadLiteral("null");
+                break;
+
+            default:
+                isValid = ReadNumber();
+                break;
+        }
+
+        --m_Depth;
+        return isValid;
+    }
+
+public:
+    explicit TJSONChecker(std::string_view text)
+        : m_Text(text)
+    {
+    }
+
+    bool IsObjectLine()
+    {
+        return Peek() == '{' && ReadValue() && IsAtEnd();
+    }
+};
+
+} // namespace
+
+//---------------------------------------------------------------------------
+bool IsJSONObjectLine(std::string_view text)
+{
+    return TJSONChecker(text).IsObjectLine();
+}
+
+} // ASWUnitTests
diff --git a/tests/tests/UT_Helper_JSON.h b/tests/tests/UT_Helper_JSON.h
new file mode 100644
index 0000000..bb70d61
--- /dev/null
+++ b/tests/tests/UT_Helper_JSON.h
@@ -0,0 +1,40 @@
+/* **************************************************************************
+UT_Helper_JSON.h
+Author: Anthony S. West - ASW Software
+
+JSON helpers shared by the unit tests.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#ifndef UT_Helper_JSONH
+#define UT_Helper_JSONH
+//---------------------------------------------------------------------------
+#include <string_view>
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+// True if 'text' is exactly one JSON object (RFC 8259), with no whitespace around it, whose strings are valid UTF-8
+// with no raw control characters: what a JSON Lines line holds without its line ending. Written independently of
+// ASWLog's JSON code, so the tests don't check that code against itself.
+bool IsJSONObjectLine(std::string_view text);
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef UT_Helper_JSONH
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index e46a4c1..ea36cc6 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -292,6 +292,10 @@
             <DependentOn>..\..\..\tests\UT_Helper_DateTime.h</DependentOn>
             <BuildOrder>44</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\UT_Helper_JSON.cpp">
+            <DependentOn>..\..\..\tests\UT_Helper_JSON.h</DependentOn>
+            <BuildOrder>49</BuildOrder>
+        </CppCompile>
         <CppCompile Include="ASWLogTests_VCL_GUI.cpp">
             <BuildOrder>0</BuildOrder>
         </CppCompile>

From 9ee00a5a24eb2ba8739dfc83844b26e302012cd1 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Fri, 9 Oct 2026 00:51:12 -0700
Subject: [PATCH 09/38] Add structured fields and scoped context

---
 ASWLog/ASWLog_Base.cpp                        |  39 +-
 ASWLog/ASWLog_Base.h                          |  13 +-
 ASWLog/ASWLog_Config.h                        |   1 +
 ASWLog/ASWLog_CrashHandler.cpp                |  91 +++
 ASWLog/ASWLog_CrashHandler.h                  |   3 +-
 ASWLog/ASWLog_Fields.cpp                      | 374 +++++++++++
 ASWLog/ASWLog_Fields.h                        | 451 +++++++++++++
 ASWLog/ASWLog_Formatter.cpp                   |  20 +-
 ASWLog/ASWLog_Formatter.h                     |  17 +-
 ASWLog/ASWLog_Interface.h                     | 153 +++++
 ASWLog/ASWLog_TextLogBase.cpp                 |   7 +
 ASWLog/ASWLog_TextLogBase.h                   |   4 +-
 ASWLog/ASWLog_Types.h                         |  35 +-
 CHANGELOG.md                                  |  27 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 README.md                                     |   2 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 example/src/main.cpp                          |  10 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_CrashHandler.cpp      | 125 ++++
 tests/tests/Test_ASWLog_CrashHandler.h        |   4 +
 tests/tests/Test_ASWLog_Fields.cpp            | 605 ++++++++++++++++++
 tests/tests/Test_ASWLog_Fields.h              |  66 ++
 tests/tests/Test_ASWLog_Formatter.cpp         | 123 ++++
 tests/tests/Test_ASWLog_Formatter.h           |   4 +
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 28 files changed, 2179 insertions(+), 22 deletions(-)
 create mode 100644 ASWLog/ASWLog_Fields.cpp
 create mode 100644 ASWLog/ASWLog_Fields.h
 create mode 100644 tests/tests/Test_ASWLog_Fields.cpp
 create mode 100644 tests/tests/Test_ASWLog_Fields.h

diff --git a/ASWLog/ASWLog_Base.cpp b/ASWLog/ASWLog_Base.cpp
index 35a4f31..bafed07 100644
--- a/ASWLog/ASWLog_Base.cpp
+++ b/ASWLog/ASWLog_Base.cpp
@@ -79,6 +79,25 @@ class TReportingErrorScope
     TReportingErrorScope& operator=(const TReportingErrorScope&) = delete;
 };
 
+//---------------------------------------------------------------------------
+
+void ForgetCopiedViews(TASWLogRecord& record) noexcept;
+
+//---------------------------------------------------------------------------
+
+/*
+  ForgetCopiedViews
+
+  Empties the views of a kept record whose texts and fields are held in copies beside it (see TBacktraceEntry)
+*/
+void ForgetCopiedViews(TASWLogRecord& record) noexcept
+{
+    record.Message = {};
+    record.Category = {};
+    record.Fields = nullptr;
+    record.Scope = nullptr;
+}
+
 } // namespace
 
 //---------------------------------------------------------------------------
@@ -171,12 +190,15 @@ void TASWLogBase::KeepInBacktrace(const TASWLogRecord& record)
     if (m_BacktraceCapacity == 0)
         return; // Switched off since the gate let the entry in
 
+    // The fields are copied first, so a failed copy changes nothing
+    Detail::TOwnedFields fields;
+    fields.AssignMerged(record.Scope, record.GetOwnFields());
+
     if (m_Backtrace.size() < m_BacktraceCapacity)
     {
         // The texts are copied first, so a failed copy leaves no empty entry behind
-        TBacktraceEntry entry{ record, std::string(record.Message), std::string(record.Category) };
-        entry.Record.Message = {};
-        entry.Record.Category = {};
+        TBacktraceEntry entry{ record, std::string(record.Message), std::string(record.Category), std::move(fields) };
+        ForgetCopiedViews(entry.Record);
         m_Backtrace.push_back(std::move(entry));
     }
     else
@@ -187,9 +209,9 @@ void TASWLogBase::KeepInBacktrace(const TASWLogRecord& record)
         std::string category(record.Category);
         entry.Message.assign(record.Message);
         entry.Category.swap(category);
+        entry.Fields = std::move(fields);
         entry.Record = record;
-        entry.Record.Message = {};
-        entry.Record.Category = {};
+        ForgetCopiedViews(entry.Record);
         m_BacktraceOldest = (m_BacktraceOldest + 1) % m_BacktraceCapacity;
     }
 
@@ -345,6 +367,9 @@ void TASWLogBase::Write(const TASWLogRecord& record) noexcept
     TASWLogRecord stampedRecord = record;
     StampRecord(stampedRecord);
 
+    if (stampedRecord.Scope == nullptr)
+        stampedRecord.Scope = TASWLogScope::GetCurrent();
+
     // A derived logger's WriteRecord() may throw (e.g. out of memory, or a custom logger's own error); logging must
     // never throw into the application, so the entry is dropped instead
     try
@@ -398,10 +423,14 @@ void TASWLogBase::WriteBacktrace()
 
     for (const auto& entry : entries)
     {
+        const auto fields = entry.Fields.Get();
+
         auto record = entry.Record;
         record.Message = entry.Message;
         record.Category = entry.Category;
+        record.Fields = &fields;
         record.Forced = true;
+
         WriteRecord(record);
     }
 
diff --git a/ASWLog/ASWLog_Base.h b/ASWLog/ASWLog_Base.h
index 56ad7c9..0e3de69 100644
--- a/ASWLog/ASWLog_Base.h
+++ b/ASWLog/ASWLog_Base.h
@@ -116,9 +116,10 @@ class TASWLogBase : public IASWLog
     // record's Message and Category are empty)
     struct TBacktraceEntry
     {
-        TASWLogRecord Record;
+        TASWLogRecord Record; // Its Message, Category, Fields and Scope are empty: the copies below hold them
         std::string Message;
         std::string Category;
+        Detail::TOwnedFields Fields; // The entry's fields and its scopes', merged
     };
 
     // The backtrace, guarded by m_BacktraceMutex: at most m_BacktraceCapacity entries, the oldest at m_BacktraceOldest
@@ -250,10 +251,10 @@ class TASWLogBase : public IASWLog
     void StampRecord(TASWLogRecord& record) const noexcept;
 
     // For a crash handler (see TASWTextLogBase): if the backtrace's lock is free, calls visit(record, index, count) for
-    // each kept entry, oldest first ('record' is marked Forced, and its Message and Category refer to the kept copies,
-    // valid during the call), then forgets them if 'mustClear', and returns true. Returns false at once if the lock is
-    // busy (e.g. the crashed thread holds it). Allocates nothing itself, except that clearing frees the copies, so with
-    // a visitor that doesn't allocate and 'mustClear' false, it can run in a signal handler.
+    // each kept entry, oldest first ('record' is marked Forced, and its Message, Category and Fields refer to the kept
+    // copies, valid during the call), then forgets them if 'mustClear', and returns true. Returns false at once if the
+    // lock is busy (e.g. the crashed thread holds it). Allocates nothing itself, except that clearing frees the copies,
+    // so with a visitor that doesn't allocate and 'mustClear' false, it can run in a signal handler.
     template<typename TVisit>
     bool VisitBacktraceForCrash(TVisit&& visit, bool mustClear)
     {
@@ -265,9 +266,11 @@ class TASWLogBase : public IASWLog
         for (std::size_t index = 0; index < count; ++index)
         {
             const auto& entry = m_Backtrace[(m_BacktraceOldest + index) % count];
+            const auto fields = entry.Fields.Get();
             TASWLogRecord record = entry.Record;
             record.Message = entry.Message;
             record.Category = entry.Category;
+            record.Fields = &fields;
             record.Forced = true;
             visit(static_cast<const TASWLogRecord&>(record), index, count);
         }
diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 8f40655..805db24 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -239,6 +239,7 @@ struct TASWLineConfig
     bool ShowPeakWorkingSet = false;
     bool ShowFunctionName   = false; // The function that logged the entry
     bool ShowSourceLine     = false; // The source file and line that logged the entry
+    bool ShowFields         = true; // The entry's fields (its own and its scopes'; see TASWLogScope), if it has any
 };
 
 
diff --git a/ASWLog/ASWLog_CrashHandler.cpp b/ASWLog/ASWLog_CrashHandler.cpp
index 2b0d794..692289d 100644
--- a/ASWLog/ASWLog_CrashHandler.cpp
+++ b/ASWLog/ASWLog_CrashHandler.cpp
@@ -540,6 +540,76 @@ void UninstallCrashHandlers() noexcept
 namespace Detail
 {
 
+namespace
+{
+
+// The room a fixed-layout line keeps after its fields: the rest of the line's own text, part of the message, and the
+// line ending
+constexpr std::size_t FieldsReserved = 96;
+
+//---------------------------------------------------------------------------
+
+bool AppendCrashFields(TCrashText& line, const TASWLogRecord& record, bool isJSON) noexcept;
+
+//---------------------------------------------------------------------------
+
+/*
+  AppendCrashFields
+
+  Appends the entry's fields as the text layout writes them (key="text" key=17, separated by spaces) or, for 'isJSON',
+  as JSON members ("key":"text","key":17), each only if it fits whole while FieldsReserved characters stay free (a long
+  text is cut to fit), and returns false if none was written. Allocates nothing.
+*/
+bool AppendCrashFields(TCrashText& line, const TASWLogRecord& record, bool isJSON) noexcept
+{
+    bool hasField = false;
+
+    record.ForEachField([&line, &hasField, isJSON](const TASWLogField& field) {
+                    const std::size_t used = line.GetSize() + FieldsReserved;
+                    if (used >= TCrashText::Capacity)
+                        return;
+
+                    // Built aside, so that a field that doesn't fit is left out whole
+                    const std::size_t room = TCrashText::Capacity - used;
+                    TCrashText text;
+                    if (hasField)
+                        text.Append(isJSON ? "," : " ");
+
+                    if (isJSON)
+                    {
+                        text.AppendJSONString(field.Key, TCrashText::Capacity - room);
+                        text.Append(":");
+                    }
+                    else
+                    {
+                        text.Append(field.Key);
+                        text.Append("=");
+                    }
+
+                    if (field.Value.GetKind() == ValueKind::Text)
+                    {
+                        text.AppendJSONString(field.Value.GetText(), TCrashText::Capacity - room);
+                    }
+                    else
+                    {
+                        char buffer[ScalarValueBufferSize];
+                        text.Append(WriteScalarValue(buffer, field.Value, isJSON));
+                    }
+
+                    if (text.GetSize() <= room)
+                    {
+                        line.Append(text.View());
+                        hasField = true;
+                    }
+                });
+
+    return hasField;
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
 /////////////////////////////////////////////////////////////////////////////
 // TCrashText
 /////////////////////////////////////////////////////////////////////////////
@@ -757,6 +827,17 @@ void AppendCrashJSONLine(TCrashText& line, const TASWLogRecord& record, bool use
     line.Append(",\"tid\":");
     line.AppendDecimal(record.ThreadId);
 
+    if (record.HasFields())
+    {
+        const std::size_t sizeBefore = line.GetSize();
+        line.Append(",\"fields\":{");
+
+        if (AppendCrashFields(line, record, true))
+            line.Append("}");
+        else
+            line.Truncate(sizeBefore);
+    }
+
     if (record.Raw)
         line.Append(",\"raw\":true");
 
@@ -786,6 +867,16 @@ void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRL
     line.AppendDecimal(record.ProcessId);
     line.Append("][T:");
     line.AppendDecimal(record.ThreadId);
+
+    if (record.HasFields())
+    {
+        const std::size_t sizeBefore = line.GetSize();
+        line.Append("][");
+
+        if (!AppendCrashFields(line, record, false))
+            line.Truncate(sizeBefore);
+    }
+
     line.Append("]: ");
     line.Append(record.Message);
 
diff --git a/ASWLog/ASWLog_CrashHandler.h b/ASWLog/ASWLog_CrashHandler.h
index dc507af..5bc09af 100644
--- a/ASWLog/ASWLog_CrashHandler.h
+++ b/ASWLog/ASWLog_CrashHandler.h
@@ -76,7 +76,8 @@ struct TASWCrashHandlerOptions
 //   since converting to local time isn't async-signal-safe. The buffered entries are flushed only if the logger's lock
 //   is free (fflush isn't on POSIX's list of async-signal-safe functions, but no other thread can use the file then).
 //   The backtrace's lines get the same layout, with their own level and category (after the level, as "[Net]", or as
-//   "category" in JSON), and only if the backtrace's lock is free.
+//   "category" in JSON), and only if the backtrace's lock is free. The lines show the entry's fields too (see
+//   TASWLogScope; the crash line has the crashing thread's scope fields), after the thread id, as far as they fit.
 // - If a logger's lock stays busy until WaitTimeout has passed (e.g. the crash happened while that thread was
 //   writing an entry), its buffered entries are lost and only the fixed-layout lines (backtrace and crash line) are
 //   written, straight to the file.
diff --git a/ASWLog/ASWLog_Fields.cpp b/ASWLog/ASWLog_Fields.cpp
new file mode 100644
index 0000000..6bac6bb
--- /dev/null
+++ b/ASWLog/ASWLog_Fields.cpp
@@ -0,0 +1,374 @@
+/* **************************************************************************
+ASWLog_Fields.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_Fields.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <atomic>
+#include <charconv>
+#include <cmath>
+#include <span>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWLog_Utils.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+namespace
+{
+
+// The calling thread's innermost scope. Constant-initialized (no dynamic initialization on a thread's first use), so a
+// crash handler can read it, even in a POSIX signal handler.
+thread_local const TASWLogScope* CurrentScope = nullptr;
+
+// How many scopes exist, on all threads. GetCurrent() reads CurrentScope only while there are some: reading a
+// thread_local costs a library call with some compilers (MinGW's GCC emulates thread-local storage), which added ~65 ns
+// to every written entry. A thread sees its own scopes counted, which is all GetCurrent() needs, so relaxed is enough.
+std::atomic<std::size_t> LiveScopeCount{ 0 };
+
+//---------------------------------------------------------------------------
+
+void AppendFieldValue(std::string& output, const TASWLogValue& value, bool isJSON);
+
+//---------------------------------------------------------------------------
+
+/*
+  AppendFieldValue
+
+  Appends a field's value: text as a JSON string (in the text layouts too), anything else as Detail::WriteScalarValue()
+  writes it
+*/
+void AppendFieldValue(std::string& output, const TASWLogValue& value, bool isJSON)
+{
+    if (value.GetKind() == ValueKind::Text)
+    {
+        JSON::AppendString(output, value.GetText());
+        return;
+    }
+
+    char buffer[Detail::ScalarValueBufferSize];
+    output.append(Detail::WriteScalarValue(buffer, value, isJSON));
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+namespace Detail
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TOwnedFields
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TOwnedFields::TOwnedFields(const TOwnedFields& other)
+{
+    Assign(other.Get());
+}
+
+//---------------------------------------------------------------------------
+TOwnedFields& TOwnedFields::operator=(const TOwnedFields& other)
+{
+    if (this != &other)
+        Assign(other.Get());
+
+    return *this;
+}
+
+//---------------------------------------------------------------------------
+void TOwnedFields::Assign(std::span<const TASWLogField> fields)
+{
+    std::size_t textSize = 0;
+    for (const auto& field : fields)
+    {
+        textSize += field.Key.size();
+        if (field.Value.GetKind() == ValueKind::Text)
+            textSize += field.Value.GetText().size();
+    }
+
+    // Built aside and swapped in, so a failed allocation leaves the fields as they were (and 'fields' may be this
+    // object's own)
+    std::vector<char> text;
+    text.reserve(textSize);
+    std::vector<TASWLogField> copies;
+    copies.reserve(fields.size());
+
+    // 'text' never grows past its reserve, so the views into it stay valid
+    const auto copyText = [&text](std::string_view source) {
+            const std::size_t start = text.size();
+            text.insert(text.end(), source.begin(), source.end());
+
+            return std::string_view(text.data() + start, source.size());
+        };
+
+    for (const auto& field : fields)
+    {
+        TASWLogField copy{ copyText(field.Key), field.Value };
+        if (field.Value.GetKind() == ValueKind::Text)
+            copy.Value = TASWLogValue(copyText(field.Value.GetText()));
+
+        copies.push_back(copy);
+    }
+
+    m_Text.swap(text);
+    m_Fields.swap(copies);
+}
+
+//---------------------------------------------------------------------------
+void TOwnedFields::AssignMerged(const TASWLogScope* scope, std::span<const TASWLogField> fields)
+{
+    if (scope == nullptr && fields.empty())
+    {
+        Clear();
+        return;
+    }
+
+    std::vector<TASWLogField> merged;
+    ForEachLogField(scope, fields, [&merged](const TASWLogField& field) {
+                merged.push_back(field);
+            });
+    Assign(merged);
+}
+
+//---------------------------------------------------------------------------
+void TOwnedFields::Clear() noexcept
+{
+    m_Fields.clear();
+    m_Text.clear();
+}
+
+//---------------------------------------------------------------------------
+std::span<const TASWLogField> TOwnedFields::Get() const noexcept
+{
+    return m_Fields;
+}
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// Free functions
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+void AppendFieldsJSON(std::string& output, const TASWLogScope* scope, std::span<const TASWLogField> fields)
+{
+    const std::size_t start = output.size();
+    bool hasField = false;
+
+    output += "\"fields\":{";
+    ForEachLogField(scope, fields, [&output, &hasField](const TASWLogField& field) {
+                if (hasField)
+                    output += ',';
+
+                JSON::AppendString(output, field.Key);
+                output += ':';
+                AppendFieldValue(output, field.Value, true);
+                hasField = true;
+            });
+
+    if (!hasField)
+    {
+        output.resize(start);
+        return;
+    }
+
+    output += "},";
+}
+
+//---------------------------------------------------------------------------
+bool AppendFieldsText(std::string& output, const TASWLogScope* scope, std::span<const TASWLogField> fields,
+    std::string_view prefix, std::string_view suffix)
+{
+    bool hasField = false;
+
+    ForEachLogField(scope, fields, [&output, &hasField, prefix](const TASWLogField& field) {
+                output.append(hasField ? std::string_view(" ") : prefix);
+                output.append(field.Key);
+                output += '=';
+                AppendFieldValue(output, field.Value, false);
+                hasField = true;
+            });
+
+    if (hasField)
+        output.append(suffix);
+
+    return hasField;
+}
+
+//---------------------------------------------------------------------------
+std::string_view WriteScalarValue(char (& buffer)[ScalarValueBufferSize], const TASWLogValue& value, bool isJSON) noexcept
+{
+    char* const end = buffer + ScalarValueBufferSize;
+    std::to_chars_result result{ buffer, std::errc() };
+
+    switch (value.GetKind())
+    {
+        case ValueKind::Int:
+            result = std::to_chars(buffer, end, value.GetInt());
+            break;
+
+        case ValueKind::UInt:
+            result = std::to_chars(buffer, end, value.GetUInt());
+            break;
+
+        case ValueKind::Double:
+        {
+            const double number = value.GetDouble();
+            if (isJSON && !std::isfinite(number))
+                return std::isnan(number) ? "\"NaN\"" : (number > 0 ? "\"Infinity\"" : "\"-Infinity\"");
+
+            result = std::to_chars(buffer, end, number);
+            break;
+        }
+
+        case ValueKind::Bool:
+            return value.GetBool() ? "true" : "false";
+
+        case ValueKind::Text:
+            break;
+    }
+
+    return std::string_view(buffer, static_cast<std::size_t>(result.ptr - buffer));
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace Detail
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogContext
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+std::span<const TASWLogField> TASWLogContext::GetFields() const noexcept
+{
+    return m_Fields.Get();
+}
+
+//---------------------------------------------------------------------------
+bool TASWLogContext::IsEmpty() const noexcept
+{
+    return m_Fields.Get().empty();
+}
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogScope
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWLogScope::TASWLogScope(std::initializer_list<TASWLogField> fields) noexcept
+    : m_Parent(CurrentScope)
+{
+    try
+    {
+        m_Fields.Assign(std::span<const TASWLogField>(fields.begin(), fields.size()));
+    }
+    catch (...)
+    {
+    }
+
+    LiveScopeCount.fetch_add(1, std::memory_order_relaxed);
+    CurrentScope = this;
+}
+
+//---------------------------------------------------------------------------
+TASWLogScope::TASWLogScope(const TASWLogContext& context, std::initializer_list<TASWLogField> fields) noexcept
+    : m_Parent(CurrentScope)
+{
+    try
+    {
+        // The context's fields first, so that 'fields' come later and replace those with the same key
+        std::vector<TASWLogField> combined(context.GetFields().begin(), context.GetFields().end());
+        combined.insert(combined.end(), fields.begin(), fields.end());
+        m_Fields.Assign(combined);
+    }
+    catch (...)
+    {
+    }
+
+    LiveScopeCount.fetch_add(1, std::memory_order_relaxed);
+    CurrentScope = this;
+}
+
+//---------------------------------------------------------------------------
+TASWLogScope::~TASWLogScope()
+{
+    // Ended out of order, a scope leaves the inner one current rather than reinstating one that has ended
+    if (CurrentScope == this)
+        CurrentScope = m_Parent;
+
+    LiveScopeCount.fetch_sub(1, std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+TASWLogContext TASWLogScope::Capture() noexcept
+{
+    TASWLogContext context;
+
+    try
+    {
+        context.m_Fields.AssignMerged(CurrentScope, {});
+    }
+    catch (...)
+    {
+        context.m_Fields.Clear();
+    }
+
+    return context;
+}
+
+//---------------------------------------------------------------------------
+const TASWLogScope* TASWLogScope::GetCurrent() noexcept
+{
+    if (LiveScopeCount.load(std::memory_order_relaxed) == 0)
+        return nullptr;
+
+    return CurrentScope;
+}
+
+//---------------------------------------------------------------------------
+std::span<const TASWLogField> TASWLogScope::GetFields() const noexcept
+{
+    return m_Fields.Get();
+}
+
+//---------------------------------------------------------------------------
+const TASWLogScope* TASWLogScope::GetParent() const noexcept
+{
+    return m_Parent;
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_Fields.h b/ASWLog/ASWLog_Fields.h
new file mode 100644
index 0000000..ed8eb86
--- /dev/null
+++ b/ASWLog/ASWLog_Fields.h
@@ -0,0 +1,451 @@
+/* **************************************************************************
+ASWLog_Fields.h
+Author: Anthony S. West - ASW Software
+
+A light-weight logging tool.
+
+Source for the ASWLog structured fields and scoped context.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_FieldsH
+#define ASWLog_FieldsH
+//---------------------------------------------------------------------------
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <span>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+class TASWLogContext;
+class TASWLogScope;
+
+//---------------------------------------------------------------------------
+
+/*
+  ValueKind enum
+
+  What a field's value holds (see TASWLogValue).
+*/
+enum class ValueKind : std::uint8_t
+{
+    Int, // std::int64_t, from any signed integer
+    UInt, // std::uint64_t, from any unsigned integer
+    Double, // From any floating-point type
+    Bool,
+    Text, // A view of the caller's text
+};
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogValue
+//
+// A field's value: a signed or unsigned integer, a double, a bool, or text. Made implicitly from those types, so a
+// field reads {"orderId", 17}, {"total", 9.99}, {"cached", true} or {"user", userName}. Text is a view of the caller's
+// characters (a string literal, std::string or std::string_view), not a copy, so making one never allocates; a logger
+// copies what it keeps beyond the call. Characters (char, wchar_t, ...), enums, pointers other than to text, and null
+// pointers aren't accepted; turn other types into a number or text first (e.g. with std::format).
+/////////////////////////////////////////////////////////////////////////////
+class TASWLogValue
+{
+private:
+    template<typename T>
+    static constexpr bool IsCharacter = std::is_same_v<T, char> || std::is_same_v<T, wchar_t> || std::is_same_v<T, char8_t> ||
+        std::is_same_v<T, char16_t> || std::is_same_v<T, char32_t>;
+
+    union
+    {
+        std::int64_t m_Int;
+        std::uint64_t m_UInt;
+        double m_Double;
+        bool m_Bool;
+        const char* m_TextData;
+    };
+
+    std::size_t m_TextSize = 0;
+    ValueKind m_Kind;
+
+public:
+    constexpr TASWLogValue() noexcept
+        : m_Int(0),
+          m_Kind(ValueKind::Int)
+    {
+    }
+
+    template<typename T>
+    requires(std::is_integral_v<T> && std::is_signed_v<T> && !IsCharacter<T>)
+    constexpr TASWLogValue(T value) noexcept
+        : m_Int(value),
+          m_Kind(ValueKind::Int)
+    {
+    }
+
+    template<typename T>
+    requires(std::is_integral_v<T> && std::is_unsigned_v<T> && !std::is_same_v<T, bool> && !IsCharacter<T>)
+    constexpr TASWLogValue(T value) noexcept
+        : m_UInt(value),
+          m_Kind(ValueKind::UInt)
+    {
+    }
+
+    template<typename T>
+    requires std::is_floating_point_v<T>
+    constexpr TASWLogValue(T value) noexcept
+        : m_Double(static_cast<double>(value)),
+          m_Kind(ValueKind::Double)
+    {
+    }
+
+    // A template, so that only a bool matches it: a pointer or an enum would otherwise become a bool
+    template<typename T>
+    requires std::is_same_v<T, bool>
+    constexpr TASWLogValue(T value) noexcept
+        : m_Bool(value),
+          m_Kind(ValueKind::Bool)
+    {
+    }
+
+    constexpr TASWLogValue(std::string_view value) noexcept
+        : m_TextData(value.data()),
+          m_TextSize(value.size()),
+          m_Kind(ValueKind::Text)
+    {
+    }
+
+    // Without it, a string literal would become a bool
+    constexpr TASWLogValue(const char* value) noexcept
+        : TASWLogValue(std::string_view(value != nullptr ? value : ""))
+    {
+    }
+
+    TASWLogValue(const std::string& value) noexcept
+        : TASWLogValue(std::string_view(value))
+    {
+    }
+
+    template<typename T>
+    requires IsCharacter<T>
+    TASWLogValue(T) = delete; // A character: use text ("x") or a number (static_cast<int>(c))
+
+    TASWLogValue(std::nullptr_t) = delete;
+
+    // The value, for the kind GetKind() returns
+    [[nodiscard]] constexpr bool GetBool() const noexcept
+    {
+        return m_Bool;
+    }
+
+    [[nodiscard]] constexpr double GetDouble() const noexcept
+    {
+        return m_Double;
+    }
+
+    [[nodiscard]] constexpr std::int64_t GetInt() const noexcept
+    {
+        return m_Int;
+    }
+
+    [[nodiscard]] constexpr ValueKind GetKind() const noexcept
+    {
+        return m_Kind;
+    }
+
+    [[nodiscard]] constexpr std::string_view GetText() const noexcept
+    {
+        return std::string_view(m_TextData, m_TextSize);
+    }
+
+    [[nodiscard]] constexpr std::uint64_t GetUInt() const noexcept
+    {
+        return m_UInt;
+    }
+};
+
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogField
+//
+// A named value attached to a log entry, by the logging call (e.g. logger.LogInfo("Order placed", {{"orderId", 17}}))
+// or by a TASWLogScope. Like the value's text, the key is a view of the caller's characters.
+/////////////////////////////////////////////////////////////////////////////
+struct TASWLogField
+{
+    std::string_view Key;
+    TASWLogValue Value;
+};
+
+//---------------------------------------------------------------------------
+// Internals, used by the classes below and the loggers. Not part of the public interface.
+//---------------------------------------------------------------------------
+namespace Detail
+{
+
+// The size of the buffer WriteScalarValue() writes to
+inline constexpr std::size_t ScalarValueBufferSize = 32;
+
+//---------------------------------------------------------------------------
+
+/*
+    AppendFieldsJSON
+
+    Appends the fields ForEachLogField() gives for 'scope' and 'fields' as a JSON object's member,
+    "fields":{"<key>":<value>,...}, followed by a comma, or nothing if there are none. Texts are JSON strings, other
+    values as WriteScalarValue() writes them. In its own source file, so the formatters don't inline it into their
+    usual path, which has no fields.
+*/
+void AppendFieldsJSON(std::string& output, const TASWLogScope* scope, std::span<const TASWLogField> fields);
+
+/*
+    AppendFieldsText
+
+    Appends the fields ForEachLogField() gives for 'scope' and 'fields' as the text layouts write them,
+    <key>=<value> separated by spaces, texts in double quotes and escaped like JSON strings (so a value can't break the
+    line or the brackets around it), other values as WriteScalarValue() writes them, between 'prefix' and 'suffix'.
+    Appends nothing, and returns false, if there are none. In its own source file, like AppendFieldsJSON().
+*/
+bool AppendFieldsText(std::string& output, const TASWLogScope* scope, std::span<const TASWLogField> fields,
+    std::string_view prefix = {}, std::string_view suffix = {});
+
+/*
+    WriteScalarValue
+
+    Writes a value that isn't text into 'buffer' and returns it: an integer in decimal, a double in the shortest form
+    that reads back the same (e.g. 9.99), a bool as true or false. For JSON ('isJSON'), a NaN or infinite double, which
+    a JSON number can't hold, is written as the string "NaN", "Infinity" or "-Infinity", quotes included. Allocates
+    nothing.
+*/
+[[nodiscard]] std::string_view WriteScalarValue(char (& buffer)[ScalarValueBufferSize], const TASWLogValue& value,
+    bool isJSON) noexcept;
+
+/////////////////////////////////////////////////////////////////////////////
+// TOwnedFields
+//
+// A copy of fields that owns their keys and texts (the fields' views refer to its own buffer), for the scopes, a
+// captured context, and a logger that keeps an entry beyond the call (the backtrace, an asynchronous OnLogEntry).
+/////////////////////////////////////////////////////////////////////////////
+class TOwnedFields
+{
+private:
+    std::vector<char> m_Text; // Moving it keeps its buffer, so the views stay valid
+    std::vector<TASWLogField> m_Fields;
+
+public:
+    TOwnedFields() = default;
+    TOwnedFields(const TOwnedFields& other);
+    TOwnedFields(TOwnedFields&& other) noexcept = default;
+    TOwnedFields& operator=(const TOwnedFields& other);
+    TOwnedFields& operator=(TOwnedFields&& other) noexcept = default;
+
+    // Replaces the fields with copies of 'fields'. Throws std::bad_alloc if they can't be copied; the fields are
+    // then unchanged.
+    void Assign(std::span<const TASWLogField> fields);
+    // Replaces the fields with copies of those ForEachLogField() gives for 'scope' and 'fields', each key once, so the
+    // copy no longer depends on the thread's scopes. Throws like Assign().
+    void AssignMerged(const TASWLogScope* scope, std::span<const TASWLogField> fields);
+    void Clear() noexcept;
+    [[nodiscard]] std::span<const TASWLogField> Get() const noexcept;
+};
+
+// Calls visit(field) for each field of 'scope' and the scopes it is in, from the outermost one in, then for each of
+// 'fields', duplicate keys included, until visit returns false; returns false if it did. Allocates nothing.
+template<typename TVisit>
+bool VisitAllLogFields(const TASWLogScope* scope, std::span<const TASWLogField> fields, TVisit& visit);
+
+} // namespace Detail
+
+//---------------------------------------------------------------------------
+
+/*
+    ForEachLogField
+
+    Calls visit(field) once for each key among the fields of 'scope' and the scopes it is in, and 'fields' (an entry's
+    own fields, which come last): in the order the keys first appear, from the outermost scope in, each with the value
+    of its last appearance, so an inner scope's value beats an outer one's, and the entry's own value beats both.
+    Allocates nothing, so a crash handler can use it too. TASWLogRecord::ForEachField() calls it for an entry.
+*/
+template<typename TVisit>
+void ForEachLogField(const TASWLogScope* scope, std::span<const TASWLogField> fields, TVisit&& visit);
+
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogContext
+//
+// A copy of a thread's scope fields (see TASWLogScope::Capture()), to apply on another thread with
+// TASWLogScope scope(context);. It owns its keys and texts, so it can be copied and kept as long as needed.
+/////////////////////////////////////////////////////////////////////////////
+class TASWLogContext
+{
+private:
+    friend class TASWLogScope;
+
+    Detail::TOwnedFields m_Fields; // Each key once, in the order ForEachLogField() gives them
+
+public:
+    // Its fields, each key once
+    [[nodiscard]] std::span<const TASWLogField> GetFields() const noexcept;
+    [[nodiscard]] bool IsEmpty() const noexcept;
+};
+
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogScope
+//
+// Fields that every entry logged on this thread carries while the scope exists, e.g. at the top of a request handler:
+//     ASWLog::TASWLogScope scope{{"requestId", requestId}};
+// Every entry the thread logs until the scope ends has requestId, in the helper functions it calls too, so one
+// request's entries can be picked out of interleaved traffic. Scopes nest: an inner scope's fields add to the outer
+// ones', and replace those with the same key (see ForEachLogField()). They don't cross threads; to take them to
+// another thread (e.g. a thread pool), Capture() them and open a scope from the copy there:
+//     auto context = ASWLog::TASWLogScope::Capture();
+//     pool.Submit([context] { ASWLog::TASWLogScope scope(context); ... });
+// An asynchronous logger keeps the fields an entry had when it was logged.
+//
+// A scope copies its keys and texts, so they may be temporaries. It belongs to the thread that made it and must end
+// on it, in the reverse order of making (as local variables do). If the copy can't be made (out of memory), the scope
+// has no fields rather than throwing.
+/////////////////////////////////////////////////////////////////////////////
+class TASWLogScope
+{
+private:
+    const TASWLogScope* m_Parent; // The thread's scope before this one, or null
+    Detail::TOwnedFields m_Fields;
+
+public:
+    // A copy of the calling thread's scope fields, each key once, to use on another thread. Empty if the thread has no
+    // scope, or if the copy can't be made (out of memory).
+    [[nodiscard]] static TASWLogContext Capture() noexcept;
+
+    // The calling thread's innermost scope, or null
+    [[nodiscard]] static const TASWLogScope* GetCurrent() noexcept;
+
+public:
+    explicit TASWLogScope(std::initializer_list<TASWLogField> fields) noexcept;
+    // The fields of 'context' (see Capture()), plus 'fields', which replace those with the same key
+    explicit TASWLogScope(const TASWLogContext& context, std::initializer_list<TASWLogField> fields = {}) noexcept;
+    ~TASWLogScope();
+
+    TASWLogScope(const TASWLogScope&) = delete;
+    TASWLogScope& operator=(const TASWLogScope&) = delete;
+
+    // This scope's own fields, as given
+    [[nodiscard]] std::span<const TASWLogField> GetFields() const noexcept;
+
+    // The scope this one is in, or null
+    [[nodiscard]] const TASWLogScope* GetParent() const noexcept;
+};
+
+//---------------------------------------------------------------------------
+
+namespace Detail
+{
+
+//---------------------------------------------------------------------------
+template<typename TVisit>
+bool VisitAllLogFields(const TASWLogScope* scope, std::span<const TASWLogField> fields, TVisit& visit)
+{
+    if (scope != nullptr && !VisitAllLogFields(scope->GetParent(), scope->GetFields(), visit))
+        return false;
+
+    for (const auto& field : fields)
+    {
+        if (!visit(field))
+            return false;
+    }
+
+    return true;
+}
+
+} // namespace Detail
+
+//---------------------------------------------------------------------------
+template<typename TVisit>
+void ForEachLogField(const TASWLogScope* scope, std::span<const TASWLogField> fields, TVisit&& visit)
+{
+    if (scope == nullptr)
+    {
+        // The usual case, without a scope: only the entry's own fields, which rarely repeat a key
+        for (std::size_t index = 0; index < fields.size(); ++index)
+        {
+            bool isRepeated = false;
+            for (std::size_t earlier = 0; earlier < index && !isRepeated; ++earlier)
+                isRepeated = fields[earlier].Key == fields[index].Key;
+
+            if (isRepeated)
+                continue;
+
+            const TASWLogField* winner = &fields[index];
+            for (std::size_t later = index + 1; later < fields.size(); ++later)
+            {
+                if (fields[later].Key == fields[index].Key)
+                    winner = &fields[later];
+            }
+
+            visit(*winner);
+        }
+
+        return;
+    }
+
+    std::size_t position = 0;
+    auto visitCandidate = [&](const TASWLogField& candidate) {
+            bool isRepeated = false;
+            const TASWLogField* winner = &candidate;
+            std::size_t index = 0;
+            auto findWinner = [&](const TASWLogField& other) {
+                    if (other.Key == candidate.Key)
+                    {
+                        if (index < position)
+                        {
+                            isRepeated = true;
+                            return false;
+                        }
+
+                        winner = &other;
+                    }
+
+                    ++index;
+
+                    return true;
+                };
+
+            Detail::VisitAllLogFields(scope, fields, findWinner);
+            ++position;
+
+            if (!isRepeated)
+                visit(*winner);
+
+            return true;
+        };
+
+    Detail::VisitAllLogFields(scope, fields, visitCandidate);
+}
+
+} // namespace ASWLog
+
+#endif // ASWLog_FieldsH
diff --git a/ASWLog/ASWLog_Formatter.cpp b/ASWLog/ASWLog_Formatter.cpp
index 0b94285..9fe306c 100644
--- a/ASWLog/ASWLog_Formatter.cpp
+++ b/ASWLog/ASWLog_Formatter.cpp
@@ -237,6 +237,9 @@ std::string TASWJSONFormatter::Format(const TASWLogRecord& record, const TASWLog
         AppendJSONNumber(line, "line", record.Location.line());
     }
 
+    if (config.Line.ShowFields && record.HasFields())
+        Detail::AppendFieldsJSON(line, record.Scope, record.GetOwnFields());
+
     if (record.Raw)
         line += "\"raw\":true,";
 
@@ -307,7 +310,7 @@ std::string TASWPatternFormatter::Format(const TASWLogRecord& record, const TASW
     line.reserve(record.Message.size() + 256);
 
     const TMemoryUsage memoryUsage = m_UsesMemoryUsage ? GetMemoryUsage() : TMemoryUsage{};
-    std::string fileName;
+    std::string text; // A field's value that has to be built first
 
     for (const auto& part : m_Parts)
     {
@@ -355,14 +358,20 @@ std::string TASWPatternFormatter::Format(const TASWLogRecord& record, const TASW
 
             case TField::File:
                 // As TASWTextFormatter writes it
-                fileName = std::filesystem::path(record.Location.file_name()).filename().string();
-                value = fileName;
+                text = std::filesystem::path(record.Location.file_name()).filename().string();
+                value = text;
                 break;
 
             case TField::Line:
                 value = ToDecimal(buffer, record.Location.line());
                 break;
 
+            case TField::Fields:
+                text.clear();
+                Detail::AppendFieldsText(text, record.Scope, record.GetOwnFields());
+                value = text;
+                break;
+
             case TField::Message:
                 value = record.Message;
                 break;
@@ -401,7 +410,7 @@ std::size_t TASWPatternFormatter::ParsePlaceholder(std::size_t start)
         { "time", TField::Time }, { "level", TField::Level }, { "category", TField::Category },
         { "pid", TField::ProcessId }, { "tid", TField::ThreadId }, { "ws", TField::WorkingSet },
         { "pws", TField::PeakWorkingSet }, { "function", TField::Function }, { "file", TField::File },
-        { "line", TField::Line }, { "message", TField::Message }
+        { "line", TField::Line }, { "fields", TField::Fields }, { "message", TField::Message }
     };
 
     const std::string_view pattern = m_Pattern;
@@ -586,6 +595,9 @@ std::string TASWTextFormatter::FormatLine(const TASWLogRecord& record, const TAS
         std::format_to(std::back_inserter(line), "[{}:{}]", fullPath.filename().string(), record.Location.line());
     }
 
+    if (config.Line.ShowFields && record.HasFields())
+        Detail::AppendFieldsText(line, record.Scope, record.GetOwnFields(), "[", "]");
+
     line += ": ";
     line.append(record.Message);
     return line;
diff --git a/ASWLog/ASWLog_Formatter.h b/ASWLog/ASWLog_Formatter.h
index 814b790..4ee74dc 100644
--- a/ASWLog/ASWLog_Formatter.h
+++ b/ASWLog/ASWLog_Formatter.h
@@ -91,6 +91,9 @@ class IASWLogFormatter
 //                       ShowPeakWorkingSet)
 //   "function"          the function that logged the entry (ShowFunctionName)
 //   "file", "line"      its source file's name (without folders) and line, a number (ShowSourceLine)
+//   "fields"            an object with the entry's fields, its own and its scopes' (see TASWLogScope), each key once,
+//                       if it has any (ShowFields): numbers and bools as such, texts as strings, and a NaN or infinite
+//                       double as the string "NaN", "Infinity" or "-Infinity"
 //   "raw"               true for a LogRaw()/LogForceRaw() entry, which gets a line of its own like any other
 //   "message"           the message, always
 // Texts are escaped as RFC 8259 asks, with each invalid UTF-8 sequence replaced by U+FFFD (see JSON::AppendString()),
@@ -122,6 +125,8 @@ class TASWJSONFormatter : public IASWLogFormatter
 //   {ws}, {pws}     the process's working set and peak working set in bytes (the memory is read once per line)
 //   {function}      the function that logged the entry
 //   {file}, {line}  its source file's name (without folders) and line
+//   {fields}        the entry's fields, its own and its scopes' (see TASWLogScope), as in TASWTextFormatter's layout:
+//                   requestId="8f3a" orderId=17; nothing if it has none
 //   {message}       the message
 // A minimum width after the name, e.g. {level:5}, pads the field with spaces on the right (counted in bytes). Text
 // inside the braces around the name is written only when the field isn't empty: punctuation and spaces as they are,
@@ -149,6 +154,7 @@ class TASWPatternFormatter : public IASWLogFormatter
         Function,
         File,
         Line,
+        Fields,
         Message,
     };
 
@@ -184,10 +190,13 @@ class TASWPatternFormatter : public IASWLogFormatter
 // TASWTextFormatter
 //
 // The built-in text layout, used when TASWLogConfig::Line.Formatter is empty:
-// "[time][LEVEL][category][P:pid][T:tid][WS:bytes][PWS:bytes][function][file:line]: message", where each bracketed
-// field is written only if its TASWLineConfig option is on (ShowTimestamp, ShowLevel, ShowCategory, ShowProcessId,
-// ShowThreadId, ShowWorkingSet, ShowPeakWorkingSet, ShowFunctionName, ShowSourceLine), and the category only if the
-// entry has one. For another layout, see TASWPatternFormatter; for JSON Lines, TASWJSONFormatter.
+// "[time][LEVEL][category][P:pid][T:tid][WS:bytes][PWS:bytes][function][file:line][fields]: message", where each
+// bracketed field is written only if its TASWLineConfig option is on (ShowTimestamp, ShowLevel, ShowCategory,
+// ShowProcessId, ShowThreadId, ShowWorkingSet, ShowPeakWorkingSet, ShowFunctionName, ShowSourceLine, ShowFields), and
+// the category and the fields only if the entry has them. The fields, its own and its scopes' (see TASWLogScope), read
+// [requestId="8f3a" orderId=17 cached=true]: each key once, texts in double quotes with '"', '\' and control
+// characters escaped as in JSON, numbers and bools as they are. For another layout, see TASWPatternFormatter; for JSON
+// Lines, TASWJSONFormatter.
 /////////////////////////////////////////////////////////////////////////////
 class TASWTextFormatter : public IASWLogFormatter
 {
diff --git a/ASWLog/ASWLog_Interface.h b/ASWLog/ASWLog_Interface.h
index ddf5da7..5dc5439 100644
--- a/ASWLog/ASWLog_Interface.h
+++ b/ASWLog/ASWLog_Interface.h
@@ -30,6 +30,7 @@ limitations under the License.
 #include <concepts>
 #include <exception>
 #include <format>
+#include <initializer_list>
 #include <memory>
 #include <source_location>
 #include <string>
@@ -159,6 +160,16 @@ class IASWLog
         return record;
     }
 
+    // Writes an entry with fields: the record points to the list, which lives during the call
+    void WriteWithFields(Level level, std::string_view message, std::initializer_list<TASWLogField> fields,
+        std::source_location loc, bool raw, bool forced) noexcept
+    {
+        const std::span<const TASWLogField> ownFields(fields.begin(), fields.size());
+        TASWLogRecord record = MakeRecord(level, message, loc, raw, forced);
+        record.Fields = &ownFields;
+        Write(record);
+    }
+
 public:
     virtual ~IASWLog() = default;
 
@@ -281,6 +292,71 @@ class IASWLog
         Write(MakeRecord(Level::Critical, msg, loc, false, false));
     }
 
+    // --- Non-virtual Inline Logging Methods With Fields ---
+    // As above, with fields for this entry, e.g. LogInfo("Order placed", {{"orderId", 17}, {"total", 9.99}}). They
+    // come after the fields of the thread's scopes (see TASWLogScope) and replace those with the same key. The keys and
+    // texts are only read during the call. A text logger writes them before the message (see
+    // TASWLineConfig::ShowFields), but not for a LogRaw() entry, which it writes as is.
+    inline void Log(Level level, std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(level, msg, fields, loc, false, false);
+    }
+
+    inline void LogRaw(Level level, std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(level, msg, fields, loc, true, false);
+    }
+
+    inline void LogForce(Level level, std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(level, msg, fields, loc, false, true);
+    }
+
+    inline void LogForceRaw(Level level, std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(level, msg, fields, loc, true, true);
+    }
+
+    inline void LogTrace(std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(Level::Trace, msg, fields, loc, false, false);
+    }
+
+    inline void LogDebug(std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(Level::Debug, msg, fields, loc, false, false);
+    }
+
+    inline void LogInfo(std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(Level::Info, msg, fields, loc, false, false);
+    }
+
+    inline void LogWarn(std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(Level::Warn, msg, fields, loc, false, false);
+    }
+
+    inline void LogError(std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(Level::Error, msg, fields, loc, false, false);
+    }
+
+    inline void LogCritical(std::string_view msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWithFields(Level::Critical, msg, fields, loc, false, false);
+    }
+
     // --- Non-virtual Inline Template Format Methods ---
     // Each passes on the caller's source location, captured by TASWFormatString. The format string is checked against
     // the arguments at compile time. Use RuntimeFormat() to wrap run time format strings. A formatting error at run
@@ -350,6 +426,83 @@ class IASWLog
     {
         LogFmt(Level::Critical, fmt, std::forward<Args>(args) ...);
     }
+
+    // --- Non-virtual Inline Template Format Methods With Fields ---
+    // As above, with fields for this entry (see the logging methods with fields), first since the format arguments
+    // come last, e.g. LogInfoFmt({{"orderId", id}}, "Order {} placed", id).
+    template<typename ... Args>
+    inline void LogFmt(Level level, std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        if (ShouldLog(level))
+            Log(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogRawFmt(Level level, std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        if (ShouldLog(level))
+            LogRaw(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogForceFmt(Level level, std::initializer_list<TASWLogField> fields,
+        TASWFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (level != Level::Off && IsEnabled())
+            LogForce(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogForceRawFmt(Level level, std::initializer_list<TASWLogField> fields,
+        TASWFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (level != Level::Off && IsEnabled())
+            LogForceRaw(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogTraceFmt(std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Trace, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogDebugFmt(std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Debug, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogInfoFmt(std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Info, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogWarnFmt(std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Warn, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogErrorFmt(std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Error, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogCriticalFmt(std::initializer_list<TASWLogField> fields, TASWFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Critical, fields, fmt, std::forward<Args>(args) ...);
+    }
 };
 
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index 5221756..a11677f 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -347,6 +347,7 @@ void TASWTextLogBase::OnCrash(std::string_view message, bool isInSignalHandler,
     record.LogLevel = Level::Critical;
     record.Message = message;
     record.Forced = true;
+    record.Scope = TASWLogScope::GetCurrent(); // The crashing thread's
     StampRecord(record);
 
     const bool writesLine = IsEnabled() && m_WritesCrashLine.load(std::memory_order_relaxed);
@@ -452,6 +453,8 @@ bool TASWTextLogBase::QueueRecord(const TASWLogRecord& record)
     entry.Record = record;
     entry.Record.Message = {};
     entry.Record.Category = {};
+    entry.Record.Fields = nullptr;
+    entry.Record.Scope = nullptr;
     entry.EndsLine = IsFormatted(record, *config);
     entry.MustFlush = record.LogLevel >= config->Async.WaitAtLevel;
 
@@ -459,6 +462,7 @@ bool TASWTextLogBase::QueueRecord(const TASWLogRecord& record)
     {
         entry.Message = record.Message;
         entry.Category = record.Category;
+        entry.Fields.AssignMerged(record.Scope, record.GetOwnFields());
         entry.CallbackConfig = config;
     }
 
@@ -1111,9 +1115,12 @@ void TASWTextLogBase::WriteQueuedEntries(std::deque<TQueuedEntry>& entries, std:
         if (!entry.IsWritten || entry.CallbackConfig == nullptr)
             continue;
 
+        const auto fields = entry.Fields.Get();
         auto record = entry.Record;
         record.Message = entry.Message;
         record.Category = entry.Category;
+        record.Fields = &fields;
+
         DispatchLogCallback(*entry.CallbackConfig, record, entry.Line);
     }
 }
diff --git a/ASWLog/ASWLog_TextLogBase.h b/ASWLog/ASWLog_TextLogBase.h
index 1c5da6c..5074a28 100644
--- a/ASWLog/ASWLog_TextLogBase.h
+++ b/ASWLog/ASWLog_TextLogBase.h
@@ -105,9 +105,11 @@ class TASWTextLogBase : public TASWLogBase
     // An entry queued by an asynchronous logger (see TASWAsyncConfig), for the worker to write
     struct TQueuedEntry
     {
-        TASWLogRecord Record; // Its Message and Category are empty: the texts are in Message and Category, if needed
+        // Its Message, Category, Fields and Scope are empty: the copies below hold them, if needed
+        TASWLogRecord Record;
         std::string Message; // The record's message, copied only if OnLogEntry will be called
         std::string Category; // The record's category, likewise
+        Detail::TOwnedFields Fields; // The record's fields and its scopes', merged, likewise
         std::string Line; // The line to write: formatted, or the raw text
         std::shared_ptr<const TASWLogConfig> CallbackConfig; // Set only if OnLogEntry will be called
         std::uint64_t Sequence = 0;
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index c7e9b3c..4959194 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -35,10 +35,13 @@ limitations under the License.
 #include <filesystem>
 #include <optional>
 #include <source_location>
+#include <span>
 #include <string>
 #include <string_view>
 #include <system_error>
 //---------------------------------------------------------------------------
+#include "ASWLog_Fields.h"
+//---------------------------------------------------------------------------
 
 namespace ASWLog
 {
@@ -418,8 +421,9 @@ struct TASWLogError
 // by a multi-log to its loggers) keeps them. A category logger (see TASWCategoryLog) fills in Category and, if it has
 // a level of its own, CategoryLevel.
 //
-// Message, Category and Location refer to the caller's data, so they are only valid during the call; a logger,
-// formatter or callback that keeps a record beyond it must copy them.
+// Message, Category, Location, Fields and Scope refer to the caller's data, so they are only valid during the call; a
+// logger, formatter or callback that keeps a record beyond it must copy them (the fields with ForEachField(), since the
+// scope is the thread's).
 /////////////////////////////////////////////////////////////////////////////
 struct TASWLogRecord
 {
@@ -440,6 +444,33 @@ struct TASWLogRecord
     std::source_location Location; // Where the entry was logged
     std::uint32_t ProcessId = 0; // The OS process id (see GetCurrentOSProcessId())
     std::uint32_t ThreadId = 0; // The OS id of the thread that logged the entry (see GetCurrentOSThreadId())
+    // The entry's own fields, from the logging call (e.g. LogInfo("Order placed", {{"orderId", 17}})), or null. A
+    // pointer to the list rather than the list itself, because every logging call builds a record, even when the entry
+    // is filtered out, and a 16-byte member measurably slowed that down.
+    const std::span<const TASWLogField>* Fields = nullptr;
+    // The innermost scope of the thread that logged the entry (see TASWLogScope), filled in by TASWLogBase::Write()
+    // like the Timestamp, if still null; null if the thread has none
+    const TASWLogScope* Scope = nullptr;
+
+    // Calls visit(field) for each of the entry's fields, its scopes' and its own, each key once, the innermost value
+    // winning (see ForEachLogField()). Allocates nothing.
+    template<typename TVisit>
+    void ForEachField(TVisit&& visit) const
+    {
+        ForEachLogField(Scope, GetOwnFields(), visit);
+    }
+
+    // The entry's own fields (see Fields), which may be empty
+    [[nodiscard]] std::span<const TASWLogField> GetOwnFields() const noexcept
+    {
+        return Fields != nullptr ? *Fields : std::span<const TASWLogField>();
+    }
+
+    // True if the entry may have fields (its own, or a scope; a scope may have none)
+    [[nodiscard]] bool HasFields() const noexcept
+    {
+        return (Fields != nullptr && !Fields->empty()) || Scope != nullptr;
+    }
 };
 
 //---------------------------------------------------------------------------
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 484cd2b..c08481b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -83,6 +83,33 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   custom formatter can format raw entries too by overriding the new
   `IASWLogFormatter::FormatsRawEntries()` (false by default), and
   `JSON::AppendString()` writes a text as an escaped JSON string.
+- Structured fields and scoped context (new `ASWLog_Fields.h`; add
+  `ASWLog_Fields.cpp` to projects that list the ASWLog sources). Every
+  logging method has an overload that takes fields for that entry, e.g.
+  `logger.LogInfo("Order placed", {{"orderId", 17}, {"total", 9.99}})`,
+  and every `*Fmt` method one with the fields first, e.g.
+  `logger.LogInfoFmt({{"orderId", id}}, "Order {} placed", id)`. A value
+  is a signed or unsigned integer, a double, a bool or text, viewed rather
+  than copied, so the call doesn't allocate; characters, enums and
+  pointers other than to text are rejected at compile time. A
+  `TASWLogScope`, e.g. `ASWLog::TASWLogScope scope{{"requestId", id}};`,
+  adds its fields to every entry the thread logs while it exists, also in
+  the functions it calls; scopes nest, and each key is written once, the
+  entry's own value winning over a scope's and an inner scope's over an
+  outer one's. Scopes stay on their thread: `TASWLogScope::Capture()`
+  copies the current ones into a `TASWLogContext`, and
+  `TASWLogScope scope(context);` applies it on another thread, e.g. in a
+  thread pool. The built-in layout writes the fields before the message,
+  `[requestId="8f3a" orderId=17 total=9.99]: Order placed`, text always
+  in quotes and escaped (hide them with the new `Line.ShowFields`); the
+  pattern formatter has `{fields}`, and the JSON formatter writes a
+  `"fields"` object (a NaN or infinite double as the string `"NaN"`,
+  `"Infinity"` or `"-Infinity"`). A `LogRaw()` entry is still written as
+  is by the text layouts. The backtrace, an asynchronous logger's
+  `OnLogEntry` and the fixed-layout crash lines keep the fields, and the
+  crash line gets the crashing thread's scope fields. `TASWLogRecord`
+  gains `Fields` and `Scope` (both pointers, so a filtered call costs no
+  more), read with `ForEachField()`.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5f0a8a9..8ff3738 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -28,6 +28,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_ConsoleLog.h
     ASWLog/ASWLog_CrashHandler.cpp
     ASWLog/ASWLog_CrashHandler.h
+    ASWLog/ASWLog_Fields.cpp
+    ASWLog/ASWLog_Fields.h
     ASWLog/ASWLog_FileLog.cpp
     ASWLog/ASWLog_FileLog.h
     ASWLog/ASWLog_Formatter.cpp
diff --git a/Deploy.bat b/Deploy.bat
index 9b38d1d..3428670 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -84,6 +84,10 @@ call :CopyFile "ASWLog\ASWLog_CrashHandler.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Cras
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_CrashHandler.h" "%TARGET_DIR%\ASWLog\ASWLog_CrashHandler.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_Fields.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Fields.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_Fields.h" "%TARGET_DIR%\ASWLog\ASWLog_Fields.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_FileLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_FileLog.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_FileLog.h" "%TARGET_DIR%\ASWLog\ASWLog_FileLog.h"
diff --git a/README.md b/README.md
index 1b82163..e1b4693 100644
--- a/README.md
+++ b/README.md
@@ -41,6 +41,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   assigned to `TASWLogConfig::Line.Formatter`).
 - JSON Lines output for log shippers and tools such as `jq`: one escaped JSON object per entry
   (`ASWLog::TASWJSONFormatter`, assigned to `TASWLogConfig::Line.Formatter`).
+- Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
+  entry on the thread carries, e.g. `ASWLog::TASWLogScope scope{{"requestId", id}};` (`ASWLog_Fields.h`).
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
   or derive a new text logger from `TASWTextLogBase` and implement only its output.
 
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index f9f1b73..80045fc 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -155,6 +155,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>13</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_Fields.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_Fields.h</DependentOn>
+            <BuildOrder>15</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_FileLog.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_FileLog.h</DependentOn>
             <BuildOrder>5</BuildOrder>
diff --git a/example/src/main.cpp b/example/src/main.cpp
index 4aaa746..f752fd8 100644
--- a/example/src/main.cpp
+++ b/example/src/main.cpp
@@ -28,6 +28,7 @@ limitations under the License.
 #include "ASWLog_CategoryLog.h"
 #include "ASWLog_ConsoleLog.h"
 #include "ASWLog_CrashHandler.h"
+#include "ASWLog_Fields.h"
 #include "ASWLog_FileLog.h"
 #include "ASWLog_MultiLog.h"
 #include "ASWLog_Utils.h"
@@ -214,6 +215,15 @@ int main(int argc, char* argv[])
     dbLogger.LogInfo("This Db entry is below the Db category's own level (Warn), so it is skipped.");
     dbLogger.LogWarn("This Db entry is at the Db category's own level, so it is written.");
 
+    // Example of fields: an entry's own, and a scope's, which every entry logged on this thread carries while the scope
+    // exists, e.g. [requestId="8f3a" orderId=17 total=9.99]
+    std::cout << "Testing fields and scopes...\n";
+    {
+        const ASWLog::TASWLogScope requestScope{ { "requestId", "8f3a" } };
+        globalLogger.LogInfo("Order placed", { { "orderId", 17 }, { "total", 9.99 } });
+        netLogger.LogDebug("This Net entry carries the request's scope fields too.");
+    }
+
     globalLogger.LogInfo("Application terminated naturally via main exit block.");
     std::cout << "Execution completed.\n";
 
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index bdeb847..c7bfdd6 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -37,6 +37,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Config.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_ConsoleLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_CrashHandler.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_Fields.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_FileLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Formatter.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_MultiLog.cpp"
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index 1a58a4b..6f76ec1 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -170,6 +170,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>33</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_Fields.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_Fields.h</DependentOn>
+            <BuildOrder>39</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_FileLog.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_FileLog.h</DependentOn>
             <BuildOrder>3</BuildOrder>
@@ -226,6 +230,10 @@
             <DependentOn>..\tests\Test_ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>34</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_Fields.cpp">
+            <DependentOn>..\tests\Test_ASWLog_Fields.h</DependentOn>
+            <BuildOrder>40</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_FileLog.cpp">
             <DependentOn>..\tests\Test_ASWLog_FileLog.h</DependentOn>
             <BuildOrder>22</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_CrashHandler.cpp b/tests/tests/Test_ASWLog_CrashHandler.cpp
index dcd64cc..f24be8b 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.cpp
+++ b/tests/tests/Test_ASWLog_CrashHandler.cpp
@@ -37,8 +37,10 @@ limitations under the License.
 #include <initializer_list>
 #include <iostream>
 #include <iterator>
+#include <limits>
 #include <memory>
 #include <mutex>
+#include <span>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -563,8 +565,11 @@ TTest_ASWLog_CrashHandler::TTest_ASWLog_CrashHandler()
     : inherited("ASWLog_CrashHandler_Tests")
 {
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_CutsALongTextButStaysValid, "AppendCrashJSONLine_CutsALongTextButStaysValid");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_ShowsTheFields, "AppendCrashJSONLine_ShowsTheFields");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_UsesTheFixedLayout, "AppendCrashJSONLine_UsesTheFixedLayout");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding, "AppendCrashLine_CutsALongMessageButKeepsTheEnding");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_FieldsThatDontFitAreLeftOut, "AppendCrashLine_FieldsThatDontFitAreLeftOut");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheFields, "AppendCrashLine_ShowsTheFields");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheCategory, "AppendCrashLine_ShowsTheCategory");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_UsesTheFixedLayout, "AppendCrashLine_UsesTheFixedLayout");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_CrashProcess_AbortWritesTheCrashLine, "CrashProcess_AbortWritesTheCrashLine");
@@ -577,6 +582,7 @@ TTest_ASWLog_CrashHandler::TTest_ASWLog_CrashHandler()
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_CrashProcess_TerminateWritesTheExceptionAndFlushes, "CrashProcess_TerminateWritesTheExceptionAndFlushes");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_ConsoleLogWritesTheLineToStdErr, "HandleCrash_ConsoleLogWritesTheLineToStdErr");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_DisabledLoggerIsOnlyFlushed, "HandleCrash_DisabledLoggerIsOnlyFlushed");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_CrashLineHasTheThreadsScopeFields, "HandleCrash_CrashLineHasTheThreadsScopeFields");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_FlushesAndWritesTheCrashLine, "HandleCrash_FlushesAndWritesTheCrashLine");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy, "HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_SkipsClosedAndDestroyedLoggers, "HandleCrash_SkipsClosedAndDestroyedLoggers");
@@ -671,6 +677,35 @@ void TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_CutsALongTextButStaysVa
     }
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_ShowsTheFields()
+{
+    // Arrange: a kept entry with fields of each kind
+    using namespace std::chrono;
+    const ASWLog::TASWLogField own[] = {
+        { "user", "a\"my" }, { "n", 17 }, { "x", 9.5 }, { "ok", true }, { "nan", std::numeric_limits<double>::quiet_NaN() }
+    };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+
+    ASWLog::TASWLogRecord record;
+    record.Timestamp = sys_days{ year{ 2026 } / 10 / 4 } + hours(12) + minutes(34) + seconds(56) + milliseconds(789);
+    record.LogLevel = ASWLog::Level::Debug;
+    record.Message = "kept";
+    record.ProcessId = 12;
+    record.ThreadId = 345;
+    record.Fields = &ownFields;
+
+    // Act
+    ASWLog::Detail::TCrashText line;
+    ASWLog::Detail::AppendCrashJSONLine(line, record, false);
+
+    // Assert
+    CheckEquals(std::string(R"({"time":"2026-10-04T12:34:56.789Z","epoch_ms":1791117296789,"level":"DEBUG","pid":12,"tid":345,)"
+        R"("fields":{"user":"a\"my","n":17,"x":9.5,"ok":true,"nan":"NaN"},"message":"kept"})" "\n"), std::string(line.View()),
+        "The fields should follow the thread id, as an object");
+    CheckEquals(ASWLog::TASWJSONFormatter().Format(record, ASWLog::TASWLogConfig()) + "\n", std::string(line.View()),
+        "The fixed layout should match the JSON formatter's default fields");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_UsesTheFixedLayout()
 {
     // Arrange: a crash line, and a raw backtrace entry from a category
@@ -727,6 +762,75 @@ void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_CutsALongMessageButKeepsThe
     CheckEndsWith(text, "x\r\n", "The cut line should still end with the line ending");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_FieldsThatDontFitAreLeftOut()
+{
+    // Arrange: a text field longer than the buffer, then one that no longer fits after it; and a field whose key alone
+    // is too long, between two that fit
+    const std::string longText(3000, 'v');
+    const ASWLog::TASWLogField own[] = { { "long", longText }, { "after", 1 } };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+
+    ASWLog::TASWLogRecord record;
+    record.LogLevel = ASWLog::Level::Critical;
+    record.Message = "msg";
+    record.Fields = &ownFields;
+
+    const std::string longKey(2000, 'k');
+    const ASWLog::TASWLogField keyed[] = { { "a", 1 }, { longKey, 2 }, { "z", 3 } };
+    const std::span<const ASWLog::TASWLogField> keyedFields(keyed);
+
+    auto keyedRecord = record;
+    keyedRecord.Fields = &keyedFields;
+
+    // Act
+    ASWLog::Detail::TCrashText textLine;
+    ASWLog::Detail::AppendCrashLine(textLine, record, true);
+    ASWLog::Detail::TCrashText jsonLine;
+    ASWLog::Detail::AppendCrashJSONLine(jsonLine, record, true);
+    ASWLog::Detail::TCrashText keyedTextLine;
+    ASWLog::Detail::AppendCrashLine(keyedTextLine, keyedRecord, true);
+    ASWLog::Detail::TCrashText keyedJSONLine;
+    ASWLog::Detail::AppendCrashJSONLine(keyedJSONLine, keyedRecord, true);
+
+    // Assert
+    CheckEndsWith(std::string(keyedTextLine.View()), "[a=1 z=3]: msg\r\n", "A field whose key doesn't fit should be left out whole");
+    CheckEndsWith(std::string(keyedJSONLine.View()), R"("fields":{"a":1,"z":3},"message":"msg"})" "\r\n",
+        "A field whose key doesn't fit should be left out of the JSON line whole");
+
+    const std::string text(textLine.View());
+    const std::string json(jsonLine.View());
+    CheckContains(text, "[long=\"vvv", "The long text should be written, cut to fit");
+    CheckNotContains(text, "after=", "A field that doesn't fit should be left out whole");
+    CheckEndsWith(text, "v\"]: msg\r\n", "The cut text should be closed, and the message should still fit");
+    CheckNotContains(json, "\"after\"", "A field that doesn't fit should be left out of the JSON line too");
+    CheckEndsWith(json, "v\"},\"message\":\"msg\"}\r\n", "The JSON line should close the fields and keep the message");
+    CheckTrue(IsJSONObjectLine(json.substr(0, json.size() - 2)), "The JSON line should be one JSON object");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheFields()
+{
+    // Arrange: a kept entry with its own fields
+    using namespace std::chrono;
+    const ASWLog::TASWLogField own[] = { { "user", "amy" }, { "n", 17 } };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+
+    ASWLog::TASWLogRecord record;
+    record.Timestamp = sys_days{ year{ 2026 } / 10 / 8 } + hours(1) + minutes(2) + seconds(3) + milliseconds(4);
+    record.LogLevel = ASWLog::Level::Debug;
+    record.Message = "kept";
+    record.ProcessId = 12;
+    record.ThreadId = 345;
+    record.Fields = &ownFields;
+
+    // Act
+    ASWLog::Detail::TCrashText line;
+    ASWLog::Detail::AppendCrashLine(line, record, false);
+
+    // Assert
+    CheckEquals(std::string("[2026-10-08T01:02:03.004Z][DEBUG][P:12][T:345][user=\"amy\" n=17]: kept\n"), std::string(line.View()),
+        "The fields should follow the thread id, as in the built-in layout");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_UsesTheFixedLayout()
 {
     // Arrange
@@ -965,6 +1069,27 @@ void TTest_ASWLog_CrashHandler::Test_HandleCrash_DisabledLoggerIsOnlyFlushed()
         "A disabled logger should be flushed, without the crash line");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_HandleCrash_CrashLineHasTheThreadsScopeFields()
+{
+    // Arrange: two loggers, one whose lock another thread holds
+    ASWLog::TASWFileLog log;
+    CheckTrue(log.Initialize(MakeCrashTestConfig("scoped.log")), "Initialize should succeed");
+    TLockableFileLog busyLog;
+    CheckTrue(busyLog.Initialize(MakeCrashTestConfig("scoped_busy.log")), "Initialize should succeed (busy)");
+
+    // Act: the crash is handled on this thread, inside its scope
+    {
+        const ASWLog::TASWLogScope scope{ { "requestId", "r-1" } };
+        HandleCrashWhileLocked(busyLog, "scoped");
+    }
+
+    // Assert
+    CheckEquals(std::string("[CRITICAL][requestId=\"r-1\"]: Crash: scoped\n"), ReadFileText(TestTempDir / "scoped.log"),
+        "The formatted crash line should have the crashing thread's scope fields");
+    CheckEndsWith(ReadFileText(TestTempDir / "scoped_busy.log"), std::format("][T:{}][requestId=\"r-1\"]: Crash: scoped\n",
+        ASWLog::GetCurrentOSThreadId()), "The fixed-layout crash line should have them too");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_HandleCrash_FlushesAndWritesTheCrashLine()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_CrashHandler.h b/tests/tests/Test_ASWLog_CrashHandler.h
index 6f1dbd7..d8cb6b9 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.h
+++ b/tests/tests/Test_ASWLog_CrashHandler.h
@@ -41,8 +41,11 @@ class TTest_ASWLog_CrashHandler : public TTestGroupBase
 
 private: // Test methods
     void Test_AppendCrashJSONLine_CutsALongTextButStaysValid();
+    void Test_AppendCrashJSONLine_ShowsTheFields();
     void Test_AppendCrashJSONLine_UsesTheFixedLayout();
     void Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding();
+    void Test_AppendCrashLine_FieldsThatDontFitAreLeftOut();
+    void Test_AppendCrashLine_ShowsTheFields();
     void Test_AppendCrashLine_ShowsTheCategory();
     void Test_AppendCrashLine_UsesTheFixedLayout();
     void Test_CrashProcess_AbortWritesTheCrashLine();
@@ -55,6 +58,7 @@ class TTest_ASWLog_CrashHandler : public TTestGroupBase
     void Test_CrashProcess_TerminateWritesTheExceptionAndFlushes();
     void Test_HandleCrash_ConsoleLogWritesTheLineToStdErr();
     void Test_HandleCrash_DisabledLoggerIsOnlyFlushed();
+    void Test_HandleCrash_CrashLineHasTheThreadsScopeFields();
     void Test_HandleCrash_FlushesAndWritesTheCrashLine();
     void Test_HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy();
     void Test_HandleCrash_SkipsClosedAndDestroyedLoggers();
diff --git a/tests/tests/Test_ASWLog_Fields.cpp b/tests/tests/Test_ASWLog_Fields.cpp
new file mode 100644
index 0000000..3ccce80
--- /dev/null
+++ b/tests/tests/Test_ASWLog_Fields.cpp
@@ -0,0 +1,605 @@
+/* **************************************************************************
+Test_ASWLog_Fields.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_Fields.h"
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <condition_variable>
+#include <cstdint>
+#include <filesystem>
+#include <format>
+#include <initializer_list>
+#include <limits>
+#include <mutex>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <type_traits>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_Base.h"
+#include "ASWLog_CategoryLog.h"
+#include "ASWLog_Fields.h"
+#include "ASWLog_FileLog.h"
+#include "ASWLog_MultiLog.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+const auto GroupBaseTempDir = std::filesystem::temp_directory_path() / "aswlog_fields_tests";
+const auto TestTempDir = GroupBaseTempDir / "test";
+
+enum class TColor
+{
+    Red,
+};
+
+enum TPlainColor
+{
+    PlainRed,
+};
+
+//---------------------------------------------------------------------------
+
+std::string DescribeField(const ASWLog::TASWLogField& field);
+std::string DescribeFields(const ASWLog::TASWLogRecord& record);
+std::string DescribeFieldList(const ASWLog::TASWLogScope* scope, std::span<const ASWLog::TASWLogField> fields);
+
+//---------------------------------------------------------------------------
+
+/*
+  DescribeField
+
+  "<key>=<value>", the value written plainly by the test (not by the library's layouts), with its kind:
+  "id=i:17", "n=u:4", "x=d:9.5", "ok=b:true", "user=t:amy"
+*/
+std::string DescribeField(const ASWLog::TASWLogField& field)
+{
+    const auto& value = field.Value;
+    switch (value.GetKind())
+    {
+        case ASWLog::ValueKind::Int:
+            return std::format("{}=i:{}", field.Key, value.GetInt());
+
+        case ASWLog::ValueKind::UInt:
+            return std::format("{}=u:{}", field.Key, value.GetUInt());
+
+        case ASWLog::ValueKind::Double:
+            return std::format("{}=d:{}", field.Key, value.GetDouble());
+
+        case ASWLog::ValueKind::Bool:
+            return std::format("{}=b:{}", field.Key, value.GetBool());
+
+        case ASWLog::ValueKind::Text:
+            return std::format("{}=t:{}", field.Key, value.GetText());
+    }
+
+    return "?";
+}
+
+/*
+  DescribeFieldList
+
+  The fields ForEachLogField() gives, each as DescribeField() writes it, separated by spaces
+*/
+std::string DescribeFieldList(const ASWLog::TASWLogScope* scope, std::span<const ASWLog::TASWLogField> fields)
+{
+    std::string text;
+    ASWLog::ForEachLogField(scope, fields, [&text](const ASWLog::TASWLogField& field) {
+                if (!text.empty())
+                    text += ' ';
+
+                text += DescribeField(field);
+            });
+
+    return text;
+}
+
+/*
+  DescribeFields
+
+  An entry's fields, as DescribeFieldList() writes them
+*/
+std::string DescribeFields(const ASWLog::TASWLogRecord& record)
+{
+    return DescribeFieldList(record.Scope, record.GetOwnFields());
+}
+
+//---------------------------------------------------------------------------
+
+// Writes "<message>|<fields>" for each entry it is given (see DescribeFields()), copied while the call lasts
+class TFieldsLogger final : public ASWLog::TASWLogBase
+{
+public:
+    std::vector<std::string> Written;
+
+protected:
+    std::string_view GetLoggerClassName() const noexcept override
+    {
+        return "TFieldsLogger";
+    }
+
+    void WriteRecord(const ASWLog::TASWLogRecord& record) override
+    {
+        Written.push_back(std::format("{}|{}", record.Message, DescribeFields(record)));
+    }
+
+public:
+    bool Initialize(const ASWLog::TASWLogConfig& config) noexcept override
+    {
+        [[maybe_unused]] const auto previousConfig = SetConfig(config);
+        SetMinimumLevel(config.InitialMinimumLevel);
+        m_IsInitialized.store(true, std::memory_order_release);
+        return true;
+    }
+
+    bool Reconfigure(const ASWLog::TASWLogConfig& config) noexcept override
+    {
+        [[maybe_unused]] const auto previousConfig = SetConfig(config);
+        return true;
+    }
+
+    bool Open() noexcept override
+    {
+        return true;
+    }
+
+    bool Close() noexcept override
+    {
+        return true;
+    }
+
+    bool Flush() noexcept override
+    {
+        return true;
+    }
+
+    bool IsOpen() const noexcept override
+    {
+        return true;
+    }
+};
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_Fields
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_Fields::TTest_ASWLog_Fields()
+    : inherited("ASWLog_Fields_Tests")
+{
+    RegisterTest(&TTest_ASWLog_Fields::Test_Async_OnLogEntryGetsTheFieldsAfterTheScopeEnds, "Async_OnLogEntryGetsTheFieldsAfterTheScopeEnds");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Backtrace_KeepsTheFieldsAfterTheScopeEnds, "Backtrace_KeepsTheFieldsAfterTheScopeEnds");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Capture_TakesTheScopesToAnotherThread, "Capture_TakesTheScopesToAnotherThread");
+    RegisterTest(&TTest_ASWLog_Fields::Test_ForEachLogField_EachKeyOnceInnermostWins, "ForEachLogField_EachKeyOnceInnermostWins");
+    RegisterTest(&TTest_ASWLog_Fields::Test_ForEachLogField_RepeatedKeysInTheEntrysOwnFields, "ForEachLogField_RepeatedKeysInTheEntrysOwnFields");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Log_CategoryAndMultiLogPassTheFieldsOn, "Log_CategoryAndMultiLogPassTheFieldsOn");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Log_EachOverloadPassesItsFields, "Log_EachOverloadPassesItsFields");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Log_ScopeFieldsComeBeforeTheEntrysOwn, "Log_ScopeFieldsComeBeforeTheEntrysOwn");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Scope_CopiesTemporaryTexts, "Scope_CopiesTemporaryTexts");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Scope_IsPerThread, "Scope_IsPerThread");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Scope_NestsAndRestoresTheCurrentScope, "Scope_NestsAndRestoresTheCurrentScope");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Value_KindsFromEachType, "Value_KindsFromEachType");
+    RegisterTest(&TTest_ASWLog_Fields::Test_Value_RejectsCharactersEnumsAndPointers, "Value_RejectsCharactersEnumsAndPointers");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_Fields::~TTest_ASWLog_Fields()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::SetUp_Group()
+{
+    std::filesystem::create_directories(GroupBaseTempDir);
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::SetUp_Test(ITestCase& /*testCase*/)
+{
+    std::filesystem::create_directories(TestTempDir);
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::TearDown_Group()
+{
+    std::error_code errorCode;
+    std::filesystem::remove_all(GroupBaseTempDir, errorCode);
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::TearDown_Test(ITestCase& /*testCase*/)
+{
+    std::error_code errorCode;
+    std::filesystem::remove_all(TestTempDir, errorCode);
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Async_OnLogEntryGetsTheFieldsAfterTheScopeEnds()
+{
+    // Arrange: an asynchronous file logger whose OnLogEntry, on the logger's thread, describes each entry's fields
+    std::mutex mutex;
+    std::condition_variable called;
+    std::vector<std::string> described;
+
+    ASWLog::TASWLogConfig config;
+    config.File.FolderPath = TestTempDir;
+    config.File.FilePath = "async.log";
+    config.File.OpenRetryCount = 1;
+    config.Async.Enabled = true;
+    config.Startup.WriteTimeInfo = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    config.Shutdown.WriteLine = false;
+    config.OnLogEntryMinimumLevel = ASWLog::Level::Trace;
+    config.OnLogEntry = [&](const ASWLog::TASWLogRecord& record, std::string_view) {
+            const std::lock_guard<std::mutex> lock(mutex);
+            described.push_back(DescribeFields(record));
+            called.notify_all();
+        };
+
+    ASWLog::TASWFileLog logger;
+    CheckTrue(logger.Initialize(config), "Initialize should succeed");
+
+    // Act: the scope and the call's texts are gone before the logger's thread calls OnLogEntry
+    {
+        const ASWLog::TASWLogScope scope{ { "requestId", std::string("r-1") } };
+        logger.LogInfo("queued", { { "user", std::string("amy") }, { "attempt", 2 } });
+    }
+
+    // The logger's thread calls OnLogEntry after it has written the entry, so after Flush() could return
+    std::unique_lock<std::mutex> lock(mutex);
+    const bool wasCalled = called.wait_for(lock, std::chrono::seconds(5), [&described] {
+            return !described.empty();
+        });
+
+    // Assert
+    AssertTrue(wasCalled, "OnLogEntry should be called");
+    AssertEquals(std::size_t(1), described.size(), "OnLogEntry should be called once");
+    CheckEquals(std::string("requestId=t:r-1 user=t:amy attempt=i:2"), described[0],
+        "OnLogEntry should get copies of the entry's fields and its scope's, made when the entry was queued");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Backtrace_KeepsTheFieldsAfterTheScopeEnds()
+{
+    // Arrange
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Info;
+    config.Backtrace.Capacity = 4;
+    config.Backtrace.LowestLevel = ASWLog::Level::Debug;
+
+    TFieldsLogger logger;
+    logger.Initialize(config);
+
+    // Act: the kept entry's scope and texts are gone when the backtrace is written
+    {
+        const ASWLog::TASWLogScope scope{ { "requestId", std::string("r-7") } };
+        logger.LogDebug("kept", { { "step", std::string("parse") } });
+    }
+
+    logger.LogError("failed", { { "code", 5 } });
+
+    // Assert
+    AssertEquals(std::size_t(4), logger.Written.size(), "The backtrace's markers, its entry and the error should be written");
+    CheckEquals(std::string("kept|requestId=t:r-7 step=t:parse"), logger.Written[1], "The kept entry should keep copies of its fields");
+    CheckEquals(std::string("failed|code=i:5"), logger.Written[3], "The error should have its own fields only");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Capture_TakesTheScopesToAnotherThread()
+{
+    // Arrange
+    ASWLog::TASWLogContext context;
+    ASWLog::TASWLogContext emptyContext = ASWLog::TASWLogScope::Capture();
+    {
+        const ASWLog::TASWLogScope outer{ { "requestId", "r-1" }, { "user", "amy" } };
+        const ASWLog::TASWLogScope inner{ { "user", "bob" } };
+        const auto captured = ASWLog::TASWLogScope::Capture();
+        context = captured; // A copy, which must refer to its own texts
+    }
+
+    std::string onOtherThread;
+    std::string afterScopeOnOtherThread;
+
+    // Act
+    std::thread worker([&] {
+        {
+            const ASWLog::TASWLogScope scope(context, { { "task", 3 }, { "user", "carl" } });
+            onOtherThread = DescribeFieldList(ASWLog::TASWLogScope::GetCurrent(), {});
+        }
+
+        afterScopeOnOtherThread = DescribeFieldList(ASWLog::TASWLogScope::GetCurrent(), {});
+            });
+    worker.join();
+
+    const ASWLog::TASWLogContext copied(context);
+    ASWLog::TASWLogContext assigned;
+    assigned = context;
+
+    // Assert
+    AssertEquals(std::size_t(2), context.GetFields().size(), "The context should hold two fields");
+
+    for (const ASWLog::TASWLogContext* copy : { &copied, static_cast<const ASWLog::TASWLogContext*>(&assigned) })
+    {
+        AssertEquals(std::size_t(2), copy->GetFields().size(), "A copy should hold the same fields");
+        CheckNotSame(context.GetFields()[0].Key.data(), copy->GetFields()[0].Key.data(), "A copy should have its own keys");
+        CheckNotSame(context.GetFields()[1].Value.GetText().data(), copy->GetFields()[1].Value.GetText().data(),
+            "A copy should have its own texts");
+        CheckEquals(std::string("requestId=t:r-1 user=t:bob"), DescribeFieldList(nullptr, copy->GetFields()), "A copy should read the same");
+    }
+
+    CheckTrue(emptyContext.IsEmpty(), "Capture() without a scope should give an empty context");
+    CheckEquals(std::string("requestId=t:r-1 user=t:bob"), DescribeFieldList(nullptr, context.GetFields()),
+        "The context should hold each key once, the inner scope's value winning");
+    CheckEquals(std::string("requestId=t:r-1 user=t:carl task=i:3"), onOtherThread,
+        "A scope made from the context should apply it on the other thread, its own fields replacing the same keys");
+    CheckEmpty(afterScopeOnOtherThread, "The other thread should have no scope once it ends");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_ForEachLogField_EachKeyOnceInnermostWins()
+{
+    // Arrange: user and req in an outer scope, req again in an inner one, then the entry's own user and x (twice)
+    const ASWLog::TASWLogScope outer{ { "user", "amy" }, { "req", 1 } };
+    const ASWLog::TASWLogScope inner{ { "req", 2 }, { "depth", 1 } };
+    const ASWLog::TASWLogField own[] = { { "user", "bob" }, { "x", 1 }, { "x", 2 } };
+
+    // Act
+    const auto described = DescribeFieldList(ASWLog::TASWLogScope::GetCurrent(), own);
+    const auto scopesOnly = DescribeFieldList(ASWLog::TASWLogScope::GetCurrent(), {});
+
+    // Assert
+    CheckEquals(std::string("user=t:bob req=i:2 depth=i:1 x=i:2"), described,
+        "Each key should come once, where it first appears, with its innermost (or the entry's own) value");
+    CheckEquals(std::string("user=t:amy req=i:2 depth=i:1"), scopesOnly, "Without the entry's fields, the inner scope should win");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_ForEachLogField_RepeatedKeysInTheEntrysOwnFields()
+{
+    // Arrange
+    const ASWLog::TASWLogField own[] = { { "a", 1 }, { "b", 2 }, { "a", 3 }, { "c", 4 }, { "b", 5 } };
+
+    // Act
+    const auto described = DescribeFieldList(nullptr, own);
+    const auto none = DescribeFieldList(nullptr, {});
+
+    // Assert
+    CheckEquals(std::string("a=i:3 b=i:5 c=i:4"), described, "A repeated key should come once, where it first appears, with its last value");
+    CheckEmpty(none, "No fields should give nothing");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Log_CategoryAndMultiLogPassTheFieldsOn()
+{
+    // Arrange: a category over a multi-log over two loggers
+    TFieldsLogger first;
+    TFieldsLogger second;
+
+    ASWLog::TASWMultiLog multiLog;
+    multiLog.AddLogger(first);
+    multiLog.AddLogger(second);
+
+    ASWLog::TASWCategoryLog netLog("Net", multiLog);
+
+    // Act
+    {
+        const ASWLog::TASWLogScope scope{ { "requestId", "r-9" } };
+        netLog.LogInfo("from net", { { "bytes", 512u } });
+    }
+
+    // Assert
+    const std::vector<std::string> expected{ "from net|requestId=t:r-9 bytes=u:512" };
+    CheckTrue(first.Written == expected, "The first logger should get the entry's fields and its scope's");
+    CheckTrue(second.Written == expected, "The second logger should get them too");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Log_EachOverloadPassesItsFields()
+{
+    // Arrange
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Trace;
+
+    TFieldsLogger logger;
+    logger.Initialize(config);
+
+    const int value = 7;
+
+    // Act
+    logger.Log(ASWLog::Level::Info, "log", { { "n", 1 } });
+    logger.LogRaw(ASWLog::Level::Info, "raw", { { "n", 2 } });
+    logger.LogForce(ASWLog::Level::Info, "force", { { "n", 3 } });
+    logger.LogForceRaw(ASWLog::Level::Info, "forceraw", { { "n", 4 } });
+    logger.LogTrace("trace", { { "n", 5 } });
+    logger.LogDebug("debug", { { "n", 6 } });
+    logger.LogInfo("info", { { "n", 7 } });
+    logger.LogWarn("warn", { { "n", 8 } });
+    logger.LogError("error", { { "n", 9 } });
+    logger.LogCritical("critical", { { "n", 10 } });
+    logger.LogFmt(ASWLog::Level::Info, { { "n", 11 } }, "logfmt {}", value);
+    logger.LogRawFmt(ASWLog::Level::Info, { { "n", 12 } }, "rawfmt {}", value);
+    logger.LogForceFmt(ASWLog::Level::Info, { { "n", 13 } }, "forcefmt {}", value);
+    logger.LogForceRawFmt(ASWLog::Level::Info, { { "n", 14 } }, "forcerawfmt {}", value);
+    logger.LogTraceFmt({ { "n", 15 } }, "tracefmt {}", value);
+    logger.LogDebugFmt({ { "n", 16 } }, "debugfmt {}", value);
+    logger.LogInfoFmt({ { "n", 17 } }, "infofmt {}", value);
+    logger.LogWarnFmt({ { "n", 18 } }, "warnfmt {}", value);
+    logger.LogErrorFmt({ { "n", 19 } }, "errorfmt {}", value);
+    logger.LogCriticalFmt({ { "n", 20 } }, "criticalfmt {}", value);
+    logger.LogInfo("none");
+
+    // Assert
+    const std::vector<std::string> expected{
+        "log|n=i:1", "raw|n=i:2", "force|n=i:3", "forceraw|n=i:4", "trace|n=i:5", "debug|n=i:6", "info|n=i:7", "warn|n=i:8",
+        "error|n=i:9", "critical|n=i:10", "logfmt 7|n=i:11", "rawfmt 7|n=i:12", "forcefmt 7|n=i:13",
+        "forcerawfmt 7|n=i:14", "tracefmt 7|n=i:15", "debugfmt 7|n=i:16", "infofmt 7|n=i:17", "warnfmt 7|n=i:18",
+        "errorfmt 7|n=i:19", "criticalfmt 7|n=i:20", "none|"
+    };
+    AssertEquals(expected.size(), logger.Written.size(), "Each call should write one entry");
+
+    for (std::size_t index = 0; index < expected.size(); ++index)
+        CheckEquals(expected[index], logger.Written[index], "Each overload should pass its message and fields");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Log_ScopeFieldsComeBeforeTheEntrysOwn()
+{
+    // Arrange
+    TFieldsLogger logger;
+    logger.Initialize(ASWLog::TASWLogConfig());
+
+    // Act
+    logger.LogInfo("before");
+    {
+        const ASWLog::TASWLogScope scope{ { "requestId", "r-2" }, { "user", "amy" } };
+        logger.LogInfo("inside");
+        logger.LogInfo("own", { { "user", "bob" }, { "total", 9.5 } });
+    }
+    logger.LogInfo("after");
+
+    // Assert
+    const std::vector<std::string> expected{
+        "before|", "inside|requestId=t:r-2 user=t:amy", "own|requestId=t:r-2 user=t:bob total=d:9.5", "after|"
+    };
+    CheckTrue(logger.Written == expected, "Entries in the scope should carry its fields, the entry's own after them and winning");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Scope_CopiesTemporaryTexts()
+{
+    // Arrange & Act: keys and texts that are gone once the scope is made
+    const ASWLog::TASWLogScope scope{ { std::string("requestId"), std::to_string(12345) },
+        { std::string_view(std::string(40, 'k')), std::string(40, 'x') } };
+    const std::vector<std::string> filler(16, std::string(40, 'z')); // Likely to reuse the freed memory
+
+    // Assert
+    CheckEquals("requestId=t:12345 " + std::string(40, 'k') + "=t:" + std::string(40, 'x'),
+        DescribeFieldList(ASWLog::TASWLogScope::GetCurrent(), {}), "The scope should keep copies of its keys and texts");
+    CheckEquals(std::size_t(16), filler.size(), "(keeps the filler alive)");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Scope_IsPerThread()
+{
+    // Arrange
+    const ASWLog::TASWLogScope scope{ { "requestId", "r-3" } };
+    const ASWLog::TASWLogScope* onOtherThread = &scope;
+
+    // Act
+    std::thread worker([&onOtherThread] {
+        onOtherThread = ASWLog::TASWLogScope::GetCurrent();
+            });
+    worker.join();
+
+    // Assert
+    CheckSame(&scope, ASWLog::TASWLogScope::GetCurrent(), "The scope should be this thread's current one");
+    CheckNull(onOtherThread, "Another thread should have no scope");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Scope_NestsAndRestoresTheCurrentScope()
+{
+    // Arrange
+    const ASWLog::TASWLogScope* beforeAll = ASWLog::TASWLogScope::GetCurrent();
+    const ASWLog::TASWLogScope* insideOuter = nullptr;
+    const ASWLog::TASWLogScope* insideInner = nullptr;
+    const ASWLog::TASWLogScope* innerParent = nullptr;
+    const ASWLog::TASWLogScope* afterInner = nullptr;
+    const ASWLog::TASWLogScope* outerAddress = nullptr;
+
+    // Act
+    {
+        const ASWLog::TASWLogScope outer{ { "a", 1 } };
+        outerAddress = &outer;
+        insideOuter = ASWLog::TASWLogScope::GetCurrent();
+        {
+            const ASWLog::TASWLogScope inner{ { "b", 2 } };
+            insideInner = ASWLog::TASWLogScope::GetCurrent();
+            innerParent = inner.GetParent();
+        }
+
+        afterInner = ASWLog::TASWLogScope::GetCurrent();
+    }
+
+    const ASWLog::TASWLogScope* afterAll = ASWLog::TASWLogScope::GetCurrent();
+
+    // Assert
+    CheckNull(beforeAll, "There should be no scope at first");
+    CheckSame(outerAddress, insideOuter, "The outer scope should be current inside it");
+    CheckNotNull(insideInner, "The inner scope should be current inside it");
+    CheckSame(outerAddress, innerParent, "The inner scope should be in the outer one");
+    CheckSame(outerAddress, afterInner, "The outer scope should be current again after the inner one ends");
+    CheckNull(afterAll, "No scope should be current after both end");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Value_KindsFromEachType()
+{
+    // Arrange
+    const std::string text = "from std::string";
+    const std::uint64_t largest = std::numeric_limits<std::uint64_t>::max();
+
+    // Act
+    const ASWLog::TASWLogField fields[] = {
+        { "int", -17 }, { "long long", std::numeric_limits<long long>::min() }, { "signed char", static_cast<signed char>(-3) },
+        { "unsigned", 4u }, { "size_t", std::size_t(4096) }, { "uint64", largest },
+        { "unsigned char", static_cast<unsigned char>(200) }, { "double", 9.99 }, { "float", 0.5f }, { "long double", 2.5L },
+        { "bool", true }, { "literal", "text" }, { "string", text }, { "view", std::string_view("view") },
+        { "default", ASWLog::TASWLogValue() }
+    };
+
+    // Assert
+    std::string described;
+    for (const auto& field : fields)
+        described += DescribeField(field) + ';';
+
+    CheckEquals(std::string("int=i:-17;long long=i:-9223372036854775808;signed char=i:-3;unsigned=u:4;size_t=u:4096;") +
+        "uint64=u:18446744073709551615;unsigned char=u:200;double=d:9.99;float=d:0.5;long double=d:2.5;bool=b:true;" +
+        "literal=t:text;string=t:from std::string;view=t:view;default=i:0;", described,
+        "Each type should become the value of its kind, signed and unsigned integers kept apart");
+    CheckSame(text.data(), fields[12].Value.GetText().data(), "Text should be a view of the caller's characters, not a copy");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Fields::Test_Value_RejectsCharactersEnumsAndPointers()
+{
+    // Act & Assert: these would otherwise become a number or a bool without the caller noticing
+    CheckFalse(std::is_constructible_v<ASWLog::TASWLogValue, char>, "A char should be rejected");
+    CheckFalse(std::is_constructible_v<ASWLog::TASWLogValue, wchar_t>, "A wchar_t should be rejected");
+    CheckFalse(std::is_constructible_v<ASWLog::TASWLogValue, char8_t>, "A char8_t should be rejected");
+    CheckFalse(std::is_constructible_v<ASWLog::TASWLogValue, TColor>, "A scoped enum should be rejected");
+    CheckFalse(std::is_constructible_v<ASWLog::TASWLogValue, TPlainColor>, "An unscoped enum should be rejected");
+    CheckFalse(std::is_constructible_v<ASWLog::TASWLogValue, const int*>, "A pointer that isn't text should be rejected");
+    CheckFalse(std::is_constructible_v<ASWLog::TASWLogValue, std::nullptr_t>, "nullptr should be rejected");
+    CheckTrue(std::is_constructible_v<ASWLog::TASWLogValue, const char*>, "A C string should be accepted");
+    CheckEquals(std::string(""), std::string(ASWLog::TASWLogValue(static_cast<const char*>(nullptr)).GetText()),
+        "A null C string should be empty text");
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_Fields)
diff --git a/tests/tests/Test_ASWLog_Fields.h b/tests/tests/Test_ASWLog_Fields.h
new file mode 100644
index 0000000..d27b70f
--- /dev/null
+++ b/tests/tests/Test_ASWLog_Fields.h
@@ -0,0 +1,66 @@
+/* **************************************************************************
+Test_ASWLog_Fields.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#ifndef Test_ASWLog_FieldsH
+#define Test_ASWLog_FieldsH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_Fields
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_Fields : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_Async_OnLogEntryGetsTheFieldsAfterTheScopeEnds();
+    void Test_Backtrace_KeepsTheFieldsAfterTheScopeEnds();
+    void Test_Capture_TakesTheScopesToAnotherThread();
+    void Test_ForEachLogField_EachKeyOnceInnermostWins();
+    void Test_ForEachLogField_RepeatedKeysInTheEntrysOwnFields();
+    void Test_Log_CategoryAndMultiLogPassTheFieldsOn();
+    void Test_Log_EachOverloadPassesItsFields();
+    void Test_Log_ScopeFieldsComeBeforeTheEntrysOwn();
+    void Test_Scope_CopiesTemporaryTexts();
+    void Test_Scope_IsPerThread();
+    void Test_Scope_NestsAndRestoresTheCurrentScope();
+    void Test_Value_KindsFromEachType();
+    void Test_Value_RejectsCharactersEnumsAndPointers();
+
+public:
+    TTest_ASWLog_Fields();
+    ~TTest_ASWLog_Fields() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_FieldsH
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index 3b90e64..12ae67c 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -31,10 +31,12 @@ limitations under the License.
 #include <filesystem>
 #include <format>
 #include <fstream>
+#include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <source_location>
+#include <span>
 #include <stdexcept>
 #include <string>
 #include <string_view>
@@ -44,6 +46,7 @@ limitations under the License.
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
 #include "ASWLog_CategoryLog.h"
+#include "ASWLog_Fields.h"
 #include "ASWLog_FileLog.h"
 #include "ASWLog_Formatter.h"
 #include "ASWLog_Utils.h"
@@ -176,14 +179,17 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
     RegisterTest(&TTest_ASWLog_Formatter::Test_Format_MatchesFormatLine, "Format_MatchesFormatLine");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_AllFieldsInOrder, "FormatLine_AllFieldsInOrder");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_CategoryOnlyWhenSetAndShown, "FormatLine_CategoryOnlyWhenSetAndShown");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_EntryFieldsBeforeTheMessage, "FormatLine_EntryFieldsBeforeTheMessage");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_LargestIdsAndEachLevel, "FormatLine_LargestIdsAndEachLevel");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_MemoryFields, "FormatLine_MemoryFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_NoFields, "FormatLine_NoFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_FormatLine_TimestampFollowsZoneAndPrecision, "FormatLine_TimestampFollowsZoneAndPrecision");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_RawEntryLeavesOutTheFields, "Formatter_RawEntryLeavesOutTheFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread, "Formatter_ReceivesRecordFromLoggingThread");
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_SharedByTwoLoggers, "Formatter_SharedByTwoLoggers");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_DefaultFields, "JSONFormatter_DefaultFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EachShowOption, "JSONFormatter_EachShowOption");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EntryFields, "JSONFormatter_EntryFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EscapesTheTexts, "JSONFormatter_EscapesTheTexts");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_FileLoggerWritesJSONLines, "JSONFormatter_FileLoggerWritesJSONLines");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_RawEntries, "JSONFormatter_RawEntries");
@@ -192,6 +198,7 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_BracesAndPlainText, "PatternFormatter_BracesAndPlainText");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_DefaultLayoutMatchesTextFormatter, "PatternFormatter_DefaultLayoutMatchesTextFormatter");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_EachPlaceholder, "PatternFormatter_EachPlaceholder");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_FieldsPlaceholder, "PatternFormatter_FieldsPlaceholder");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_FileLoggerWritesItsLines, "PatternFormatter_FileLoggerWritesItsLines");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_InvalidPatternThrows, "PatternFormatter_InvalidPatternThrows");
     RegisterTest(&TTest_ASWLog_Formatter::Test_PatternFormatter_MemoryFields, "PatternFormatter_MemoryFields");
@@ -290,6 +297,39 @@ void TTest_ASWLog_Formatter::Test_FormatLine_CategoryOnlyWhenSetAndShown()
     CheckEquals(std::string("[WARN]: categorized"), hiddenLine, "ShowCategory false should hide the category");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_FormatLine_EntryFieldsBeforeTheMessage()
+{
+    // Arrange: the level and the fields only; a value of each kind, and a text that needs escaping
+    auto config = MakeConfigWithoutFields("unused.log");
+    config.Line.ShowLevel = true;
+
+    const ASWLog::TASWLogField own[] = {
+        { "user", "amy" }, { "n", 17 }, { "neg", -3 }, { "big", std::numeric_limits<std::uint64_t>::max() }, { "x", 9.99 },
+        { "ok", true }, { "q", "say \"hi\" \\\n" }, { "empty", "" }
+    };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+
+    auto record = MakeRecord("msg");
+    record.Fields = &ownFields;
+
+    const ASWLog::TASWLogScope emptyScope(std::initializer_list<ASWLog::TASWLogField>{});
+
+    auto emptyScopeRecord = MakeRecord("msg");
+    emptyScopeRecord.Scope = &emptyScope;
+
+    // Act
+    const auto line = ASWLog::TASWTextFormatter::FormatLine(record, config);
+    const auto emptyScopeLine = ASWLog::TASWTextFormatter::FormatLine(emptyScopeRecord, config);
+    config.Line.ShowFields = false;
+    const auto hiddenLine = ASWLog::TASWTextFormatter::FormatLine(record, config);
+
+    // Assert
+    CheckEquals(std::string(R"([WARN][user="amy" n=17 neg=-3 big=18446744073709551615 x=9.99 ok=true q="say \"hi\" \\\n" empty=""]: msg)"),
+        line, "The fields should come in brackets before the message, texts quoted and escaped");
+    CheckEquals(std::string("[WARN]: msg"), emptyScopeLine, "A scope without fields should add no brackets");
+    CheckEquals(std::string("[WARN]: msg"), hiddenLine, "ShowFields false should hide the fields");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_FormatLine_LargestIdsAndEachLevel()
 {
     // Arrange
@@ -358,6 +398,30 @@ void TTest_ASWLog_Formatter::Test_FormatLine_TimestampFollowsZoneAndPrecision()
     CheckEquals(std::string("[2026-09-21T10:13:20.123000-04:00]: local"), line, "The timestamp should be local time with microseconds and the offset");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_Formatter_RawEntryLeavesOutTheFields()
+{
+    // Arrange: the level only, and a scope
+    auto config = MakeConfigWithoutFields("raw_fields.log");
+    config.Line.ShowLevel = true;
+
+    ASWLog::TASWFileLog logger;
+    const bool initialized = logger.Initialize(config);
+
+    // Act
+    {
+        const ASWLog::TASWLogScope scope{ { "requestId", "r-1" } };
+        logger.LogInfo("line", { { "n", 1 } });
+        logger.LogRaw(ASWLog::Level::Info, "raw\n", { { "n", 2 } });
+    }
+
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(std::string("[INFO][requestId=\"r-1\" n=1]: line\nraw\n"), ReadFileText(TestTempDir / "raw_fields.log"),
+        "A formatted entry should have its fields; a raw entry is written as is, without them");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_Formatter_ReceivesRecordFromLoggingThread()
 {
     // Arrange
@@ -490,6 +554,44 @@ void TTest_ASWLog_Formatter::Test_JSONFormatter_EachShowOption()
     CheckTrue(IsJSONObjectLine(allLine) && IsJSONObjectLine(memoryLine) && IsJSONObjectLine(noFieldsLine), "Each line should be one JSON object");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_EntryFields()
+{
+    // Arrange: a scope and the entry's own fields, which replace the scope's n; a value of each kind, and the doubles
+    // a JSON number can't hold
+    const auto config = MakeConfigWithoutFields("unused.log");
+    const ASWLog::TASWLogScope scope{ { "req", "r-1" }, { "n", 0 } };
+    const ASWLog::TASWLogField own[] = {
+        { "n", 17 }, { "big", std::numeric_limits<std::uint64_t>::max() }, { "x", 9.99 }, { "ok", false }, { "q", "a\"b" },
+        { "nan", std::numeric_limits<double>::quiet_NaN() }, { "inf", std::numeric_limits<double>::infinity() },
+        { "ninf", -std::numeric_limits<double>::infinity() }
+    };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+
+    auto record = MakeRecord("msg");
+    record.Fields = &ownFields;
+    record.Scope = &scope;
+
+    auto raw = record;
+    raw.Raw = true;
+
+    const ASWLog::TASWJSONFormatter formatter;
+
+    // Act
+    const auto line = formatter.Format(record, config);
+    const auto rawLine = formatter.Format(raw, config);
+    auto hiddenConfig = config;
+    hiddenConfig.Line.ShowFields = false;
+    const auto hiddenLine = formatter.Format(record, hiddenConfig);
+
+    // Assert
+    const std::string fields = R"("fields":{"req":"r-1","n":17,"big":18446744073709551615,"x":9.99,"ok":false,"q":"a\"b",)"
+        R"("nan":"NaN","inf":"Infinity","ninf":"-Infinity"})";
+    CheckEquals("{" + fields + R"(,"message":"msg"})", line, "The fields should be an object before the message, each key once");
+    CheckEquals("{" + fields + R"(,"raw":true,"message":"msg"})", rawLine, "A raw entry should have its fields too");
+    CheckEquals(std::string(R"({"message":"msg"})"), hiddenLine, "ShowFields false should leave them out");
+    CheckTrue(IsJSONObjectLine(line) && IsJSONObjectLine(rawLine), "Each line should be one JSON object");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_JSONFormatter_EscapesTheTexts()
 {
     // Arrange: quotes, a backslash, control characters and invalid UTF-8 in the category and the message
@@ -713,6 +815,27 @@ void TTest_ASWLog_Formatter::Test_PatternFormatter_EachPlaceholder()
     CheckEquals(pattern, std::string(formatter.GetPattern()), "GetPattern should return the pattern");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_PatternFormatter_FieldsPlaceholder()
+{
+    // Arrange
+    const ASWLog::TASWPatternFormatter formatter("{[fields] }{message}");
+    const ASWLog::TASWLogField own[] = { { "a", 1 }, { "b", "x y" } };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+
+    auto withFields = MakeRecord("msg");
+    withFields.Fields = &ownFields;
+
+    const ASWLog::TASWLogConfig config;
+
+    // Act
+    const auto line = formatter.Format(withFields, config);
+    const auto lineWithout = formatter.Format(MakeRecord("msg"), config);
+
+    // Assert
+    CheckEquals(std::string("[a=1 b=\"x y\"] msg"), line, "{fields} should write the fields as the built-in layout does");
+    CheckEquals(std::string("msg"), lineWithout, "{fields} should write nothing, affixes included, without fields");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_PatternFormatter_FileLoggerWritesItsLines()
 {
     // Arrange: CRLF, so the line ending shows that the logger still adds it
diff --git a/tests/tests/Test_ASWLog_Formatter.h b/tests/tests/Test_ASWLog_Formatter.h
index 39b9af0..dcd24f4 100644
--- a/tests/tests/Test_ASWLog_Formatter.h
+++ b/tests/tests/Test_ASWLog_Formatter.h
@@ -39,14 +39,17 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
     void Test_Format_MatchesFormatLine();
     void Test_FormatLine_AllFieldsInOrder();
     void Test_FormatLine_CategoryOnlyWhenSetAndShown();
+    void Test_FormatLine_EntryFieldsBeforeTheMessage();
     void Test_FormatLine_LargestIdsAndEachLevel();
     void Test_FormatLine_MemoryFields();
     void Test_FormatLine_NoFields();
     void Test_FormatLine_TimestampFollowsZoneAndPrecision();
+    void Test_Formatter_RawEntryLeavesOutTheFields();
     void Test_Formatter_ReceivesRecordFromLoggingThread();
     void Test_Formatter_SharedByTwoLoggers();
     void Test_JSONFormatter_DefaultFields();
     void Test_JSONFormatter_EachShowOption();
+    void Test_JSONFormatter_EntryFields();
     void Test_JSONFormatter_EscapesTheTexts();
     void Test_JSONFormatter_FileLoggerWritesJSONLines();
     void Test_JSONFormatter_RawEntries();
@@ -55,6 +58,7 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
     void Test_PatternFormatter_BracesAndPlainText();
     void Test_PatternFormatter_DefaultLayoutMatchesTextFormatter();
     void Test_PatternFormatter_EachPlaceholder();
+    void Test_PatternFormatter_FieldsPlaceholder();
     void Test_PatternFormatter_FileLoggerWritesItsLines();
     void Test_PatternFormatter_InvalidPatternThrows();
     void Test_PatternFormatter_MemoryFields();
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index ea36cc6..90800a6 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -208,6 +208,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>42</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_Fields.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_Fields.h</DependentOn>
+            <BuildOrder>50</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_FileLog.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_FileLog.h</DependentOn>
             <BuildOrder>5</BuildOrder>
@@ -260,6 +264,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>43</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_Fields.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_Fields.h</DependentOn>
+            <BuildOrder>51</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_FileLog.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_FileLog.h</DependentOn>
             <BuildOrder>30</BuildOrder>

From b9f58dbb7a82be86ff262654a84b9e4860b8d112 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Fri, 9 Oct 2026 00:58:52 -0700
Subject: [PATCH 10/38] Add optional multi-line message handling

---
 ASWLog/ASWLog_Config.h                   |   4 +
 ASWLog/ASWLog_CrashHandler.cpp           |  30 +++++-
 ASWLog/ASWLog_CrashHandler.h             |  12 ++-
 ASWLog/ASWLog_Formatter.h                |   7 +-
 ASWLog/ASWLog_TextLogBase.cpp            |  11 ++-
 ASWLog/ASWLog_TextLogBase.h              |   1 +
 ASWLog/ASWLog_Types.cpp                  |  15 +++
 ASWLog/ASWLog_Types.h                    |  30 ++++++
 ASWLog/ASWLog_Utils.cpp                  |  95 ++++++++++++++++++
 ASWLog/ASWLog_Utils.h                    |  26 +++++
 CHANGELOG.md                             |  12 +++
 README.md                                |   3 +
 tests/tests/Test_ASWLog_Config.cpp       |   1 +
 tests/tests/Test_ASWLog_CrashHandler.cpp | 106 ++++++++++++++++++++
 tests/tests/Test_ASWLog_CrashHandler.h   |   3 +
 tests/tests/Test_ASWLog_TextLogBase.cpp  | 112 +++++++++++++++++++++
 tests/tests/Test_ASWLog_TextLogBase.h    |   4 +
 tests/tests/Test_ASWLog_Types.cpp        |  25 +++++
 tests/tests/Test_ASWLog_Types.h          |   2 +
 tests/tests/Test_ASWLog_Utils.cpp        | 120 +++++++++++++++++++++++
 tests/tests/Test_ASWLog_Utils.h          |   4 +
 21 files changed, 612 insertions(+), 11 deletions(-)

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 805db24..7edaf19 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -219,6 +219,10 @@ struct TASWLineConfig
     // be shared by several loggers.
     std::shared_ptr<const IASWLogFormatter> Formatter;
     LineEnding Ending = LineEnding::LF; // Added after each formatted line (not after LogRaw entries written as is)
+    // The line breaks inside a formatted line, e.g. of a multi-line message: written as they are (the default), each
+    // followed by "    | " on the next line (Indent), or as \r and \n (Escape), so that every entry is recognizable as
+    // one (see MultilineMode). LogRaw entries written as is always stay as they are; a JSON line has no line breaks.
+    MultilineMode Multiline = MultilineMode::Preserve;
 
     // The clock and precision of the timestamps, e.g. 2026-09-28T21:02:44.342Z (the defaults) or, with
     // TimeZone::Local and TimePrecision::Microseconds, 2026-09-28T16:02:44.342519-05:00. The zone also sets when daily
diff --git a/ASWLog/ASWLog_CrashHandler.cpp b/ASWLog/ASWLog_CrashHandler.cpp
index 692289d..5fec125 100644
--- a/ASWLog/ASWLog_CrashHandler.cpp
+++ b/ASWLog/ASWLog_CrashHandler.cpp
@@ -704,6 +704,32 @@ void TCrashText::AppendJSONString(std::string_view text, std::size_t reserved) n
     Append("\"");
 }
 
+//---------------------------------------------------------------------------
+void TCrashText::AppendMultiline(std::string_view text, MultilineMode mode, LineEnding ending,
+    std::size_t reserved) noexcept
+{
+    const std::size_t limit = Capacity - std::min(Capacity, reserved);
+    std::size_t index = 0;
+
+    while (index < text.size())
+    {
+        const auto piece = NextMultilinePiece(text, index, mode, ending);
+        const std::size_t room = limit > m_Size ? limit - m_Size : 0;
+
+        if (piece.Text.size() <= room)
+        {
+            Append(piece.Text);
+            continue;
+        }
+
+        // A run of text is cut; a rewritten line break is left out whole
+        if (!piece.IsLineBreak)
+            Append(piece.Text.substr(0, room));
+
+        break;
+    }
+}
+
 //---------------------------------------------------------------------------
 std::size_t TCrashText::GetSize() const noexcept
 {
@@ -848,7 +874,7 @@ void AppendCrashJSONLine(TCrashText& line, const TASWLogRecord& record, bool use
 }
 
 //---------------------------------------------------------------------------
-void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF) noexcept
+void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF, MultilineMode multiline) noexcept
 {
     const std::string_view ending = usesCRLF ? "\r\n" : "\n";
 
@@ -878,7 +904,7 @@ void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRL
     }
 
     line.Append("]: ");
-    line.Append(record.Message);
+    line.AppendMultiline(record.Message, multiline, usesCRLF ? LineEnding::CRLF : LineEnding::LF, ending.size());
 
     line.Truncate(TCrashText::Capacity - ending.size());
     line.Append(ending);
diff --git a/ASWLog/ASWLog_CrashHandler.h b/ASWLog/ASWLog_CrashHandler.h
index 5bc09af..cc27630 100644
--- a/ASWLog/ASWLog_CrashHandler.h
+++ b/ASWLog/ASWLog_CrashHandler.h
@@ -78,6 +78,7 @@ struct TASWCrashHandlerOptions
 //   The backtrace's lines get the same layout, with their own level and category (after the level, as "[Net]", or as
 //   "category" in JSON), and only if the backtrace's lock is free. The lines show the entry's fields too (see
 //   TASWLogScope; the crash line has the crashing thread's scope fields), after the thread id, as far as they fit.
+//   The text lines write the line breaks in their messages as TASWLineConfig::Multiline says, like the other lines.
 // - If a logger's lock stays busy until WaitTimeout has passed (e.g. the crash happened while that thread was
 //   writing an entry), its buffered entries are lost and only the fixed-layout lines (backtrace and crash line) are
 //   written, straight to the file.
@@ -146,6 +147,9 @@ class TCrashText
     // 'text' as a JSON string (see JSON::AppendString()), cut between characters if needed so that 'reserved'
     // characters stay free after it; the string is always closed
     void AppendJSONString(std::string_view text, std::size_t reserved) noexcept;
+    // 'text' with its line breaks written as 'mode' asks (see Detail::NextMultilinePiece()), cut if needed so that
+    // 'reserved' characters stay free after it; a rewritten line break is never cut
+    void AppendMultiline(std::string_view text, MultilineMode mode, LineEnding ending, std::size_t reserved) noexcept;
     std::size_t GetSize() const noexcept;
     void Truncate(std::size_t size) noexcept; // Cuts the text to 'size' characters, if it is longer
     std::string_view View() const noexcept;
@@ -183,9 +187,11 @@ void AppendBacktraceBeginText(TCrashText& text, std::size_t count) noexcept;
 // is always a whole JSON object, followed by the line ending.
 void AppendCrashJSONLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF) noexcept;
 
-// Appends the fixed-layout crash line for 'record' (see the crash handling notes above), with a CRLF or LF ending. A
-// message too long for the buffer is cut off, but the line always ends with the line ending.
-void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF) noexcept;
+// Appends the fixed-layout crash line for 'record' (see the crash handling notes above), with a CRLF or LF ending, the
+// message's line breaks written as 'multiline' asks (TASWLineConfig::Multiline). A message too long for the buffer is
+// cut off, but the line always ends with the line ending.
+void AppendCrashLine(TCrashText& line, const TASWLogRecord& record, bool usesCRLF,
+    MultilineMode multiline = MultilineMode::Preserve) noexcept;
 
 // Pauses briefly (about a millisecond) and returns true, or returns false at once if 'deadline' has passed. For the
 // polling waits of a crash handler, which can't wait on a condition variable in a signal handler.
diff --git a/ASWLog/ASWLog_Formatter.h b/ASWLog/ASWLog_Formatter.h
index 4ee74dc..ca9b42c 100644
--- a/ASWLog/ASWLog_Formatter.h
+++ b/ASWLog/ASWLog_Formatter.h
@@ -58,9 +58,10 @@ class IASWLogFormatter
 public:
     virtual ~IASWLogFormatter() = default;
 
-    // Returns the line for 'record', without its line ending (the logger adds TASWLogConfig::Line.Ending).
-    // 'config' is the calling logger's config. Not called for a Raw record (LogRaw()/LogForceRaw()), whose message is
-    // written as is, unless FormatsRawEntries() says so.
+    // Returns the line for 'record', without its line ending (the logger adds TASWLogConfig::Line.Ending, after
+    // rewriting the line breaks inside the line as Line.Multiline says). 'config' is the calling logger's config. Not
+    // called for a Raw record (LogRaw()/LogForceRaw()), whose message is written as is, unless FormatsRawEntries()
+    // says so.
     // May throw, e.g. std::bad_alloc: the entry is then dropped.
     [[nodiscard]] virtual std::string Format(const TASWLogRecord& record, const TASWLogConfig& config) const = 0;
 
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index a11677f..1e23e66 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -82,7 +82,7 @@ void TASWTextLogBase::AppendCrashLine(Detail::TCrashText& line, const TASWLogRec
     if (m_CrashLineUsesJSON.load(std::memory_order_relaxed))
         Detail::AppendCrashJSONLine(line, record, usesCRLF);
     else
-        Detail::AppendCrashLine(line, record, usesCRLF);
+        Detail::AppendCrashLine(line, record, usesCRLF, m_CrashLineMultiline.load(std::memory_order_relaxed));
 }
 
 //---------------------------------------------------------------------------
@@ -197,8 +197,9 @@ void TASWTextLogBase::FlushForCrashUnlocked() noexcept
 /*
     TASWTextLogBase::FormatEntry
 
-    The line written for 'record' with 'config': the formatter's line followed by the line ending, or, for a Raw record
-    that the formatter doesn't format (see IsFormatted()), its message as is.
+    The line written for 'record' with 'config': the formatter's line, its line breaks written as Line.Multiline asks,
+    followed by the line ending, or, for a Raw record that the formatter doesn't format (see IsFormatted()), its
+    message as is.
 */
 std::string TASWTextLogBase::FormatEntry(const TASWLogRecord& record, const TASWLogConfig& config)
 {
@@ -217,6 +218,9 @@ std::string TASWTextLogBase::FormatEntry(const TASWLogRecord& record, const TASW
     const auto* formatter = config.Line.Formatter.get();
     line = formatter != nullptr ? formatter->Format(record, config) : TASWTextFormatter::FormatLine(record, config);
 
+    if (config.Line.Multiline != MultilineMode::Preserve)
+        Detail::ApplyMultilineMode(line, config.Line.Multiline, config.Line.Ending);
+
     if (config.Line.Ending == LineEnding::CRLF)
         line += "\r\n";
     else
@@ -698,6 +702,7 @@ void TASWTextLogBase::StoreCrashLineSettingsUnlocked() noexcept
     m_CrashLineUsesCRLF.store(config.Line.Ending == LineEnding::CRLF, std::memory_order_relaxed);
     const bool usesJSON = dynamic_cast<const TASWJSONFormatter*>(config.Line.Formatter.get()) != nullptr;
     m_CrashLineUsesJSON.store(usesJSON, std::memory_order_relaxed);
+    m_CrashLineMultiline.store(config.Line.Multiline, std::memory_order_relaxed);
     m_WritesCrashLine.store(config.Shutdown.WriteCrashLine, std::memory_order_relaxed);
 }
 
diff --git a/ASWLog/ASWLog_TextLogBase.h b/ASWLog/ASWLog_TextLogBase.h
index 5074a28..69c49b9 100644
--- a/ASWLog/ASWLog_TextLogBase.h
+++ b/ASWLog/ASWLog_TextLogBase.h
@@ -151,6 +151,7 @@ class TASWTextLogBase : public TASWLogBase
     // From the config (see StoreCrashLineSettingsUnlocked()), for a crash handler that doesn't get the lock
     std::atomic<bool> m_CrashLineUsesCRLF{ false };
     std::atomic<bool> m_CrashLineUsesJSON{ false }; // The formatter is a TASWJSONFormatter
+    std::atomic<MultilineMode> m_CrashLineMultiline{ MultilineMode::Preserve };
     std::atomic<bool> m_WritesCrashLine{ true };
 
 private:
diff --git a/ASWLog/ASWLog_Types.cpp b/ASWLog/ASWLog_Types.cpp
index 3b0c1c5..65fadb1 100644
--- a/ASWLog/ASWLog_Types.cpp
+++ b/ASWLog/ASWLog_Types.cpp
@@ -140,6 +140,21 @@ std::optional<LineEnding> LineEnding_FromString(std::string_view str) noexcept
     return std::nullopt; // Return empty optional if the string is not recognized
 }
 
+//---------------------------------------------------------------------------
+std::optional<MultilineMode> MultilineMode_FromString(std::string_view str) noexcept
+{
+    if (iequals(str, "PRESERVE"))
+        return MultilineMode::Preserve;
+
+    if (iequals(str, "INDENT"))
+        return MultilineMode::Indent;
+
+    if (iequals(str, "ESCAPE"))
+        return MultilineMode::Escape;
+
+    return std::nullopt;
+}
+
 //---------------------------------------------------------------------------
 std::optional<TimePrecision> TimePrecision_FromString(std::string_view str) noexcept
 {
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index 4959194..5ccb058 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -333,6 +333,36 @@ enum class LineEnding
 
 //---------------------------------------------------------------------------
 
+// How a text logger writes the line breaks inside an entry's line, e.g. of a message holding an HTTP body (see
+// TASWLineConfig::Multiline)
+enum class MultilineMode
+{
+    Preserve, // As they are, so a multi-line message spans several lines of the log
+    Indent,   // Each "\n" or "\r\n" as the line ending followed by "    | ", so each line after the first is marked
+    Escape,   // Each CR and LF as the two characters \r and \n, so the entry stays on one line
+};
+
+[[nodiscard]] std::optional<MultilineMode> MultilineMode_FromString(std::string_view str) noexcept;
+
+[[nodiscard]] constexpr std::string_view MultilineMode_ToString(MultilineMode mode) noexcept
+{
+    switch (mode)
+    {
+        case MultilineMode::Preserve:
+            return "PRESERVE";
+
+        case MultilineMode::Indent:
+            return "INDENT";
+
+        case MultilineMode::Escape:
+            return "ESCAPE";
+    }
+
+    return "UNKNOWN";
+}
+
+//---------------------------------------------------------------------------
+
 // How many digits of the second a timestamp shows (see TASWLineConfig::TimestampPrecision). The digits past the system
 // clock's resolution are 0: with nanoseconds, the last two with MSVC and MinGW on Windows (100 ns), the last three with
 // libc++ (1 us, e.g. RAD Studio).
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index 583a000..d07828d 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -34,6 +34,7 @@ limitations under the License.
 #include <filesystem>
 #include <format>
 #include <fstream>
+#include <utility>
 #include <vector>
 
 #if defined(_WIN32)
@@ -623,17 +624,48 @@ namespace Detail
 namespace
 {
 
+// The line breaks MultilineMode::Escape writes
+constexpr std::string_view EscapedCR = "\\r";
+constexpr std::string_view EscapedLF = "\\n";
+
+// The line breaks MultilineMode::Indent writes: the line ending and the next line's marker, whose space is left out
+// when that line is empty
+constexpr std::string_view IndentedCRLF = "\r\n    | ";
+constexpr std::string_view IndentedLF = "\n    | ";
+
 // U+FFFD, the replacement character, in UTF-8
 constexpr std::string_view ReplacementCharacter = "\xEF\xBF\xBD";
 
 //---------------------------------------------------------------------------
 
+bool HasCROrLF(const char* data) noexcept;
 bool IsPlainJSONCharacter(unsigned char character) noexcept;
 bool IsPlainJSONWord(const char* data) noexcept;
 std::size_t MeasureUTF8Sequence(std::string_view text, std::size_t index, std::size_t& invalidLength) noexcept;
 
 //---------------------------------------------------------------------------
 
+/*
+  HasCROrLF
+
+  True if any of the 8 characters at 'data' is a CR or a LF, tested together in a 64-bit word (see IsPlainJSONWord())
+*/
+bool HasCROrLF(const char* data) noexcept
+{
+    constexpr std::uint64_t Ones = 0x0101010101010101;
+    constexpr std::uint64_t HighBits = 0x8080808080808080;
+
+    std::uint64_t word;
+    std::memcpy(&word, data, sizeof(word));
+
+    // The usual test for a zero byte, on the word XORed with each of them
+    const std::uint64_t returns = word ^ (Ones * '\r');
+    const std::uint64_t lineFeeds = word ^ (Ones * '\n');
+    const std::uint64_t found = ((returns - Ones) & ~returns) | ((lineFeeds - Ones) & ~lineFeeds);
+
+    return (found & HighBits) != 0;
+}
+
 /*
   IsPlainJSONCharacter
 
@@ -727,6 +759,25 @@ std::size_t MeasureUTF8Sequence(std::string_view text, std::size_t index, std::s
 
 } // namespace
 
+//---------------------------------------------------------------------------
+void ApplyMultilineMode(std::string& line, MultilineMode mode, LineEnding ending)
+{
+    std::size_t index = 0;
+    const auto first = NextMultilinePiece(line, index, mode, ending);
+
+    if (!first.IsLineBreak && index >= line.size())
+        return;
+
+    std::string rewritten;
+    rewritten.reserve(line.size() + 32);
+    rewritten.append(first.Text);
+
+    while (index < line.size())
+        rewritten.append(NextMultilinePiece(line, index, mode, ending).Text);
+
+    line = std::move(rewritten);
+}
+
 //---------------------------------------------------------------------------
 TJSONPiece NextJSONPiece(std::string_view text, std::size_t& index, char (& escape)[6]) noexcept
 {
@@ -816,6 +867,50 @@ TJSONPiece NextJSONPiece(std::string_view text, std::size_t& index, char (& esca
     return TJSONPiece{ std::string_view(escape, 2), true };
 }
 
+//---------------------------------------------------------------------------
+TMultilinePiece NextMultilinePiece(std::string_view text, std::size_t& index, MultilineMode mode,
+    LineEnding ending) noexcept
+{
+    const std::size_t start = index;
+
+    if (mode == MultilineMode::Preserve)
+    {
+        index = text.size();
+        return TMultilinePiece{ text.substr(start), false };
+    }
+
+    // Indent leaves a lone CR as it is
+    const auto isLineBreakAt = [text, mode](std::size_t position) {
+            return text[position] == '\n' || (text[position] == '\r' && (mode == MultilineMode::Escape ||
+                (position + 1 < text.size() && text[position + 1] == '\n')));
+        };
+
+    while (index < text.size())
+    {
+        if (text.size() - index >= 8 && !HasCROrLF(text.data() + index))
+            index += 8;
+        else if (isLineBreakAt(index))
+            break;
+        else
+            ++index;
+    }
+
+    if (index > start)
+        return TMultilinePiece{ text.substr(start, index - start), false };
+
+    if (index >= text.size())
+        return TMultilinePiece{};
+
+    if (mode == MultilineMode::Escape)
+        return TMultilinePiece{ text[index++] == '\r' ? EscapedCR : EscapedLF, true };
+
+    index += text[index] == '\r' ? 2 : 1;
+    const std::string_view indented = ending == LineEnding::CRLF ? IndentedCRLF : IndentedLF;
+    const bool isNextLineEmpty = index >= text.size() || isLineBreakAt(index);
+
+    return TMultilinePiece{ isNextLineEmpty ? indented.substr(0, indented.size() - 1) : indented, true };
+}
+
 } // namespace Detail
 
 //---------------------------------------------------------------------------
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index b6cc2e8..c6fcd9b 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -146,8 +146,23 @@ struct TJSONPiece
     bool IsEscape = false; // An escape or U+FFFD, which must not be cut; otherwise ASCII and valid UTF-8, as they are
 };
 
+// A piece of a line as a MultilineMode writes it (see NextMultilinePiece())
+struct TMultilinePiece
+{
+    std::string_view Text;
+    bool IsLineBreak = false; // A line break as the mode writes it, which must not be cut; otherwise text as it is
+};
+
 //---------------------------------------------------------------------------
 
+/*
+    ApplyMultilineMode
+
+    Rewrites the line breaks inside 'line' as 'mode' asks (see MultilineMode), Indent with 'ending' as the line ending.
+    Leaves 'line' as it is, without allocating, if it has no line break to rewrite.
+*/
+void ApplyMultilineMode(std::string& line, MultilineMode mode, LineEnding ending);
+
 /*
     NextJSONPiece
 
@@ -158,6 +173,17 @@ struct TJSONPiece
 */
 [[nodiscard]] TJSONPiece NextJSONPiece(std::string_view text, std::size_t& index, char (& escape)[6]) noexcept;
 
+/*
+    NextMultilinePiece
+
+    The next piece of 'text', from 'index' on, as ApplyMultilineMode() writes it, and moves 'index' past it: a run of
+    text without a line break to rewrite (a view of 'text'; with Preserve, the rest of it), or one line break as 'mode'
+    writes it (Indent: 'ending' and the marker of the next line, "    | ", or "    |" when that line is empty). An empty
+    piece at the end of 'text'. Allocates nothing, so a crash handler can use it too.
+*/
+[[nodiscard]] TMultilinePiece NextMultilinePiece(std::string_view text, std::size_t& index, MultilineMode mode,
+    LineEnding ending) noexcept;
+
 } // namespace Detail
 
 namespace JSON
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c08481b..ae66a4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -110,6 +110,18 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   crash line gets the crashing thread's scope fields. `TASWLogRecord`
   gains `Fields` and `Scope` (both pointers, so a filtered call costs no
   more), read with `ForEachField()`.
+- Multi-line message handling: `Line.Multiline` (`MultilineMode::Preserve`,
+  the default, writes line breaks as they are, as before). With
+  `MultilineMode::Indent`, each `\n` or `\r\n` in a formatted line is
+  written as the line ending followed by `    | ` (`    |` for an empty
+  line), so every line after an entry's first is marked as part of it and
+  can't pass for an entry of its own; a lone `\r` stays as it is. With
+  `MultilineMode::Escape`, each CR and LF is written as the two characters
+  `\r` and `\n` (other characters, backslashes included, as they are), so
+  every entry is one line. It applies to the line of any formatter,
+  including your own (a JSON line has no line breaks), and to the
+  fixed-layout crash and backtrace lines; `LogRaw()` entries written as is
+  stay as they are.
 
 ### Changed
 
diff --git a/README.md b/README.md
index e1b4693..52d752c 100644
--- a/README.md
+++ b/README.md
@@ -41,6 +41,9 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   assigned to `TASWLogConfig::Line.Formatter`).
 - JSON Lines output for log shippers and tools such as `jq`: one escaped JSON object per entry
   (`ASWLog::TASWJSONFormatter`, assigned to `TASWLogConfig::Line.Formatter`).
+- Multi-line messages (e.g. an HTTP body) written as they are, or, with `TASWLogConfig::Line.Multiline`, each line after
+  the first marked with `    | ` (`MultilineMode::Indent`) or the line breaks escaped as `\r` and `\n`
+  (`MultilineMode::Escape`), so that every entry is recognizable as one.
 - Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
   entry on the thread carries, e.g. `ASWLog::TASWLogScope scope{{"requestId", id}};` (`ASWLog_Fields.h`).
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 0a2d15c..82b998c 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -89,6 +89,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     // Assert: Line
     CheckNull(config.Line.Formatter, "Line.Formatter should default to unset (the built-in layout)");
     CheckEquals(ASWLog::LineEnding::LF, config.Line.Ending, "Line.Ending should default to LF");
+    CheckEquals(ASWLog::MultilineMode::Preserve, config.Line.Multiline, "Line.Multiline should default to Preserve");
     CheckEquals(ASWLog::TimeZone::UTC, config.Line.TimestampZone, "Line.TimestampZone should default to UTC");
     CheckEquals(ASWLog::TimePrecision::Milliseconds, config.Line.TimestampPrecision, "Line.TimestampPrecision should default to Milliseconds");
     CheckTrue(config.Line.ShowTimestamp, "Line.ShowTimestamp should default to true");
diff --git a/tests/tests/Test_ASWLog_CrashHandler.cpp b/tests/tests/Test_ASWLog_CrashHandler.cpp
index f24be8b..26e251b 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.cpp
+++ b/tests/tests/Test_ASWLog_CrashHandler.cpp
@@ -24,6 +24,7 @@ limitations under the License.
 // Module header
 #include "Test_ASWLog_CrashHandler.h"
 //---------------------------------------------------------------------------
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
@@ -569,6 +570,8 @@ TTest_ASWLog_CrashHandler::TTest_ASWLog_CrashHandler()
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashJSONLine_UsesTheFixedLayout, "AppendCrashJSONLine_UsesTheFixedLayout");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding, "AppendCrashLine_CutsALongMessageButKeepsTheEnding");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_FieldsThatDontFitAreLeftOut, "AppendCrashLine_FieldsThatDontFitAreLeftOut");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_FollowsTheMultilineMode, "AppendCrashLine_FollowsTheMultilineMode");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_NeverCutsARewrittenLineBreak, "AppendCrashLine_NeverCutsARewrittenLineBreak");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheFields, "AppendCrashLine_ShowsTheFields");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheCategory, "AppendCrashLine_ShowsTheCategory");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_AppendCrashLine_UsesTheFixedLayout, "AppendCrashLine_UsesTheFixedLayout");
@@ -583,6 +586,7 @@ TTest_ASWLog_CrashHandler::TTest_ASWLog_CrashHandler()
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_ConsoleLogWritesTheLineToStdErr, "HandleCrash_ConsoleLogWritesTheLineToStdErr");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_DisabledLoggerIsOnlyFlushed, "HandleCrash_DisabledLoggerIsOnlyFlushed");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_CrashLineHasTheThreadsScopeFields, "HandleCrash_CrashLineHasTheThreadsScopeFields");
+    RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_FixedLayoutLineFollowsTheMultilineMode, "HandleCrash_FixedLayoutLineFollowsTheMultilineMode");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_FlushesAndWritesTheCrashLine, "HandleCrash_FlushesAndWritesTheCrashLine");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy, "HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy");
     RegisterTest(&TTest_ASWLog_CrashHandler::Test_HandleCrash_SkipsClosedAndDestroyedLoggers, "HandleCrash_SkipsClosedAndDestroyedLoggers");
@@ -807,6 +811,84 @@ void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_FieldsThatDontFitAreLeftOut
     CheckTrue(IsJSONObjectLine(json.substr(0, json.size() - 2)), "The JSON line should be one JSON object");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_FollowsTheMultilineMode()
+{
+    // Arrange: a message with each kind of line break, a lone CR, and a line break at its end
+    ASWLog::TASWLogRecord record;
+    record.LogLevel = ASWLog::Level::Critical;
+    record.Message = "a\r\nb\n\rc\n";
+
+    const auto appendLine = [&record](bool usesCRLF, ASWLog::MultilineMode mode) {
+            ASWLog::Detail::TCrashText line;
+            ASWLog::Detail::AppendCrashLine(line, record, usesCRLF, mode);
+
+            return std::string(line.View());
+        };
+
+    // Act
+    const auto preserved = appendLine(false, ASWLog::MultilineMode::Preserve);
+    const auto indentedLF = appendLine(false, ASWLog::MultilineMode::Indent);
+    const auto indentedCRLF = appendLine(true, ASWLog::MultilineMode::Indent);
+    const auto escaped = appendLine(true, ASWLog::MultilineMode::Escape);
+
+    // Assert
+    CheckEndsWith(preserved, "][P:0][T:0]: a\r\nb\n\rc\n\n", "Preserve should write the message as it is");
+    CheckEndsWith(indentedLF, "][P:0][T:0]: a\n    | b\n    | \rc\n    |\n", "Indent should mark each line after the first");
+    CheckEndsWith(indentedCRLF, "][P:0][T:0]: a\r\n    | b\r\n    | \rc\r\n    |\r\n", "Indent should use the CRLF ending");
+    CheckEndsWith(escaped, "][P:0][T:0]: a\\r\\nb\\n\\rc\\n\r\n", "Escape should keep the entry on one line");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_NeverCutsARewrittenLineBreak()
+{
+    // Arrange: messages whose line break falls at each place around the end of the buffer
+    struct TCase
+    {
+        ASWLog::MultilineMode Mode;
+        bool UsesCRLF;
+        std::string_view LineBreak;
+        std::string_view Rewritten; // How the line break is written
+    };
+
+    const TCase cases[] = {
+        { ASWLog::MultilineMode::Indent, false, "\n", "\n    | " },
+        { ASWLog::MultilineMode::Indent, true, "\r\n", "\r\n    | " },
+        { ASWLog::MultilineMode::Escape, false, "\n", "\\n" }, { ASWLog::MultilineMode::Escape, true, "\r", "\\r" }
+    };
+
+    for (const auto& item : cases)
+    {
+        // A record of its own for each case: the message of the last one is gone
+        ASWLog::TASWLogRecord record;
+        record.LogLevel = ASWLog::Level::Critical;
+
+        const std::string_view ending = item.UsesCRLF ? "\r\n" : "\n";
+        ASWLog::Detail::TCrashText emptyLine;
+        ASWLog::Detail::AppendCrashLine(emptyLine, record, item.UsesCRLF, item.Mode);
+        const std::size_t room = ASWLog::Detail::TCrashText::Capacity - emptyLine.GetSize(); // For the message
+        CheckGreaterThan(room, std::size_t(900), "The line without a message should leave most of the buffer free");
+
+        for (std::size_t length = room - 12; length <= room; ++length)
+        {
+            const std::string message = std::string(length, 'x') + std::string(item.LineBreak) + "y";
+            record.Message = message;
+
+            // Act
+            ASWLog::Detail::TCrashText line;
+            ASWLog::Detail::AppendCrashLine(line, record, item.UsesCRLF, item.Mode);
+
+            // Assert: before the line ending, the last 'x', the whole rewritten line break, or the 'y' after it
+            const std::string text(line.View());
+            const auto description = std::format("{} with a line break after {} of {} characters",
+                ASWLog::MultilineMode_ToString(item.Mode), length, room);
+            CheckEndsWith(text, std::string(ending), description);
+            CheckLessThanOrEqual(text.size(), ASWLog::Detail::TCrashText::Capacity, description);
+            const auto body = text.substr(0, text.size() - std::min(text.size(), ending.size()));
+            CheckTrue(body.ends_with('x') || body.ends_with('y') || body.ends_with(item.Rewritten),
+                description + ": the line break should be written whole or not at all");
+        }
+    }
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_AppendCrashLine_ShowsTheFields()
 {
     // Arrange: a kept entry with its own fields
@@ -1090,6 +1172,30 @@ void TTest_ASWLog_CrashHandler::Test_HandleCrash_CrashLineHasTheThreadsScopeFiel
         ASWLog::GetCurrentOSThreadId()), "The fixed-layout crash line should have them too");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_CrashHandler::Test_HandleCrash_FixedLayoutLineFollowsTheMultilineMode()
+{
+    // Arrange: an Indent logger with a multi-line backtrace entry (HandleCrashWhileLocked() holds its lock on another
+    // thread meanwhile), reconfigured to CRLF endings
+    auto config = MakeCrashTestConfig("multiline.log");
+    config.Backtrace.Capacity = 5;
+    config.Backtrace.LowestLevel = ASWLog::Level::Debug;
+    config.Line.Multiline = ASWLog::MultilineMode::Indent;
+    TLockableFileLog log;
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+    config.Line.Ending = ASWLog::LineEnding::CRLF;
+    CheckTrue(log.Reconfigure(config), "Reconfigure should succeed");
+    log.LogDebug("debug\nsecond");
+
+    // Act
+    HandleCrashWhileLocked(log, "busy\nreason");
+    const auto contents = ReadFileText(TestTempDir / "multiline.log");
+
+    // Assert
+    const auto ids = std::format("[P:{}][T:{}]: ", ASWLog::GetCurrentOSProcessId(), ASWLog::GetCurrentOSThreadId());
+    CheckContains(contents, "][DEBUG]" + ids + "debug\r\n    | second\r\n", "The backtrace entry should be indented");
+    CheckEndsWith(contents, "][CRITICAL]" + ids + "Crash: busy\r\n    | reason\r\n", "The crash line should be indented");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_CrashHandler::Test_HandleCrash_FlushesAndWritesTheCrashLine()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_CrashHandler.h b/tests/tests/Test_ASWLog_CrashHandler.h
index d8cb6b9..e52550a 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.h
+++ b/tests/tests/Test_ASWLog_CrashHandler.h
@@ -45,6 +45,8 @@ class TTest_ASWLog_CrashHandler : public TTestGroupBase
     void Test_AppendCrashJSONLine_UsesTheFixedLayout();
     void Test_AppendCrashLine_CutsALongMessageButKeepsTheEnding();
     void Test_AppendCrashLine_FieldsThatDontFitAreLeftOut();
+    void Test_AppendCrashLine_FollowsTheMultilineMode();
+    void Test_AppendCrashLine_NeverCutsARewrittenLineBreak();
     void Test_AppendCrashLine_ShowsTheFields();
     void Test_AppendCrashLine_ShowsTheCategory();
     void Test_AppendCrashLine_UsesTheFixedLayout();
@@ -59,6 +61,7 @@ class TTest_ASWLog_CrashHandler : public TTestGroupBase
     void Test_HandleCrash_ConsoleLogWritesTheLineToStdErr();
     void Test_HandleCrash_DisabledLoggerIsOnlyFlushed();
     void Test_HandleCrash_CrashLineHasTheThreadsScopeFields();
+    void Test_HandleCrash_FixedLayoutLineFollowsTheMultilineMode();
     void Test_HandleCrash_FlushesAndWritesTheCrashLine();
     void Test_HandleCrash_JSONLoggerGetsJSONLinesWhenTheLockStaysBusy();
     void Test_HandleCrash_SkipsClosedAndDestroyedLoggers();
diff --git a/tests/tests/Test_ASWLog_TextLogBase.cpp b/tests/tests/Test_ASWLog_TextLogBase.cpp
index e5c15a6..479e09f 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.cpp
+++ b/tests/tests/Test_ASWLog_TextLogBase.cpp
@@ -426,6 +426,10 @@ TTest_ASWLog_TextLogBase::TTest_ASWLog_TextLogBase()
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Log_ThrowingWriteDoesNotEscape, "Log_ThrowingWriteDoesNotEscape");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_LogRaw_FormatterCanFormatRawEntries, "LogRaw_FormatterCanFormatRawEntries");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_LogRaw_WritesMessageAsIs, "LogRaw_WritesMessageAsIs");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_Multiline_AppliesToEveryFormattersLine, "Multiline_AppliesToEveryFormattersLine");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_Multiline_EscapeKeepsEachEntryOnOneLine, "Multiline_EscapeKeepsEachEntryOnOneLine");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_Multiline_LogRawStaysAsIs, "Multiline_LogRawStaysAsIs");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_Multiline_PreserveWritesLineBreaksAsTheyAre, "Multiline_PreserveWritesLineBreaksAsTheyAre");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_OnLogEntry_CallbackCanReconfigureTheLogger, "OnLogEntry_CallbackCanReconfigureTheLogger");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Reconfigure_AppliesNewConfigButKeepsLevel, "Reconfigure_AppliesNewConfigButKeepsLevel");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Reconfigure_IsSafeWhileOtherThreadsLog, "Reconfigure_IsSafeWhileOtherThreadsLog");
@@ -1325,6 +1329,114 @@ void TTest_ASWLog_TextLogBase::Test_LogRaw_WritesMessageAsIs()
     CheckTrue(output.EndsLine == std::vector<bool>{ false, false }, "A raw entry doesn't end its line");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_Multiline_AppliesToEveryFormattersLine()
+{
+    // Arrange: Indent with CRLF endings, for the built-in layout, a pattern, a user's own formatter and JSON
+    auto config = MakeQuietConfig();
+    config.Line.Multiline = ASWLog::MultilineMode::Indent;
+    config.Line.Ending = ASWLog::LineEnding::CRLF;
+
+    const auto logWith = [&config](std::shared_ptr<const ASWLog::IASWLogFormatter> formatter) {
+            TMemoryOutput output;
+            auto formatterConfig = config;
+            formatterConfig.Line.Formatter = std::move(formatter);
+            TMemoryTextLog log(output);
+            if (log.Initialize(formatterConfig))
+                log.LogInfo("first\nsecond");
+
+            return output.Lines;
+        };
+
+    // Act
+    const auto textLines = logWith(nullptr);
+    const auto patternLines = logWith(std::make_shared<const ASWLog::TASWPatternFormatter>("{level}|{message} <"));
+    const auto ownLines = logWith(std::make_shared<const TPipeFormatter>());
+    const auto jsonLines = logWith(std::make_shared<const ASWLog::TASWJSONFormatter>());
+
+    // Assert
+    CheckTrue(textLines == std::vector<std::string>{ "[INFO]: first\r\n    | second\r\n" }, "The built-in layout's line should be indented");
+    CheckTrue(patternLines == std::vector<std::string>{ "INFO|first\r\n    | second <\r\n" }, "A pattern's line should be indented");
+    CheckTrue(ownLines == std::vector<std::string>{ "INFO|first\r\n    | second\r\n" }, "A user's own formatter's line should be indented");
+    CheckTrue(jsonLines == std::vector<std::string>{ "{\"level\":\"INFO\",\"message\":\"first\\nsecond\"}\r\n" },
+        "A JSON line has no line break to indent");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_Multiline_EscapeKeepsEachEntryOnOneLine()
+{
+    // Arrange: a logger that starts with Preserve and is reconfigured to Escape, and an asynchronous one
+    TMemoryOutput output;
+    TMemoryOutput asyncOutput;
+    std::vector<std::string> callbackLines;
+    auto config = MakeQuietConfig();
+    config.OnLogEntryMinimumLevel = ASWLog::Level::Info;
+    config.OnLogEntry = [&callbackLines](const ASWLog::TASWLogRecord& /*record*/, std::string_view line) {
+            callbackLines.emplace_back(line);
+        };
+    auto escapeConfig = config;
+    escapeConfig.Line.Multiline = ASWLog::MultilineMode::Escape;
+    auto asyncConfig = MakeAsyncConfig();
+    asyncConfig.Line.Multiline = ASWLog::MultilineMode::Escape;
+    TMemoryTextLog log(output);
+    TMemoryTextLog asyncLog(asyncOutput);
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+    CheckTrue(asyncLog.Initialize(asyncConfig), "Initialize should succeed (async)");
+
+    // Act
+    log.LogInfo("first\nline");
+    const bool reconfigured = log.Reconfigure(escapeConfig);
+    log.LogInfo("GET /\r\nHost: x\r\n");
+    asyncLog.LogInfo("GET /\r\nHost: x\r\n");
+    asyncLog.Flush(); // Waits for the queued entry
+
+    // Assert
+    const std::vector<std::string> expected{ "[INFO]: first\nline\n", "[INFO]: GET /\\r\\nHost: x\\r\\n\n" };
+    CheckTrue(reconfigured, "Reconfigure should succeed");
+    CheckTrue(output.Lines == expected, "After Reconfigure, the line breaks should be escaped");
+    CheckTrue(callbackLines == expected, "OnLogEntry should get the line as written");
+    CheckTrue(asyncOutput.Lines == std::vector<std::string>{ expected[1] }, "A queued line's line breaks should be escaped");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_Multiline_LogRawStaysAsIs()
+{
+    // Arrange: Indent, without and with a formatter that formats raw entries
+    TMemoryOutput output;
+    TMemoryOutput formattedOutput;
+    auto config = MakeQuietConfig();
+    config.Line.Multiline = ASWLog::MultilineMode::Indent;
+    auto formattedConfig = config;
+    formattedConfig.Line.Formatter = std::make_shared<const TRawFormattingFormatter>();
+    TMemoryTextLog log(output);
+    TMemoryTextLog formattedLog(formattedOutput);
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+    CheckTrue(formattedLog.Initialize(formattedConfig), "Initialize should succeed (formatted raw entries)");
+
+    // Act
+    log.LogRaw(ASWLog::Level::Info, "a\nb\n");
+    log.LogForceRaw(ASWLog::Level::Trace, "c\r\nd");
+    formattedLog.LogRaw(ASWLog::Level::Info, "a\nb");
+
+    // Assert
+    CheckTrue(output.Lines == std::vector<std::string>{ "a\nb\n", "c\r\nd" }, "Raw entries written as is should stay as they are");
+    CheckTrue(formattedOutput.Lines == std::vector<std::string>{ "raw|a\n    | b\n" },
+        "A raw entry the formatter formats should be indented like any formatted line");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_Multiline_PreserveWritesLineBreaksAsTheyAre()
+{
+    // Arrange: the default mode, with CRLF endings
+    TMemoryOutput output;
+    auto config = MakeQuietConfig();
+    config.Line.Ending = ASWLog::LineEnding::CRLF;
+    TMemoryTextLog log(output);
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+
+    // Act
+    log.LogInfo("a\r\nb\nc\rd\n");
+
+    // Assert: no line break converted to the line ending
+    CheckTrue(output.Lines == std::vector<std::string>{ "[INFO]: a\r\nb\nc\rd\n\r\n" }, "The message should be written as it is");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_TextLogBase::Test_OnLogEntry_CallbackCanReconfigureTheLogger()
 {
     // Arrange: a callback that replaces the config it belongs to, e.g. to turn itself off after the first error. The
diff --git a/tests/tests/Test_ASWLog_TextLogBase.h b/tests/tests/Test_ASWLog_TextLogBase.h
index 594adf1..3655b9c 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.h
+++ b/tests/tests/Test_ASWLog_TextLogBase.h
@@ -63,6 +63,10 @@ class TTest_ASWLog_TextLogBase : public TTestGroupBase
     void Test_Log_ThrowingWriteDoesNotEscape();
     void Test_LogRaw_FormatterCanFormatRawEntries();
     void Test_LogRaw_WritesMessageAsIs();
+    void Test_Multiline_AppliesToEveryFormattersLine();
+    void Test_Multiline_EscapeKeepsEachEntryOnOneLine();
+    void Test_Multiline_LogRawStaysAsIs();
+    void Test_Multiline_PreserveWritesLineBreaksAsTheyAre();
     void Test_OnLogEntry_CallbackCanReconfigureTheLogger();
     void Test_Reconfigure_AppliesNewConfigButKeepsLevel();
     void Test_Reconfigure_IsSafeWhileOtherThreadsLog();
diff --git a/tests/tests/Test_ASWLog_Types.cpp b/tests/tests/Test_ASWLog_Types.cpp
index 6947ca4..d85d25e 100644
--- a/tests/tests/Test_ASWLog_Types.cpp
+++ b/tests/tests/Test_ASWLog_Types.cpp
@@ -53,6 +53,8 @@ TTest_ASWLog_Types::TTest_ASWLog_Types()
     RegisterTest(&TTest_ASWLog_Types::Test_LineEnding_FromString, "LineEnding_FromString");
     RegisterTest(&TTest_ASWLog_Types::Test_LineEnding_ToString, "LineEnding_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_LogError_ToString, "LogError_ToString");
+    RegisterTest(&TTest_ASWLog_Types::Test_MultilineMode_FromString, "MultilineMode_FromString");
+    RegisterTest(&TTest_ASWLog_Types::Test_MultilineMode_ToString, "MultilineMode_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_FromString, "TimePrecision_FromString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_ToString, "TimePrecision_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimeZone_FromString, "TimeZone_FromString");
@@ -315,6 +317,29 @@ void TTest_ASWLog_Types::Test_LogError_ToString()
     CheckEquals("OPEN_FAILED: Couldn't open the log file 'logs/app.log': " + code.message() + " (3 more not reported)", everyPartText, "Every part should be in the line");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_MultilineMode_FromString()
+{
+    // Arrange
+    const auto preserve = ASWLog::MultilineMode_FromString("PRESERVE");
+    const auto indent = ASWLog::MultilineMode_FromString("indent");
+    const auto escape = ASWLog::MultilineMode_FromString("Escape");
+    const auto unknown = ASWLog::MultilineMode_FromString("verbatim");
+
+    // Act & Assert
+    CheckTrue(preserve == ASWLog::MultilineMode::Preserve, "PRESERVE should map to Preserve");
+    CheckTrue(indent == ASWLog::MultilineMode::Indent, "indent should map to Indent, ignoring case");
+    CheckTrue(escape == ASWLog::MultilineMode::Escape, "Escape should map to Escape, ignoring case");
+    CheckFalse(unknown.has_value(), "An unknown mode should not parse");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_MultilineMode_ToString()
+{
+    // Act & Assert
+    CheckEquals(std::string("PRESERVE"), std::string(ASWLog::MultilineMode_ToString(ASWLog::MultilineMode::Preserve)), "Preserve should stringify as PRESERVE");
+    CheckEquals(std::string("INDENT"), std::string(ASWLog::MultilineMode_ToString(ASWLog::MultilineMode::Indent)), "Indent should stringify as INDENT");
+    CheckEquals(std::string("ESCAPE"), std::string(ASWLog::MultilineMode_ToString(ASWLog::MultilineMode::Escape)), "Escape should stringify as ESCAPE");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_TimePrecision_FromString()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_Types.h b/tests/tests/Test_ASWLog_Types.h
index 69b5735..61f0486 100644
--- a/tests/tests/Test_ASWLog_Types.h
+++ b/tests/tests/Test_ASWLog_Types.h
@@ -47,6 +47,8 @@ class TTest_ASWLog_Types : public TTestGroupBase
     void Test_Level_ToString();
     void Test_LineEnding_FromString();
     void Test_LineEnding_ToString();
+    void Test_MultilineMode_FromString();
+    void Test_MultilineMode_ToString();
     void Test_LogError_ToString();
     void Test_TimePrecision_FromString();
     void Test_TimePrecision_ToString();
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index a71b97a..ca03a37 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -62,6 +62,14 @@ constexpr bool HasSubmicrosecondClock = std::ratio_less_v<std::chrono::system_cl
 
 //---------------------------------------------------------------------------
 
+// 'text' as Detail::ApplyMultilineMode() rewrites it
+std::string ApplyMode(std::string text, ASWLog::MultilineMode mode, ASWLog::LineEnding ending = ASWLog::LineEnding::LF)
+{
+    ASWLog::Detail::ApplyMultilineMode(text, mode, ending);
+
+    return text;
+}
+
 std::string ReadText(const std::filesystem::path& path)
 {
     std::ifstream stream(path, std::ios::binary);
@@ -95,6 +103,10 @@ std::string ToJSONString(std::string_view text)
 TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     : inherited("ASWLog_Utils_Tests")
 {
+    RegisterTest(&TTest_ASWLog_Utils::Test_ApplyMultilineMode_EscapeWritesCRAndLFAsText, "ApplyMultilineMode_EscapeWritesCRAndLFAsText");
+    RegisterTest(&TTest_ASWLog_Utils::Test_ApplyMultilineMode_FindsLineBreaksAnywhereInALongText, "ApplyMultilineMode_FindsLineBreaksAnywhereInALongText");
+    RegisterTest(&TTest_ASWLog_Utils::Test_ApplyMultilineMode_IndentMarksEachLineAfterTheFirst, "ApplyMultilineMode_IndentMarksEachLineAfterTheFirst");
+    RegisterTest(&TTest_ASWLog_Utils::Test_ApplyMultilineMode_LeavesOtherLinesAsTheyAre, "ApplyMultilineMode_LeavesOtherLinesAsTheyAre");
     RegisterTest(&TTest_ASWLog_Utils::Test_GenerateLogFileName_ContainsExpectedFields, "GenerateLogFileName_ContainsExpectedFields");
     RegisterTest(&TTest_ASWLog_Utils::Test_GenerateLogFileName_PrefixAndPostfixAreOptional, "GenerateLogFileName_PrefixAndPostfixAreOptional");
     RegisterTest(&TTest_ASWLog_Utils::Test_GetCurrentOSProcessId_MatchesOS, "GetCurrentOSProcessId_MatchesOS");
@@ -143,6 +155,114 @@ void TTest_ASWLog_Utils::TearDown_Test(ITestCase& /*testCase*/)
 
 // /////// Begin tests after this line ///////////////////////
 
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_ApplyMultilineMode_EscapeWritesCRAndLFAsText()
+{
+    // Arrange: each CR and LF, alone or together, and other text around them
+    struct TCase
+    {
+        std::string Text;
+        std::string Expected;
+    };
+
+    const std::vector<TCase> cases{
+        { "a\r\nb\nc\rd", "a\\r\\nb\\nc\\rd" }, { "a\n\n", "a\\n\\n" }, { "\r", "\\r" },
+        { "C:\\temp\\new\n", "C:\\temp\\new\\n" }, { "\t\"x\"\xCE\xBB\n", "\t\"x\"\xCE\xBB\\n" }
+    };
+
+    // Act & Assert: the line ending doesn't matter
+    for (const auto& item : cases)
+    {
+        CheckEquals(item.Expected, ApplyMode(item.Text, ASWLog::MultilineMode::Escape),
+            "Only CR and LF should be escaped, with LF endings: " + ToHex(item.Text));
+        CheckEquals(item.Expected, ApplyMode(item.Text, ASWLog::MultilineMode::Escape, ASWLog::LineEnding::CRLF),
+            "Only CR and LF should be escaped, with CRLF endings: " + ToHex(item.Text));
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_ApplyMultilineMode_FindsLineBreaksAnywhereInALongText()
+{
+    // Arrange: text is scanned 8 bytes at a time, so each line break goes at every position of the first two 8-byte
+    // words of a longer text, with what it should become
+    struct TCase
+    {
+        ASWLog::MultilineMode Mode;
+        std::string Text;
+        std::string Expected;
+    };
+
+    const std::vector<TCase> breaks{
+        { ASWLog::MultilineMode::Indent, "\n", "\n    | " }, { ASWLog::MultilineMode::Indent, "\r\n", "\n    | " },
+        { ASWLog::MultilineMode::Indent, "\r", "\r" }, { ASWLog::MultilineMode::Escape, "\n", "\\n" },
+        { ASWLog::MultilineMode::Escape, "\r", "\\r" }
+    };
+
+    // Act & Assert
+    for (const auto& item : breaks)
+    {
+        for (std::size_t position = 0; position < 16; ++position)
+        {
+            const std::string before(position, 'a');
+            const std::string after(24 - position, 'z');
+            CheckEquals(before + item.Expected + after, ApplyMode(before + item.Text + after, item.Mode),
+                std::format("{} at index {} should be found ({})", ToHex(item.Text), position,
+                    ASWLog::MultilineMode_ToString(item.Mode)));
+        }
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_ApplyMultilineMode_IndentMarksEachLineAfterTheFirst()
+{
+    // Arrange
+    struct TCase
+    {
+        std::string Text;
+        ASWLog::LineEnding Ending;
+        std::string Expected;
+    };
+
+    constexpr auto LF = ASWLog::LineEnding::LF;
+    constexpr auto CRLF = ASWLog::LineEnding::CRLF;
+    const std::vector<TCase> cases{
+        // Each "\n" or "\r\n" becomes the line ending and the marker
+        { "a\nb", LF, "a\n    | b" }, { "a\nb", CRLF, "a\r\n    | b" }, { "a\r\nb", LF, "a\n    | b" },
+        { "a\r\nb", CRLF, "a\r\n    | b" }, { "\nb", LF, "\n    | b" }, { "a\n  b", LF, "a\n    |   b" },
+        // An empty line gets the marker without its space, at the end too
+        { "a\n", LF, "a\n    |" }, { "\n", CRLF, "\r\n    |" }, { "a\n\nb", LF, "a\n    |\n    | b" },
+        { "a\r\n\r\nb", CRLF, "a\r\n    |\r\n    | b" }, { "a\n\r\n", LF, "a\n    |\n    |" },
+        // A lone CR stays as it is
+        { "a\rb", LF, "a\rb" }, { "a\r", CRLF, "a\r" }, { "a\r\r\nb", LF, "a\r\n    | b" }, { "a\n\rb", LF, "a\n    | \rb" }
+    };
+
+    // Act & Assert
+    for (const auto& item : cases)
+    {
+        CheckEquals(item.Expected, ApplyMode(item.Text, ASWLog::MultilineMode::Indent, item.Ending),
+            std::format("{} with {} endings", ToHex(item.Text), ASWLog::LineEnding_ToString(item.Ending)));
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_ApplyMultilineMode_LeavesOtherLinesAsTheyAre()
+{
+    // Arrange
+    const std::string multiline = "a\r\nb\n\rc\r";
+    std::string plain = "[2026-09-28T21:02:44.342Z][INFO]: no line break here, but more than 8 characters";
+    const char* plainData = plain.data();
+
+    // Act
+    const auto preservedLF = ApplyMode(multiline, ASWLog::MultilineMode::Preserve);
+    const auto preservedCRLF = ApplyMode(multiline, ASWLog::MultilineMode::Preserve, ASWLog::LineEnding::CRLF);
+    ASWLog::Detail::ApplyMultilineMode(plain, ASWLog::MultilineMode::Indent, ASWLog::LineEnding::LF);
+    ASWLog::Detail::ApplyMultilineMode(plain, ASWLog::MultilineMode::Escape, ASWLog::LineEnding::LF);
+
+    // Assert
+    CheckEquals(multiline, preservedLF, "Preserve should leave every line break as it is (LF endings)");
+    CheckEquals(multiline, preservedCRLF, "Preserve should leave every line break as it is (CRLF endings)");
+    CheckEquals(std::string("[2026-09-28T21:02:44.342Z][INFO]: no line break here, but more than 8 characters"), plain,
+        "A line without line breaks should stay as it is");
+    CheckSame(plainData, plain.data(), "A line without line breaks should be left in place, not copied");
+    CheckEquals(std::string(), ApplyMode("", ASWLog::MultilineMode::Indent), "An empty line should stay empty");
+}
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_GenerateLogFileName_ContainsExpectedFields()
 {
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index 28e8c4f..10ef84e 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -36,6 +36,10 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     typedef TTestGroupBase inherited;
 
 private: // Test methods
+    void Test_ApplyMultilineMode_EscapeWritesCRAndLFAsText();
+    void Test_ApplyMultilineMode_FindsLineBreaksAnywhereInALongText();
+    void Test_ApplyMultilineMode_IndentMarksEachLineAfterTheFirst();
+    void Test_ApplyMultilineMode_LeavesOtherLinesAsTheyAre();
     void Test_GenerateLogFileName_ContainsExpectedFields();
     void Test_GenerateLogFileName_PrefixAndPostfixAreOptional();
     void Test_GetCurrentOSProcessId_MatchesOS();

From 3f88ac27d822189022bdd03bfeed6be8311c4909 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Fri, 9 Oct 2026 01:04:33 -0700
Subject: [PATCH 11/38] Add a hook to filter or change entries before they are
 written

---
 ASWLog/ASWLog_Base.cpp                  |  98 ++++++++++++--
 ASWLog/ASWLog_Base.h                    |   6 +-
 ASWLog/ASWLog_Config.h                  |  15 ++
 ASWLog/ASWLog_MultiLog.cpp              |  29 +++-
 ASWLog/ASWLog_MultiLog.h                |  14 +-
 ASWLog/ASWLog_Types.cpp                 |  98 ++++++++++++++
 ASWLog/ASWLog_Types.h                   |  56 ++++++++
 CHANGELOG.md                            |  14 ++
 README.md                               |   2 +
 tests/tests/Test_ASWLog_Base.cpp        | 173 ++++++++++++++++++++++++
 tests/tests/Test_ASWLog_Base.h          |   5 +
 tests/tests/Test_ASWLog_Config.cpp      |   1 +
 tests/tests/Test_ASWLog_MultiLog.cpp    |  51 ++++++-
 tests/tests/Test_ASWLog_MultiLog.h      |   1 +
 tests/tests/Test_ASWLog_TextLogBase.cpp | 159 ++++++++++++++++++++++
 tests/tests/Test_ASWLog_TextLogBase.h   |   3 +
 tests/tests/Test_ASWLog_Types.cpp       | 163 ++++++++++++++++++++++
 tests/tests/Test_ASWLog_Types.h         |   5 +
 18 files changed, 873 insertions(+), 20 deletions(-)

diff --git a/ASWLog/ASWLog_Base.cpp b/ASWLog/ASWLog_Base.cpp
index bafed07..2c0924c 100644
--- a/ASWLog/ASWLog_Base.cpp
+++ b/ASWLog/ASWLog_Base.cpp
@@ -79,6 +79,28 @@ class TReportingErrorScope
     TReportingErrorScope& operator=(const TReportingErrorScope&) = delete;
 };
 
+// True while this thread is in a logger's OnBeforeWrite hook (see TASWLogBase::WriteThroughHook()). Read only by a
+// logger that has a hook, since a thread_local read is a library call with some compilers (e.g. MinGW's GCC).
+thread_local bool IsRunningBeforeWrite = false;
+
+// Sets IsRunningBeforeWrite while alive (hooks don't nest: an entry logged inside one skips them)
+class TRunningBeforeWriteScope
+{
+public:
+    TRunningBeforeWriteScope() noexcept
+    {
+        IsRunningBeforeWrite = true;
+    }
+
+    ~TRunningBeforeWriteScope()
+    {
+        IsRunningBeforeWrite = false;
+    }
+
+    TRunningBeforeWriteScope(const TRunningBeforeWriteScope&) = delete;
+    TRunningBeforeWriteScope& operator=(const TRunningBeforeWriteScope&) = delete;
+};
+
 //---------------------------------------------------------------------------
 
 void ForgetCopiedViews(TASWLogRecord& record) noexcept;
@@ -319,6 +341,8 @@ std::shared_ptr<const TASWLogConfig> TASWLogBase::SetConfig(const TASWLogConfig&
         m_Config.swap(snapshot);
     }
 
+    m_HasBeforeWrite.store(config.OnBeforeWrite != nullptr, std::memory_order_relaxed);
+
     if (KeepsBacktrace())
         ApplyBacktraceConfig(config.Backtrace);
 
@@ -374,18 +398,11 @@ void TASWLogBase::Write(const TASWLogRecord& record) noexcept
     // never throw into the application, so the entry is dropped instead
     try
     {
-        // Let in only for the backtrace. Read again: if the minimum level changed since the gate, the entry is kept or
-        // written as if it had been logged just before or after the change.
-        if (!record.Forced && record.LogLevel < GetMinimumLevelFor(record))
-        {
-            KeepInBacktrace(stampedRecord);
-            return;
-        }
-
-        if (m_HasBacktrace.load(std::memory_order_relaxed) && record.LogLevel >= m_BacktraceDumpLevel.load(std::memory_order_relaxed))
-            WriteBacktrace();
-
-        WriteRecord(stampedRecord);
+        // An entry logged from inside a hook is written as it is, so a hook that logs doesn't recurse
+        if (m_HasBeforeWrite.load(std::memory_order_relaxed) && !IsRunningBeforeWrite)
+            WriteThroughHook(stampedRecord);
+        else
+            WriteOrKeep(stampedRecord);
     }
     catch (...)
     {
@@ -437,6 +454,63 @@ void TASWLogBase::WriteBacktrace()
     writeMarker(Detail::BacktraceEndText);
 }
 
+//---------------------------------------------------------------------------
+/*
+    TASWLogBase::WriteOrKeep
+
+    Write()'s last step, for a stamped entry that passed the gate (and the hook, if any): keeps it in the backtrace if
+    only the backtrace let it in, else writes the backtrace first if the entry's level dumps it, then the entry.
+*/
+void TASWLogBase::WriteOrKeep(const TASWLogRecord& record)
+{
+    // Read again: if the minimum level changed since the gate, the entry is kept or written as if it had been logged
+    // just before or after the change
+    if (!record.Forced && record.LogLevel < GetMinimumLevelFor(record))
+    {
+        KeepInBacktrace(record);
+        return;
+    }
+
+    if (m_HasBacktrace.load(std::memory_order_relaxed) && record.LogLevel >= m_BacktraceDumpLevel.load(std::memory_order_relaxed))
+        WriteBacktrace();
+
+    WriteRecord(record);
+}
+
+//---------------------------------------------------------------------------
+/*
+    TASWLogBase::WriteThroughHook
+
+    Passes a stamped entry to the config's OnBeforeWrite hook, then on to WriteOrKeep() as the hook changed it, unless
+    the hook drops it. A hook that throws drops the entry, which is reported.
+*/
+void TASWLogBase::WriteThroughHook(const TASWLogRecord& record)
+{
+    const auto config = GetConfig();
+    if (config->OnBeforeWrite == nullptr)
+    {
+        WriteOrKeep(record); // Reconfigured without a hook since Write() checked
+        return;
+    }
+
+    TASWPendingEntry entry(record);
+    bool isKept = false;
+
+    try
+    {
+        TRunningBeforeWriteScope runningScope;
+        isKept = config->OnBeforeWrite(entry);
+    }
+    catch (...)
+    {
+        ReportError(*config, MakeExceptionError("Dropped an entry, OnBeforeWrite threw"));
+        return;
+    }
+
+    if (isKept)
+        WriteOrKeep(entry.GetRecord());
+}
+
 //---------------------------------------------------------------------------
 /*
     TASWLogBase::WriteErrorToStdErr
diff --git a/ASWLog/ASWLog_Base.h b/ASWLog/ASWLog_Base.h
index 0e3de69..685181a 100644
--- a/ASWLog/ASWLog_Base.h
+++ b/ASWLog/ASWLog_Base.h
@@ -136,6 +136,7 @@ class TASWLogBase : public IASWLog
     // m_ConfigMutex held, and the derived logger with its own lock held (see GetConfigUnlocked()).
     mutable Detail::TMutex m_ConfigMutex;
     std::shared_ptr<const TASWLogConfig> m_Config{ std::make_shared<const TASWLogConfig>() };
+    std::atomic<bool> m_HasBeforeWrite{ false }; // The config has an OnBeforeWrite hook; read for each written entry
 
     // When ReportError() last reported each ErrorKind, and how many it left out since (see
     // TASWLogConfig::ErrorReportInterval). Guarded by m_ErrorReportMutex.
@@ -155,6 +156,8 @@ class TASWLogBase : public IASWLog
     std::vector<TBacktraceEntry> TakeBacktrace() noexcept;
     void WriteBacktrace();
     void WriteErrorToStdErr(const TASWLogError& error) const;
+    void WriteOrKeep(const TASWLogRecord& record);
+    void WriteThroughHook(const TASWLogRecord& record);
 
 protected:
     std::atomic<bool> m_IsInitialized{ false };
@@ -286,7 +289,8 @@ class TASWLogBase : public IASWLog
     }
 
     // Called by Write() with each entry this logger writes: it passed the enabled, Level::Off and minimum level checks
-    // (see Write()), and has its Timestamp, ProcessId and ThreadId filled in. Called on the logging thread. May throw:
+    // (see Write()), has its Timestamp, ProcessId and ThreadId filled in, and is as the config's OnBeforeWrite hook, if
+    // any, changed it (the backtrace's entries were changed when kept). Called on the logging thread. May throw:
     // Write() catches the exception and drops the entry, so it never reaches the application.
     virtual void WriteRecord(const TASWLogRecord& record) = 0;
 
diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 7edaf19..b36610f 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -301,6 +301,21 @@ struct TASWLogConfig
     TASWAsyncConfig Async;
     TASWBacktraceConfig Backtrace;
 
+    // --- Pre-write Hook ---
+    // A last chance for the application to drop or change each of its entries before the logger writes it, e.g. to
+    // redact secrets or personal data, or to drop noisy entries by content or category. Return false to drop the entry;
+    // to change it, call entry.SetMessage(), SetField() or RemoveField(). Called for each application entry that passes
+    // the level checks (LogRaw() entries included, with record.Raw set; those the backtrace keeps too, which it then
+    // keeps as changed), on the logging thread, before the logger takes its lock or queues the entry, so it may log to
+    // another logger, and threads that log at the same time call it at the same time (keep it thread-safe and quick).
+    // An entry logged from inside the hook, on its thread, skips the hooks and is written as it is. The
+    // logger's own lines (startup, shutdown, backtrace markers, crash lines) don't pass through it. If it throws, the
+    // entry is dropped and the exception reported (see OnError). OnLogEntry gets the changed entry. A multi-log calls
+    // its hook once per entry and passes the changed entry on; the config it passes to its loggers has no hook. With no
+    // hook set, a written entry costs one more flag check.
+    using BeforeWriteCallback = std::function<bool (TASWPendingEntry& entry)>;
+    BeforeWriteCallback OnBeforeWrite;
+
     // --- Log Entry Callback Options ---
     // Receives the entry's record (with its time and ids) and the line as written. Both are only valid during the call.
     using LogCallback = std::function<void (const TASWLogRecord& record, std::string_view formattedLine)>;
diff --git a/ASWLog/ASWLog_MultiLog.cpp b/ASWLog/ASWLog_MultiLog.cpp
index fe0a1d2..5b45603 100644
--- a/ASWLog/ASWLog_MultiLog.cpp
+++ b/ASWLog/ASWLog_MultiLog.cpp
@@ -31,6 +31,29 @@ limitations under the License.
 namespace ASWLog
 {
 
+namespace
+{
+
+TASWLogConfig MakeSinkConfig(const TASWLogConfig& config);
+
+//---------------------------------------------------------------------------
+
+/*
+  MakeSinkConfig
+
+  The config a multi-log passes to its loggers: its own, without the OnBeforeWrite hook, which the multi-log calls
+  itself, once per entry
+*/
+TASWLogConfig MakeSinkConfig(const TASWLogConfig& config)
+{
+    TASWLogConfig sinkConfig = config;
+    sinkConfig.OnBeforeWrite = nullptr;
+
+    return sinkConfig;
+}
+
+} // namespace
+
 //---------------------------------------------------------------------------
 
 /////////////////////////////////////////////////////////////////////////////
@@ -151,10 +174,11 @@ bool TASWMultiLog::Initialize(const TASWLogConfig& config) noexcept
             m_IsInitialized.store(true, std::memory_order_release);
         }
 
+        const auto sinkConfig = MakeSinkConfig(config);
         bool allSucceeded = true;
         for (auto* sink : SnapshotSinks())
         {
-            if (!sink->Initialize(config) && !sink->IsOpen())
+            if (!sink->Initialize(sinkConfig) && !sink->IsOpen())
                 allSucceeded = false;
         }
 
@@ -221,10 +245,11 @@ bool TASWMultiLog::Reconfigure(const TASWLogConfig& config) noexcept
             previousConfig = SetConfig(config);
         }
 
+        const auto sinkConfig = MakeSinkConfig(config);
         bool allSucceeded = true;
         for (auto* sink : SnapshotSinks())
         {
-            if (!sink->Reconfigure(config))
+            if (!sink->Reconfigure(sinkConfig))
                 allSucceeded = false;
         }
 
diff --git a/ASWLog/ASWLog_MultiLog.h b/ASWLog/ASWLog_MultiLog.h
index 419b880..eaa6ebd 100644
--- a/ASWLog/ASWLog_MultiLog.h
+++ b/ASWLog/ASWLog_MultiLog.h
@@ -62,6 +62,10 @@ namespace ASWLog
 // It keeps no backtrace either (each sink keeps its own, see
 // TASWBacktraceConfig), so its minimum level must be at or below the
 // sinks' Backtrace.LowestLevel for their backtraces to get those entries.
+// Its OnBeforeWrite hook runs once per entry, before the fan-out, and the
+// sinks get the entry as the hook changed it; the config it passes to them
+// has no hook (a sink initialized on its own keeps its own hook, which runs
+// after this one's).
 /////////////////////////////////////////////////////////////////////////////
 class TASWMultiLog : public TASWLogBase
 {
@@ -112,11 +116,13 @@ class TASWMultiLog : public TASWLogBase
     // Fans out to every registered sink, tolerating sinks that are already initialized/open (their own Initialize()
     // may correctly return false in that case, e.g. a singleton initialized elsewhere before being added here) rather
     // than treating that as a failure. Returns true only if every sink ends up initialized or open. Returns false without
-    // doing anything if this composite is already initialized; after Close() it can be initialized again. Thread-safe.
+    // doing anything if this composite is already initialized; after Close() it can be initialized again. The sinks get
+    // the config without its OnBeforeWrite hook, which this composite calls itself. Thread-safe.
     bool Initialize(const TASWLogConfig& config) noexcept override;
-    // Stores the config and passes it to every registered sink's Reconfigure(), even if one fails. Returns true only if
-    // every sink's Reconfigure() succeeds; false without doing anything if this composite isn't initialized. A sink
-    // that needs settings of its own is reconfigured directly instead. Thread-safe.
+    // Stores the config and passes it (without OnBeforeWrite, as Initialize() does) to every registered sink's
+    // Reconfigure(), even if one fails. Returns true only if every sink's Reconfigure() succeeds; false without doing
+    // anything if this composite isn't initialized. A sink that needs settings of its own is reconfigured directly
+    // instead. Thread-safe.
     bool Reconfigure(const TASWLogConfig& config) noexcept override;
 
     bool Open() noexcept override;
diff --git a/ASWLog/ASWLog_Types.cpp b/ASWLog/ASWLog_Types.cpp
index 65fadb1..fd8220f 100644
--- a/ASWLog/ASWLog_Types.cpp
+++ b/ASWLog/ASWLog_Types.cpp
@@ -30,6 +30,8 @@ limitations under the License.
 #include <iomanip>
 #include <iostream>
 #include <sstream>
+#include <utility>
+#include <vector>
 //---------------------------------------------------------------------------
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
@@ -209,4 +211,100 @@ std::string TASWLogError::ToString() const
 
 //---------------------------------------------------------------------------
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWPendingEntry
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWPendingEntry::TASWPendingEntry(const TASWLogRecord& record) noexcept
+    : m_Record(record)
+{
+}
+
+//---------------------------------------------------------------------------
+const TASWLogValue* TASWPendingEntry::FindField(std::string_view key) const noexcept
+{
+    const TASWLogValue* value = nullptr;
+    m_Record.ForEachField([key, &value](const TASWLogField& field) {
+            if (field.Key == key)
+                value = &field.Value;
+        });
+
+    return value;
+}
+
+//---------------------------------------------------------------------------
+const TASWLogRecord& TASWPendingEntry::GetRecord() const noexcept
+{
+    return m_Record;
+}
+
+//---------------------------------------------------------------------------
+void TASWPendingEntry::RemoveField(std::string_view key)
+{
+    if (FindField(key) == nullptr)
+        return;
+
+    std::vector<TASWLogField> fields;
+    m_Record.ForEachField([key, &fields](const TASWLogField& field) {
+            if (field.Key != key)
+                fields.push_back(field);
+        });
+
+    ReplaceFields(fields);
+}
+
+//---------------------------------------------------------------------------
+/*
+    TASWPendingEntry::ReplaceFields
+
+    Makes 'fields' (copied; they may refer to the current copies) the entry's only fields, in place of its own and its
+    scopes'. The copies they replace are kept until the entry ends, so a ForEachField() under way can finish.
+*/
+void TASWPendingEntry::ReplaceFields(std::span<const TASWLogField> fields)
+{
+    Detail::TOwnedFields replacement;
+    replacement.Assign(fields);
+
+    if (!m_Fields.Get().empty())
+        m_ReplacedFields.push_back(std::move(m_Fields));
+
+    m_Fields = std::move(replacement);
+    m_FieldsView = m_Fields.Get();
+    m_Record.Fields = &m_FieldsView;
+    m_Record.Scope = nullptr;
+}
+
+//---------------------------------------------------------------------------
+void TASWPendingEntry::SetField(std::string_view key, const TASWLogValue& value)
+{
+    std::vector<TASWLogField> fields;
+    bool isReplaced = false;
+    m_Record.ForEachField([key, &value, &fields, &isReplaced](const TASWLogField& field) {
+            if (field.Key == key)
+            {
+                fields.push_back(TASWLogField{ field.Key, value });
+                isReplaced = true;
+            }
+            else
+            {
+                fields.push_back(field);
+            }
+        });
+
+    if (!isReplaced)
+        fields.push_back(TASWLogField{ key, value });
+
+    ReplaceFields(fields);
+}
+
+//---------------------------------------------------------------------------
+void TASWPendingEntry::SetMessage(std::string message) noexcept
+{
+    m_Message = std::move(message);
+    m_Record.Message = m_Message;
+}
+
+//---------------------------------------------------------------------------
+
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index 5ccb058..a96c3b0 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -39,6 +39,7 @@ limitations under the License.
 #include <string>
 #include <string_view>
 #include <system_error>
+#include <vector>
 //---------------------------------------------------------------------------
 #include "ASWLog_Fields.h"
 //---------------------------------------------------------------------------
@@ -505,6 +506,61 @@ struct TASWLogRecord
 
 //---------------------------------------------------------------------------
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWPendingEntry
+//
+// An entry about to be written, as TASWLogConfig::OnBeforeWrite gets it: the hook reads the record and may change its
+// message and fields before the logger writes it. The entry owns what the hook sets, so the hook's own strings may be
+// temporaries. Its level, time, ids, category, location and flags can't be changed (the logger has already checked
+// the level). Only valid during the hook's call.
+/////////////////////////////////////////////////////////////////////////////
+class TASWPendingEntry
+{
+private:
+    TASWLogRecord m_Record; // Its Message and Fields refer to the copies below once the hook has set them
+    std::string m_Message;
+    Detail::TOwnedFields m_Fields; // After a field change: all the entry's fields, each key once
+    std::span<const TASWLogField> m_FieldsView; // What m_Record.Fields points to after a field change
+    std::vector<Detail::TOwnedFields> m_ReplacedFields; // Kept, so a ForEachField() under way can finish
+
+private:
+    void ReplaceFields(std::span<const TASWLogField> fields);
+
+public:
+    explicit TASWPendingEntry(const TASWLogRecord& record) noexcept;
+
+    TASWPendingEntry(const TASWPendingEntry&) = delete;
+    TASWPendingEntry& operator=(const TASWPendingEntry&) = delete;
+
+    // The value of the entry's field 'key' (its own, or its scopes'; see TASWLogRecord::ForEachField()), or null if it
+    // has none. Valid until the hook changes the fields or returns.
+    [[nodiscard]] const TASWLogValue* FindField(std::string_view key) const noexcept;
+
+    // Calls visit(field) for each of the entry's fields, each key once (see TASWLogRecord::ForEachField()). The hook
+    // may change the fields from inside visit; the visit then goes on over the fields as they were when it started.
+    template<typename TVisit>
+    void ForEachField(TVisit&& visit) const
+    {
+        m_Record.ForEachField(visit);
+    }
+
+    // The entry as it will be written, with the hook's changes so far
+    [[nodiscard]] const TASWLogRecord& GetRecord() const noexcept;
+
+    // Removes the field 'key' (its own, or a scope's, for this entry only), if it has one. Throws std::bad_alloc if
+    // the fields can't be copied; they are then unchanged.
+    void RemoveField(std::string_view key);
+
+    // Sets the field 'key' to 'value' (copied, text included): replaces its value where it is, or adds it after the
+    // others. Throws like RemoveField().
+    void SetField(std::string_view key, const TASWLogValue& value);
+
+    // Replaces the entry's message, e.g. with a redacted copy
+    void SetMessage(std::string message) noexcept;
+};
+
+//---------------------------------------------------------------------------
+
 } // namespace ASWLog
 
 #endif // #ifndef ASWLog_TypesH
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ae66a4f..c69d801 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -122,6 +122,20 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   including your own (a JSON line has no line breaks), and to the
   fixed-layout crash and backtrace lines; `LogRaw()` entries written as is
   stay as they are.
+- A hook to drop or change entries before they are written:
+  `OnBeforeWrite`, e.g. to redact secrets or personal data, or to drop
+  noisy entries by content, category or field. It gets a `TASWPendingEntry`
+  for each entry that passes the level checks (`LogRaw()` entries
+  included): return false to drop it, or change it with `SetMessage()`,
+  `SetField()` and `RemoveField()` (read with `GetRecord()`, `FindField()`
+  and `ForEachField()`); level, time and category stay as they are. It runs
+  on the logging thread before the logger's lock or queue, so it may log
+  elsewhere; an entry logged from inside it is written as is. Entries the
+  backtrace keeps are kept as changed, `OnLogEntry` sees the changed entry,
+  and a hook that throws drops the entry and reports it (`OnError`). The
+  logger's own lines (startup, shutdown, backtrace markers, crash lines)
+  don't pass through it. A multi-log runs its hook once per entry and
+  passes its config on without it.
 
 ### Changed
 
diff --git a/README.md b/README.md
index 52d752c..b406287 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
 - Multi-line messages (e.g. an HTTP body) written as they are, or, with `TASWLogConfig::Line.Multiline`, each line after
   the first marked with `    | ` (`MultilineMode::Indent`) or the line breaks escaped as `\r` and `\n`
   (`MultilineMode::Escape`), so that every entry is recognizable as one.
+- A hook to drop or change entries before they are written (`TASWLogConfig::OnBeforeWrite`), e.g. to redact secrets
+  or drop noisy entries by content, category or field.
 - Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
   entry on the thread carries, e.g. `ASWLog::TASWLogScope scope{{"requestId", id}};` (`ASWLog_Fields.h`).
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
diff --git a/tests/tests/Test_ASWLog_Base.cpp b/tests/tests/Test_ASWLog_Base.cpp
index 6a84ead..a025cb1 100644
--- a/tests/tests/Test_ASWLog_Base.cpp
+++ b/tests/tests/Test_ASWLog_Base.cpp
@@ -306,6 +306,11 @@ TTest_ASWLog_Base::TTest_ASWLog_Base()
     RegisterTest(&TTest_ASWLog_Base::Test_LogFormatMethods_SkipFormattingWhenNotWritten, "LogFormatMethods_SkipFormattingWhenNotWritten");
     RegisterTest(&TTest_ASWLog_Base::Test_LogLevelConvenienceMethods, "LogLevelConvenienceMethods");
     RegisterTest(&TTest_ASWLog_Base::Test_LogMethods_PassRecordsToWrite, "LogMethods_PassRecordsToWrite");
+    RegisterTest(&TTest_ASWLog_Base::Test_OnBeforeWrite_DropsOrChangesEntries, "OnBeforeWrite_DropsOrChangesEntries");
+    RegisterTest(&TTest_ASWLog_Base::Test_OnBeforeWrite_EntriesLoggedInsideTheHookAreWrittenAsIs, "OnBeforeWrite_EntriesLoggedInsideTheHookAreWrittenAsIs");
+    RegisterTest(&TTest_ASWLog_Base::Test_OnBeforeWrite_ReconfigureSetsAndClearsTheHook, "OnBeforeWrite_ReconfigureSetsAndClearsTheHook");
+    RegisterTest(&TTest_ASWLog_Base::Test_OnBeforeWrite_SeesEntriesThatPassTheLevelChecks, "OnBeforeWrite_SeesEntriesThatPassTheLevelChecks");
+    RegisterTest(&TTest_ASWLog_Base::Test_OnBeforeWrite_ThrowingHookDropsTheEntryAndReports, "OnBeforeWrite_ThrowingHookDropsTheEntryAndReports");
     RegisterTest(&TTest_ASWLog_Base::Test_ReportError_FailureInHandlerIsNotReportedAgain, "ReportError_FailureInHandlerIsNotReportedAgain");
     RegisterTest(&TTest_ASWLog_Base::Test_ReportError_ThrottlesEachKindSeparately, "ReportError_ThrottlesEachKindSeparately");
     RegisterTest(&TTest_ASWLog_Base::Test_ReportError_ThrowingHandlerDoesNotEscape, "ReportError_ThrowingHandlerDoesNotEscape");
@@ -882,6 +887,174 @@ void TTest_ASWLog_Base::Test_LogMethods_PassRecordsToWrite()
     CheckEquals(9, logger.WriteRecordCount, "Each call should pass exactly one record to WriteRecord()");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Base::Test_OnBeforeWrite_DropsOrChangesEntries()
+{
+    // Arrange: a hook that drops noisy entries and redacts secrets, raw ones included
+    TTestLogger logger;
+    std::vector<std::string> seen;
+    ASWLog::TASWLogConfig config;
+    config.OnBeforeWrite = [&seen](ASWLog::TASWPendingEntry& entry) {
+            const auto& record = entry.GetRecord();
+            seen.push_back(std::format("{}|{}{}", ASWLog::Level_ToString(record.LogLevel), record.Message, record.Raw ? "|raw" : ""));
+            if (record.Message.starts_with("noisy"))
+                return false;
+
+            const auto secretAt = record.Message.find("secret");
+            if (secretAt != std::string_view::npos)
+            {
+                std::string redacted(record.Message);
+                entry.SetMessage(redacted.replace(secretAt, 6, "***"));
+            }
+
+            return true;
+        };
+    logger.Initialize(config);
+
+    // Act
+    logger.LogInfo("first");
+    logger.LogWarn("noisy entry");
+    logger.LogError("password=secret");
+    logger.LogRaw(ASWLog::Level::Info, "raw secret body\n");
+    logger.LogForceRaw(ASWLog::Level::Debug, "noisy raw");
+
+    // Assert
+    const std::vector<std::string> expectedSeen{ "INFO|first", "WARN|noisy entry", "ERROR|password=secret",
+                                                 "INFO|raw secret body\n|raw", "DEBUG|noisy raw|raw" };
+    const std::vector<std::string> expectedWritten{ "INFO|first", "ERROR|password=***", "INFO|raw *** body\n" };
+    CheckTrue(seen == expectedSeen, "The hook should see every entry, raw ones flagged");
+    CheckTrue(logger.Written == expectedWritten, "Dropped entries should be left out and changed ones written as changed");
+    CheckTrue(logger.LastRecord.Raw, "A changed raw entry should stay raw");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Base::Test_OnBeforeWrite_EntriesLoggedInsideTheHookAreWrittenAsIs()
+{
+    // Arrange: a hook that logs to its own logger and to another one that has a hook
+    TTestLogger logger;
+    TTestLogger other;
+    int hookCount = 0;
+    int otherHookCount = 0;
+    ASWLog::TASWLogConfig config;
+    config.OnBeforeWrite = [&](ASWLog::TASWPendingEntry& entry) {
+            ++hookCount;
+            if (entry.GetRecord().Message == "outer")
+            {
+                logger.LogInfo("inner");
+                other.LogInfo("to_other");
+            }
+
+            entry.SetMessage(std::format("changed_{}", entry.GetRecord().Message));
+            return true;
+        };
+    ASWLog::TASWLogConfig otherConfig;
+    otherConfig.OnBeforeWrite = [&otherHookCount](ASWLog::TASWPendingEntry& entry) {
+            ++otherHookCount;
+            entry.SetMessage(std::format("other_{}", entry.GetRecord().Message));
+            return true;
+        };
+    logger.Initialize(config);
+    other.Initialize(otherConfig);
+
+    // Act
+    logger.LogInfo("outer");
+    logger.LogInfo("next");
+    other.LogInfo("after");
+
+    // Assert
+    CheckTrue(logger.Written == std::vector<std::string>{ "INFO|inner", "INFO|changed_outer", "INFO|changed_next" },
+        "An entry logged inside the hook should be written as is, and the hook should run again afterwards");
+    CheckTrue(other.Written == std::vector<std::string>{ "INFO|to_other", "INFO|other_after" },
+        "Another logger's hook should be skipped inside a hook, and run again afterwards");
+    CheckEquals(2, hookCount, "The hook should run once for each of its logger's entries logged outside it");
+    CheckEquals(1, otherHookCount, "The other hook should run only for the entry logged outside a hook");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Base::Test_OnBeforeWrite_ReconfigureSetsAndClearsTheHook()
+{
+    // Arrange
+    TTestLogger logger;
+    ASWLog::TASWLogConfig config;
+    logger.Initialize(config);
+    auto dropAllConfig = config;
+    dropAllConfig.OnBeforeWrite = [](ASWLog::TASWPendingEntry& /*entry*/) {
+            return false;
+        };
+
+    // Act
+    logger.LogInfo("before");
+    const bool setHook = logger.Reconfigure(dropAllConfig);
+    logger.LogInfo("dropped");
+    const bool clearedHook = logger.Reconfigure(config);
+    logger.LogInfo("after");
+
+    // Assert
+    CheckTrue(setHook && clearedHook, "Reconfigure should succeed");
+    CheckTrue(logger.Written == std::vector<std::string>{ "INFO|before", "INFO|after" },
+        "The hook should apply from the Reconfigure() that sets it until the one that clears it");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Base::Test_OnBeforeWrite_SeesEntriesThatPassTheLevelChecks()
+{
+    // Arrange: a backtrace of Debug entries; the hook marks what it sees and drops one Debug entry
+    TTestLogger logger;
+    std::vector<std::string> seen;
+    auto config = MakeBacktraceConfig(5);
+    config.OnBeforeWrite = [&seen](ASWLog::TASWPendingEntry& entry) {
+            seen.emplace_back(entry.GetRecord().Message);
+            if (entry.GetRecord().Message == "dropped_debug")
+                return false;
+
+            entry.SetMessage(std::format("h:{}", entry.GetRecord().Message));
+            return true;
+        };
+    logger.Initialize(config);
+
+    // Act
+    logger.LogTrace("trace_1"); // Below the backtrace's level: filtered
+    logger.LogDebug("debug_1"); // Kept, as changed
+    logger.LogDebug("dropped_debug"); // Not kept
+    logger.LogInfo("info_1");
+    logger.LogError("error_1"); // Writes the backtrace, whose entries aren't hooked again
+    logger.SetEnabled(false);
+    logger.LogError("disabled");
+
+    // Assert
+    const std::vector<std::string> expectedWritten{ "INFO|h:info_1", "INFO|Backtrace: the last 1 entry below the minimum level|forced",
+                                                    "DEBUG|h:debug_1|forced", "INFO|Backtrace end|forced", "ERROR|h:error_1" };
+    CheckTrue(seen == std::vector<std::string>{ "debug_1", "dropped_debug", "info_1", "error_1" },
+        "The hook should see each entry that passes the level checks once, but not the backtrace's markers");
+    CheckTrue(logger.Written == expectedWritten, "The backtrace should keep the entries as the hook changed them");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Base::Test_OnBeforeWrite_ThrowingHookDropsTheEntryAndReports()
+{
+    // Arrange
+    TTestLogger logger;
+    std::vector<ASWLog::TASWLogError> reports;
+    ASWLog::TASWLogConfig config;
+    config.ErrorReportInterval = std::chrono::milliseconds(0);
+    config.OnError = [&reports](const ASWLog::TASWLogError& error) {
+            reports.push_back(error);
+        };
+    config.OnBeforeWrite = [](ASWLog::TASWPendingEntry& entry) {
+            if (entry.GetRecord().Message == "bad")
+                throw std::runtime_error("boom");
+
+            return true;
+        };
+    logger.Initialize(config);
+
+    // Act
+    logger.LogError("bad");
+    logger.LogError("good");
+
+    // Assert
+    CheckTrue(logger.Written == std::vector<std::string>{ "ERROR|good" }, "Only the entry the hook didn't throw for should be written");
+    AssertEquals(std::size_t(1), reports.size(), "The dropped entry should be reported");
+    CheckEquals(ASWLog::ErrorKind::Exception, reports[0].Kind, "A throwing hook should be reported as an Exception");
+    CheckEquals(std::string("Dropped an entry, OnBeforeWrite threw: boom"), reports[0].Message,
+        "The report should name the hook and give the exception's what()");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Base::Test_ReportError_FailureInHandlerIsNotReportedAgain()
 {
     // Arrange: a handler that fails the same way again, like one that logs to the logger whose output failed. Without
diff --git a/tests/tests/Test_ASWLog_Base.h b/tests/tests/Test_ASWLog_Base.h
index 5d6c1b5..fc26b60 100644
--- a/tests/tests/Test_ASWLog_Base.h
+++ b/tests/tests/Test_ASWLog_Base.h
@@ -53,6 +53,11 @@ class TTest_ASWLog_Base : public TTestGroupBase
     void Test_LogFormatMethods_SkipFormattingWhenNotWritten();
     void Test_LogLevelConvenienceMethods();
     void Test_LogMethods_PassRecordsToWrite();
+    void Test_OnBeforeWrite_DropsOrChangesEntries();
+    void Test_OnBeforeWrite_EntriesLoggedInsideTheHookAreWrittenAsIs();
+    void Test_OnBeforeWrite_ReconfigureSetsAndClearsTheHook();
+    void Test_OnBeforeWrite_SeesEntriesThatPassTheLevelChecks();
+    void Test_OnBeforeWrite_ThrowingHookDropsTheEntryAndReports();
     void Test_ReportError_FailureInHandlerIsNotReportedAgain();
     void Test_ReportError_ThrottlesEachKindSeparately();
     void Test_ReportError_ThrowingHandlerDoesNotEscape();
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 82b998c..d669d59 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -80,6 +80,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     CheckNull(config.OnLogEntry, "OnLogEntry should default to unset");
     CheckEquals(ASWLog::Level::Error, config.OnLogEntryMinimumLevel, "OnLogEntryMinimumLevel should default to Error");
     CheckNull(config.OnError, "OnError should default to unset (reports go to stderr)");
+    CheckNull(config.OnBeforeWrite, "OnBeforeWrite should default to unset");
     CheckFalse(config.Async.Enabled, "Async.Enabled should default to false");
     CheckEquals(8192, config.Async.QueueCapacity, "Async.QueueCapacity should default to 8192");
     CheckEquals(ASWLog::AsyncOverflowPolicy::Block, config.Async.OverflowPolicy, "Async.OverflowPolicy should default to Block");
diff --git a/tests/tests/Test_ASWLog_MultiLog.cpp b/tests/tests/Test_ASWLog_MultiLog.cpp
index 1aa70c0..16523a0 100644
--- a/tests/tests/Test_ASWLog_MultiLog.cpp
+++ b/tests/tests/Test_ASWLog_MultiLog.cpp
@@ -105,9 +105,13 @@ class TRecordingLogger final : public ASWLog::TASWLogBase
     std::vector<ASWLog::TASWLogRecord> Records; // Every field but Message
     bool FlushResult = true; // Returned by Flush()
     bool ReconfigureResult = true; // Returned by Reconfigure()
+    bool WasInitialized = false; // Initialize() was called
+    bool InitializeHadBeforeWrite = false; // The config passed to Initialize() had an OnBeforeWrite hook
 
-    bool Initialize(const ASWLog::TASWLogConfig& /*config*/) noexcept override
+    bool Initialize(const ASWLog::TASWLogConfig& config) noexcept override
     {
+        WasInitialized = true;
+        InitializeHadBeforeWrite = config.OnBeforeWrite != nullptr;
         return true;
     }
 
@@ -285,6 +289,7 @@ TTest_ASWLog_MultiLog::TTest_ASWLog_MultiLog()
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Log_ThrowingSinkDoesNotStopOtherSinks, "Log_ThrowingSinkDoesNotStopOtherSinks");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_LogFmt_FormatsOnceForAllSinks, "LogFmt_FormatsOnceForAllSinks");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_LogForce_BypassesCompositeGate, "LogForce_BypassesCompositeGate");
+    RegisterTest(&TTest_ASWLog_MultiLog::Test_OnBeforeWrite_RunsOnceBeforeTheFanOut, "OnBeforeWrite_RunsOnceBeforeTheFanOut");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Reconfigure_PassesConfigToEverySink, "Reconfigure_PassesConfigToEverySink");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_RemoveAllLoggers_ClearsRegistrationAndReturnsCount, "RemoveAllLoggers_ClearsRegistrationAndReturnsCount");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_RemoveLogger_StopsReceivingEntries, "RemoveLogger_StopsReceivingEntries");
@@ -848,6 +853,50 @@ void TTest_ASWLog_MultiLog::Test_LogForce_BypassesCompositeGate()
     CheckContains(ReadFileText(fileA), "forced_past_composite_gate", "LogForce should bypass the composite's own MinimumLevel gate");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_MultiLog::Test_OnBeforeWrite_RunsOnceBeforeTheFanOut()
+{
+    // Arrange: the second sink has a hook of its own, set directly
+    TRecordingLogger first;
+    TRecordingLogger second;
+    ASWLog::TASWLogConfig secondConfig;
+    secondConfig.OnBeforeWrite = [](ASWLog::TASWPendingEntry& entry) {
+            entry.SetMessage(std::format("{}+second", entry.GetRecord().Message));
+            return true;
+        };
+    second.Reconfigure(secondConfig);
+
+    ASWLog::TASWMultiLog multiLog;
+    multiLog.AddLogger(first);
+    multiLog.AddLogger(second);
+    int hookCount = 0;
+    ASWLog::TASWLogConfig config;
+    config.OnBeforeWrite = [&hookCount](ASWLog::TASWPendingEntry& entry) {
+            ++hookCount;
+            if (entry.GetRecord().Message == "dropped")
+                return false;
+
+            entry.SetMessage(std::format("multi:{}", entry.GetRecord().Message));
+            return true;
+        };
+    CheckTrue(multiLog.Initialize(config), "Initialize should succeed");
+
+    // Act
+    multiLog.LogInfo("entry");
+    multiLog.LogInfo("dropped");
+    const bool reconfigured = multiLog.Reconfigure(config);
+    multiLog.LogInfo("after");
+
+    // Assert
+    CheckEquals(3, hookCount, "The multi-log's hook should run once per entry, not once per sink");
+    CheckTrue(first.WasInitialized && !first.InitializeHadBeforeWrite, "The config passed to a sink's Initialize() should have no hook");
+    CheckTrue(reconfigured, "Reconfigure should succeed");
+    CheckNull(first.GetConfig()->OnBeforeWrite, "The config passed to a sink's Reconfigure() should have no hook");
+    CheckTrue(first.Calls == std::vector<std::string>{ "Log:multi:entry", "Reconfigure", "Log:multi:after" },
+        "The sinks should get the entries as the multi-log's hook changed them, not the dropped one");
+    CheckTrue(second.Calls == std::vector<std::string>{ "Reconfigure", "Log:multi:entry+second", "Reconfigure", "Log:multi:after" },
+        "A sink's own hook should run after the multi-log's, until the multi-log's Reconfigure() replaces its config");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_MultiLog::Test_Reconfigure_PassesConfigToEverySink()
 {
     // Arrange: the first sink's Reconfigure() fails
diff --git a/tests/tests/Test_ASWLog_MultiLog.h b/tests/tests/Test_ASWLog_MultiLog.h
index 929bdc4..1330f30 100644
--- a/tests/tests/Test_ASWLog_MultiLog.h
+++ b/tests/tests/Test_ASWLog_MultiLog.h
@@ -56,6 +56,7 @@ class TTest_ASWLog_MultiLog : public TTestGroupBase
     void Test_Log_ThrowingSinkDoesNotStopOtherSinks();
     void Test_LogFmt_FormatsOnceForAllSinks();
     void Test_LogForce_BypassesCompositeGate();
+    void Test_OnBeforeWrite_RunsOnceBeforeTheFanOut();
     void Test_Reconfigure_PassesConfigToEverySink();
     void Test_RemoveAllLoggers_ClearsRegistrationAndReturnsCount();
     void Test_RemoveLogger_StopsReceivingEntries();
diff --git a/tests/tests/Test_ASWLog_TextLogBase.cpp b/tests/tests/Test_ASWLog_TextLogBase.cpp
index 479e09f..e160266 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.cpp
+++ b/tests/tests/Test_ASWLog_TextLogBase.cpp
@@ -430,6 +430,9 @@ TTest_ASWLog_TextLogBase::TTest_ASWLog_TextLogBase()
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Multiline_EscapeKeepsEachEntryOnOneLine, "Multiline_EscapeKeepsEachEntryOnOneLine");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Multiline_LogRawStaysAsIs, "Multiline_LogRawStaysAsIs");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Multiline_PreserveWritesLineBreaksAsTheyAre, "Multiline_PreserveWritesLineBreaksAsTheyAre");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_OnBeforeWrite_RunsOnEveryLoggingThread, "OnBeforeWrite_RunsOnEveryLoggingThread");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_OnBeforeWrite_RunsOutsideTheLockBeforeQueuing, "OnBeforeWrite_RunsOutsideTheLockBeforeQueuing");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_OnBeforeWrite_SkipsTheLoggersOwnLines, "OnBeforeWrite_SkipsTheLoggersOwnLines");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_OnLogEntry_CallbackCanReconfigureTheLogger, "OnLogEntry_CallbackCanReconfigureTheLogger");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Reconfigure_AppliesNewConfigButKeepsLevel, "Reconfigure_AppliesNewConfigButKeepsLevel");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Reconfigure_IsSafeWhileOtherThreadsLog, "Reconfigure_IsSafeWhileOtherThreadsLog");
@@ -1437,6 +1440,162 @@ void TTest_ASWLog_TextLogBase::Test_Multiline_PreserveWritesLineBreaksAsTheyAre(
     CheckTrue(output.Lines == std::vector<std::string>{ "[INFO]: a\r\nb\nc\rd\n\r\n" }, "The message should be written as it is");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_OnBeforeWrite_RunsOnEveryLoggingThread()
+{
+    // Arrange: a synchronous and an asynchronous logger whose hook changes the message and a field of each entry, and
+    // drops every fourth, while several threads log (for ThreadSanitizer)
+    constexpr int ThreadCount = 4;
+    constexpr int EntryCount = 200;
+    std::atomic<int> hookCount{ 0 };
+    const auto hook = [&hookCount](ASWLog::TASWPendingEntry& entry) {
+            hookCount.fetch_add(1);
+            const auto* index = entry.FindField("index");
+            if (index != nullptr && index->GetInt() % 4 == 3)
+                return false;
+
+            entry.SetMessage(std::format("hooked {}", entry.GetRecord().Message));
+            entry.SetField("index", "x");
+            return true;
+        };
+
+    TMemoryOutput output;
+    TMemoryOutput asyncOutput;
+    auto config = MakeQuietConfig();
+    config.OnBeforeWrite = hook;
+    auto asyncConfig = MakeAsyncConfig();
+    asyncConfig.OnBeforeWrite = hook;
+    TMemoryTextLog log(output);
+    TMemoryTextLog asyncLog(asyncOutput);
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+    CheckTrue(asyncLog.Initialize(asyncConfig), "Initialize should succeed (async)");
+
+    // Act
+    std::vector<std::thread> threads;
+    for (int threadIndex = 0; threadIndex < ThreadCount; ++threadIndex)
+    {
+        threads.emplace_back([&log, &asyncLog] {
+                for (int index = 0; index < EntryCount; ++index)
+                {
+                    log.LogInfo("entry", { { "index", index } });
+                    asyncLog.LogInfo("entry", { { "index", index } });
+                }
+            });
+    }
+
+    for (auto& thread : threads)
+        thread.join();
+
+    asyncLog.Flush(); // Waits for the queued entries
+
+    // Assert
+    constexpr std::size_t KeptCount = ThreadCount * EntryCount * 3 / 4;
+    const std::vector<std::string> expected(KeptCount, "[INFO][index=\"x\"]: hooked entry\n");
+    CheckEquals(2 * ThreadCount * EntryCount, hookCount.load(), "The hook should run once for each entry");
+    CheckTrue(output.Lines == expected, "Every kept entry should be written as the hook changed it");
+    CheckTrue(asyncOutput.Lines == expected, "Every kept queued entry should be written as the hook changed it");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_OnBeforeWrite_RunsOutsideTheLockBeforeQueuing()
+{
+    // Arrange: a hook that redacts a token in the message and the user field, for a synchronous and an asynchronous
+    // logger, both with OnLogEntry
+    TMemoryOutput output;
+    TMemoryOutput asyncOutput;
+    TMemoryTextLog log(output);
+    TMemoryTextLog asyncLog(asyncOutput);
+    bool wasMutexFree = false;
+    std::thread::id hookThreadId;
+    std::string seenLine;
+    std::string seenMessage;
+    std::mutex asyncSeenMutex;
+    std::string asyncSeenLine;
+    std::atomic<bool> isAsyncCalled{ false };
+
+    const auto redact = [](ASWLog::TASWPendingEntry& entry) {
+            if (entry.GetRecord().Message.starts_with("token="))
+                entry.SetMessage("token=***");
+
+            if (entry.FindField("user") != nullptr)
+                entry.SetField("user", "***");
+        };
+
+    auto config = MakeQuietConfig();
+    config.OnLogEntryMinimumLevel = ASWLog::Level::Info;
+    config.OnBeforeWrite = [&log, &wasMutexFree, &redact](ASWLog::TASWPendingEntry& entry) {
+            wasMutexFree = log.IsMutexFree();
+            redact(entry);
+            return true;
+        };
+    config.OnLogEntry = [&seenLine, &seenMessage](const ASWLog::TASWLogRecord& record, std::string_view line) {
+            seenMessage = record.Message;
+            seenLine = line;
+        };
+
+    auto asyncConfig = MakeAsyncConfig();
+    asyncConfig.OnLogEntryMinimumLevel = ASWLog::Level::Info;
+    asyncConfig.OnBeforeWrite = [&hookThreadId, &redact](ASWLog::TASWPendingEntry& entry) {
+            hookThreadId = std::this_thread::get_id();
+            redact(entry);
+            return true;
+        };
+    asyncConfig.OnLogEntry = [&](const ASWLog::TASWLogRecord& /*record*/, std::string_view line) {
+            {
+                std::lock_guard<std::mutex> lock(asyncSeenMutex);
+                asyncSeenLine = line;
+            }
+
+            isAsyncCalled.store(true);
+        };
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+    CheckTrue(asyncLog.Initialize(asyncConfig), "Initialize should succeed (async)");
+
+    // Act
+    log.LogInfo("token=abc", { { "user", "amy" } });
+    asyncLog.LogInfo("token=abc", { { "user", "amy" } });
+    const bool wasAsyncCalled = WaitUntil([&isAsyncCalled] {
+            return isAsyncCalled.load();
+        });
+
+    // Assert
+    const std::string expected = "[INFO][user=\"***\"]: token=***\n";
+    CheckTrue(wasMutexFree, "The hook should run before the logger takes its lock");
+    CheckTrue(output.Lines == std::vector<std::string>{ expected }, "The line should be written as the hook changed it");
+    CheckEquals(expected, seenLine, "OnLogEntry should get the changed line");
+    CheckEquals(std::string("token=***"), seenMessage, "OnLogEntry should get the changed record");
+    CheckTrue(hookThreadId == std::this_thread::get_id(), "An asynchronous logger should run the hook on the logging thread");
+    CheckTrue(asyncOutput.Lines == std::vector<std::string>{ expected }, "A queued line should be written as the hook changed it");
+    CheckTrue(wasAsyncCalled, "The asynchronous OnLogEntry should be called");
+    std::lock_guard<std::mutex> lock(asyncSeenMutex);
+    CheckEquals(expected, asyncSeenLine, "The asynchronous OnLogEntry should get the changed line");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_OnBeforeWrite_SkipsTheLoggersOwnLines()
+{
+    // Arrange: a hook that drops every entry, with a startup banner and the shutdown line
+    TMemoryOutput output;
+    int hookCount = 0;
+    auto config = MakeQuietConfig();
+    config.Startup.Banner = "banner";
+    config.Shutdown.WriteLine = true;
+    config.OnBeforeWrite = [&hookCount](ASWLog::TASWPendingEntry& /*entry*/) {
+            ++hookCount;
+            return false;
+        };
+
+    // Act
+    {
+        TMemoryTextLog log(output);
+        CheckTrue(log.Initialize(config), "Initialize should succeed");
+        log.LogError("dropped");
+    }
+
+    // Assert
+    CheckEquals(1, hookCount, "The hook should see only the application's entry");
+    AssertEquals(std::size_t(2), output.Lines.size(), "Only the banner and the shutdown line should be written");
+    CheckEquals(std::string("[INFO]: banner\n"), output.Lines[0], "The startup banner should be written");
+    CheckContains(output.Lines[1], "Logger shutdown", "The shutdown line should be written");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_TextLogBase::Test_OnLogEntry_CallbackCanReconfigureTheLogger()
 {
     // Arrange: a callback that replaces the config it belongs to, e.g. to turn itself off after the first error. The
diff --git a/tests/tests/Test_ASWLog_TextLogBase.h b/tests/tests/Test_ASWLog_TextLogBase.h
index 3655b9c..f3b5e9a 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.h
+++ b/tests/tests/Test_ASWLog_TextLogBase.h
@@ -67,6 +67,9 @@ class TTest_ASWLog_TextLogBase : public TTestGroupBase
     void Test_Multiline_EscapeKeepsEachEntryOnOneLine();
     void Test_Multiline_LogRawStaysAsIs();
     void Test_Multiline_PreserveWritesLineBreaksAsTheyAre();
+    void Test_OnBeforeWrite_RunsOnEveryLoggingThread();
+    void Test_OnBeforeWrite_RunsOutsideTheLockBeforeQueuing();
+    void Test_OnBeforeWrite_SkipsTheLoggersOwnLines();
     void Test_OnLogEntry_CallbackCanReconfigureTheLogger();
     void Test_Reconfigure_AppliesNewConfigButKeepsLevel();
     void Test_Reconfigure_IsSafeWhileOtherThreadsLog();
diff --git a/tests/tests/Test_ASWLog_Types.cpp b/tests/tests/Test_ASWLog_Types.cpp
index d85d25e..066f175 100644
--- a/tests/tests/Test_ASWLog_Types.cpp
+++ b/tests/tests/Test_ASWLog_Types.cpp
@@ -25,9 +25,13 @@ limitations under the License.
 #include "Test_ASWLog_Types.h"
 //---------------------------------------------------------------------------
 #include <cstddef>
+#include <format>
 #include <optional>
+#include <span>
 #include <string>
+#include <string_view>
 #include <system_error>
+#include <vector>
 //---------------------------------------------------------------------------
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
@@ -37,6 +41,25 @@ limitations under the License.
 namespace ASWUnitTests
 {
 
+namespace
+{
+
+// "key=value" for each of the entry's fields, in the order ForEachField() gives them (text values as they are)
+std::vector<std::string> DescribeFields(const ASWLog::TASWPendingEntry& entry)
+{
+    std::vector<std::string> fields;
+    entry.ForEachField([&fields](const ASWLog::TASWLogField& field) {
+                if (field.Value.GetKind() == ASWLog::ValueKind::Text)
+                    fields.push_back(std::format("{}={}", field.Key, field.Value.GetText()));
+                else
+                    fields.push_back(std::format("{}={}", field.Key, field.Value.GetInt()));
+            });
+
+    return fields;
+}
+
+} // namespace
+
 //---------------------------------------------------------------------------
 TTest_ASWLog_Types::TTest_ASWLog_Types()
     : inherited("ASWLog_Types_Tests")
@@ -55,6 +78,11 @@ TTest_ASWLog_Types::TTest_ASWLog_Types()
     RegisterTest(&TTest_ASWLog_Types::Test_LogError_ToString, "LogError_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_MultilineMode_FromString, "MultilineMode_FromString");
     RegisterTest(&TTest_ASWLog_Types::Test_MultilineMode_ToString, "MultilineMode_ToString");
+    RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_ChangingFieldsWhileVisitingIsSafe, "PendingEntry_ChangingFieldsWhileVisitingIsSafe");
+    RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_FindsFieldsOfTheEntryAndItsScopes, "PendingEntry_FindsFieldsOfTheEntryAndItsScopes");
+    RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_RemoveFieldRemovesItForThisEntry, "PendingEntry_RemoveFieldRemovesItForThisEntry");
+    RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_SetFieldReplacesOrAddsACopy, "PendingEntry_SetFieldReplacesOrAddsACopy");
+    RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_SetMessageOwnsTheText, "PendingEntry_SetMessageOwnsTheText");
     RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_FromString, "TimePrecision_FromString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_ToString, "TimePrecision_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimeZone_FromString, "TimeZone_FromString");
@@ -340,6 +368,141 @@ void TTest_ASWLog_Types::Test_MultilineMode_ToString()
     CheckEquals(std::string("ESCAPE"), std::string(ASWLog::MultilineMode_ToString(ASWLog::MultilineMode::Escape)), "Escape should stringify as ESCAPE");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_PendingEntry_ChangingFieldsWhileVisitingIsSafe()
+{
+    // Arrange: text fields from a scope, then (after the first change) the entry's own copies
+    ASWLog::TASWLogScope scope{ { "a", "1" }, { "b", "2" }, { "c", "3" } };
+    ASWLog::TASWLogRecord record;
+    record.Scope = ASWLog::TASWLogScope::GetCurrent();
+    ASWLog::TASWPendingEntry entry(record);
+    std::vector<std::string> firstVisit;
+    std::vector<std::string> secondVisit;
+
+    // Act: each change replaces the copies the visit is going over (a visit over freed copies is undefined behavior,
+    // which AddressSanitizer reports; without it the freed memory usually still holds the old fields)
+    entry.ForEachField([&](const ASWLog::TASWLogField& field) {
+            firstVisit.push_back(std::format("{}={}", field.Key, field.Value.GetText()));
+            entry.SetField(field.Key, "x");
+        });
+    entry.ForEachField([&](const ASWLog::TASWLogField& field) {
+            secondVisit.push_back(std::format("{}={}", field.Key, field.Value.GetText()));
+            entry.SetField(field.Key, std::string(field.Value.GetText()) + "y");
+        });
+
+    // Assert
+    CheckTrue(firstVisit == std::vector<std::string>{ "a=1", "b=2", "c=3" }, "The first visit should go over the fields as they were");
+    CheckTrue(secondVisit == std::vector<std::string>{ "a=x", "b=x", "c=x" }, "The second visit should go over the first visit's changes");
+    CheckTrue(DescribeFields(entry) == std::vector<std::string>{ "a=xy", "b=xy", "c=xy" }, "Every change should be kept");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_PendingEntry_FindsFieldsOfTheEntryAndItsScopes()
+{
+    // Arrange: a scope and the entry's own fields, one of which replaces the scope's
+    ASWLog::TASWLogScope scope{ { "requestId", "8f3a" }, { "user", "amy" } };
+    const ASWLog::TASWLogField own[] = { { "user", "bob" }, { "orderId", 17 } };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+    ASWLog::TASWLogRecord record;
+    record.Fields = &ownFields;
+    record.Scope = ASWLog::TASWLogScope::GetCurrent();
+    const ASWLog::TASWPendingEntry entry(record);
+
+    // Act
+    const auto* requestId = entry.FindField("requestId");
+    const auto* user = entry.FindField("user");
+    const auto* orderId = entry.FindField("orderId");
+    const auto* missing = entry.FindField("missing");
+
+    // Assert
+    AssertNotNull(requestId, "A scope's field should be found");
+    AssertNotNull(user, "A field the entry and its scope both have should be found");
+    AssertNotNull(orderId, "The entry's own field should be found");
+    CheckEquals(std::string("8f3a"), std::string(requestId->GetText()), "The scope's value should be returned");
+    CheckEquals(std::string("bob"), std::string(user->GetText()), "The entry's own value should beat the scope's");
+    CheckEquals(17, orderId->GetInt(), "The entry's own value should be returned");
+    CheckNull(missing, "A field the entry doesn't have should give null");
+    CheckTrue(DescribeFields(entry) == std::vector<std::string>{ "requestId=8f3a", "user=bob", "orderId=17" },
+        "ForEachField() should give each key once, as written");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_PendingEntry_RemoveFieldRemovesItForThisEntry()
+{
+    // Arrange
+    ASWLog::TASWLogScope scope{ { "user", "amy" }, { "requestId", "8f3a" } };
+    const ASWLog::TASWLogField own[] = { { "user", "bob" }, { "orderId", 17 } };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+    ASWLog::TASWLogRecord record;
+    record.Fields = &ownFields;
+    record.Scope = ASWLog::TASWLogScope::GetCurrent();
+    ASWLog::TASWPendingEntry entry(record);
+
+    // Act
+    entry.RemoveField("missing");
+    const auto* fieldsAfterMissing = entry.GetRecord().Fields;
+    entry.RemoveField("user");
+
+    // Assert
+    CheckSame(record.Fields, fieldsAfterMissing, "Removing a field the entry doesn't have should change nothing");
+    CheckTrue(DescribeFields(entry) == std::vector<std::string>{ "requestId=8f3a", "orderId=17" },
+        "The field should be gone, its own value and the scope's");
+    CheckNull(entry.GetRecord().Scope, "The entry's fields should no longer depend on the scope");
+    CheckEquals(std::string("amy"), std::string(ASWLog::TASWLogScope::GetCurrent()->GetFields()[0].Value.GetText()),
+        "The scope itself should keep the field");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_PendingEntry_SetFieldReplacesOrAddsACopy()
+{
+    // Arrange
+    ASWLog::TASWLogScope scope{ { "requestId", "8f3a" }, { "user", "amy" } };
+    const ASWLog::TASWLogField own[] = { { "orderId", 17 } };
+    const std::span<const ASWLog::TASWLogField> ownFields(own);
+    ASWLog::TASWLogRecord record;
+    record.Fields = &ownFields;
+    record.Scope = ASWLog::TASWLogScope::GetCurrent();
+    ASWLog::TASWPendingEntry entry(record);
+
+    // Act: the key and value of the added field are temporaries
+    entry.SetField("user", "***");
+    {
+        std::string key = "token";
+        std::string value = "secret_value";
+        entry.SetField(key, value);
+        key.assign(key.size(), '?');
+        value.assign(value.size(), '?');
+    }
+    entry.SetField("orderId", 18);
+
+    // Assert
+    CheckTrue(DescribeFields(entry) == std::vector<std::string>{ "requestId=8f3a", "user=***", "orderId=18", "token=secret_value" },
+        "A field should be replaced where it is, and a new one added after the others, as a copy");
+    CheckSame(record.Fields, &ownFields, "The record the entry was made from should be unchanged");
+    CheckEquals(17, ownFields[0].Value.GetInt(), "The caller's fields should be unchanged");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_PendingEntry_SetMessageOwnsTheText()
+{
+    // Arrange
+    ASWLog::TASWLogRecord record;
+    record.LogLevel = ASWLog::Level::Warn;
+    record.Raw = true;
+    record.Message = "password=secret";
+    record.Category = "Net";
+    ASWLog::TASWPendingEntry entry(record);
+
+    // Act: the new message is a temporary
+    {
+        std::string redacted = "password=***";
+        entry.SetMessage(redacted);
+        redacted.assign(redacted.size(), '?');
+    }
+
+    // Assert
+    CheckEquals(std::string("password=***"), std::string(entry.GetRecord().Message), "The entry should own its new message");
+    CheckEquals(std::string("password=secret"), std::string(record.Message), "The original record should be unchanged");
+    CheckEquals(ASWLog::Level::Warn, entry.GetRecord().LogLevel, "The level should be kept");
+    CheckTrue(entry.GetRecord().Raw, "The flags should be kept");
+    CheckEquals(std::string("Net"), std::string(entry.GetRecord().Category), "The category should be kept");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_TimePrecision_FromString()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_Types.h b/tests/tests/Test_ASWLog_Types.h
index 61f0486..efbe2fd 100644
--- a/tests/tests/Test_ASWLog_Types.h
+++ b/tests/tests/Test_ASWLog_Types.h
@@ -49,6 +49,11 @@ class TTest_ASWLog_Types : public TTestGroupBase
     void Test_LineEnding_ToString();
     void Test_MultilineMode_FromString();
     void Test_MultilineMode_ToString();
+    void Test_PendingEntry_ChangingFieldsWhileVisitingIsSafe();
+    void Test_PendingEntry_FindsFieldsOfTheEntryAndItsScopes();
+    void Test_PendingEntry_RemoveFieldRemovesItForThisEntry();
+    void Test_PendingEntry_SetFieldReplacesOrAddsACopy();
+    void Test_PendingEntry_SetMessageOwnsTheText();
     void Test_LogError_ToString();
     void Test_TimePrecision_FromString();
     void Test_TimePrecision_ToString();

From e779bf352584a28ef1900ccce28fa6e9f754616b Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 08:27:17 -0700
Subject: [PATCH 12/38] Bump version to 0.85.0-dev.2

---
 ASWLog/ASWLog_Version.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ASWLog/ASWLog_Version.h b/ASWLog/ASWLog_Version.h
index 663dddc..690799f 100644
--- a/ASWLog/ASWLog_Version.h
+++ b/ASWLog/ASWLog_Version.h
@@ -36,8 +36,8 @@ limitations under the License.
 #define ASWLOG_VERSION_MAJOR 0
 #define ASWLOG_VERSION_MINOR 85
 #define ASWLOG_VERSION_PATCH 0
-#define ASWLOG_VERSION_PRERELEASE "dev.1"
-#define ASWLOG_VERSION_STRING "0.85.0-dev.1"
+#define ASWLOG_VERSION_PRERELEASE "dev.2"
+#define ASWLOG_VERSION_STRING "0.85.0-dev.2"
 
 namespace ASWLog
 {

From 2f88ff1174ed7a1015ac474bebd115040e3c14a7 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 08:30:32 -0700
Subject: [PATCH 13/38] Add TASWNullLog

---
 ASWLog/ASWLog_NullLog.cpp                     | 190 +++++++++++++
 ASWLog/ASWLog_NullLog.h                       | 120 ++++++++
 CHANGELOG.md                                  |   7 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 README.md                                     |   2 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_NullLog.cpp           | 265 ++++++++++++++++++
 tests/tests/Test_ASWLog_NullLog.h             |  61 ++++
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 12 files changed, 672 insertions(+)
 create mode 100644 ASWLog/ASWLog_NullLog.cpp
 create mode 100644 ASWLog/ASWLog_NullLog.h
 create mode 100644 tests/tests/Test_ASWLog_NullLog.cpp
 create mode 100644 tests/tests/Test_ASWLog_NullLog.h

diff --git a/ASWLog/ASWLog_NullLog.cpp b/ASWLog/ASWLog_NullLog.cpp
new file mode 100644
index 0000000..506f7af
--- /dev/null
+++ b/ASWLog/ASWLog_NullLog.cpp
@@ -0,0 +1,190 @@
+/* **************************************************************************
+ASWLog_NullLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_NullLog.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <format>
+#include <utility>
+//---------------------------------------------------------------------------
+#include "ASWLog_Version.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWNullLog
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWNullLog::TASWNullLog()
+    : m_Config(std::make_shared<const TASWLogConfig>())
+{
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::Close() noexcept
+{
+    return true;
+}
+
+//---------------------------------------------------------------------------
+void TASWNullLog::DumpBacktrace() noexcept
+{
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::Flush() noexcept
+{
+    return true;
+}
+
+//---------------------------------------------------------------------------
+std::shared_ptr<const TASWLogConfig> TASWNullLog::GetConfig() const noexcept
+{
+    std::lock_guard<std::mutex> lock(m_ConfigMutex);
+    return m_Config;
+}
+
+//---------------------------------------------------------------------------
+std::string TASWNullLog::GetFullVersionStr() const
+{
+    return std::format("TASWNullLog - Base version {}", GetVersionStr());
+}
+
+//---------------------------------------------------------------------------
+TASWNullLog& TASWNullLog::GetInstance()
+{
+    // Never deleted, so the instance stays usable through static destruction (it has nothing to finalize)
+    static TASWNullLog* const instance = new TASWNullLog();
+    return *instance;
+}
+
+//---------------------------------------------------------------------------
+Level TASWNullLog::GetMinimumLevel() const noexcept
+{
+    return m_MinimumLevel.load(std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+std::string_view TASWNullLog::GetVersionStr() const noexcept
+{
+    return Version; // See ASWLog_Version.h
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::Initialize(const TASWLogConfig& config) noexcept
+{
+    if (!StoreConfig(config))
+        return false;
+
+    SetMinimumLevel(config.InitialMinimumLevel);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::IsEnabled() const noexcept
+{
+    return false;
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::IsOpen() const noexcept
+{
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::Open() noexcept
+{
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::Reconfigure(const TASWLogConfig& config) noexcept
+{
+    return StoreConfig(config);
+}
+
+//---------------------------------------------------------------------------
+void TASWNullLog::SetEnabled(bool /*enabled*/) noexcept
+{
+}
+
+//---------------------------------------------------------------------------
+void TASWNullLog::SetMinimumLevel(Level level) noexcept
+{
+    m_MinimumLevel.store(level, std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::ShouldLog(Level /*level*/) const noexcept
+{
+    return false;
+}
+
+//---------------------------------------------------------------------------
+bool TASWNullLog::ShouldLog(const TASWLogRecord& /*record*/) const noexcept
+{
+    return false;
+}
+
+//---------------------------------------------------------------------------
+/*
+    TASWNullLog::StoreConfig
+
+    Replaces the kept config with a copy of 'config'. The previous one is released after the lock, since destroying it
+    can run other code (e.g. the destructors of its callbacks' captures). False if the copy can't be made.
+*/
+bool TASWNullLog::StoreConfig(const TASWLogConfig& config) noexcept
+{
+    try
+    {
+        auto snapshot = std::make_shared<const TASWLogConfig>(config);
+
+        {
+            std::lock_guard<std::mutex> lock(m_ConfigMutex);
+            m_Config.swap(snapshot);
+        }
+
+        return true;
+    }
+    catch (...)
+    {
+        return false;
+    }
+}
+
+//---------------------------------------------------------------------------
+void TASWNullLog::Write(const TASWLogRecord& /*record*/) noexcept
+{
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_NullLog.h b/ASWLog/ASWLog_NullLog.h
new file mode 100644
index 0000000..52a654e
--- /dev/null
+++ b/ASWLog/ASWLog_NullLog.h
@@ -0,0 +1,120 @@
+/* **************************************************************************
+ASWLog_NullLog.h
+Author: Anthony S. West - ASW Software
+
+A light-weight logging tool.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_NullLogH
+#define ASWLog_NullLogH
+//---------------------------------------------------------------------------
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <string_view>
+//---------------------------------------------------------------------------
+#include "ASWLog_Interface.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWNullLog
+//
+// A logger that writes nothing, e.g. to turn logging off behind an IASWLog& without changing the code that logs, or to
+// pass to code under test:
+//     void Sync(ASWLog::IASWLog& log = ASWLog::TASWNullLog::GetInstance());
+//
+// ShouldLog() and IsEnabled() are always false (SetEnabled() is ignored), so no logging call formats, stamps or copies
+// anything, the LogForce*() ones included: a call costs one virtual call. Everything else behaves like a working
+// logger, so code that manages its logger keeps working: Initialize(), Reconfigure(), Open(), Close() and Flush()
+// return true, IsOpen() is true, GetConfig() returns the config last passed to Initialize() or Reconfigure() (a default
+// config before), and the minimum level reads back as set (Initialize() seeds it from InitialMinimumLevel).
+//
+// Thread-safe.
+/////////////////////////////////////////////////////////////////////////////
+class TASWNullLog : public IASWLog
+{
+private:
+    typedef IASWLog inherited;
+
+private:
+    mutable std::mutex m_ConfigMutex;
+    std::shared_ptr<const TASWLogConfig> m_Config; // Never null; guarded by m_ConfigMutex
+    std::atomic<Level> m_MinimumLevel{ Level::Info };
+
+private:
+    bool StoreConfig(const TASWLogConfig& config) noexcept;
+
+public: // Static methods
+    // A shared instance, e.g. for a default argument. Never destroyed, so it stays usable through static destruction.
+    static TASWNullLog& GetInstance();
+
+public:
+    // Throws std::bad_alloc if the default config can't be made
+    TASWNullLog();
+    ~TASWNullLog() override = default;
+
+    TASWNullLog(const TASWNullLog&) = delete;
+    TASWNullLog& operator=(const TASWNullLog&) = delete;
+
+    std::string_view GetVersionStr() const noexcept override;
+    std::string GetFullVersionStr() const override;
+
+    // The config last passed to Initialize() or Reconfigure(), or a default config
+    std::shared_ptr<const TASWLogConfig> GetConfig() const noexcept override;
+
+    // Keep the config (see GetConfig()) and return true; false only if it can't be copied (out of memory). Initialize()
+    // also sets the minimum level to config.InitialMinimumLevel.
+    bool Initialize(const TASWLogConfig& config) noexcept override;
+    bool Reconfigure(const TASWLogConfig& config) noexcept override;
+
+    // Do nothing and return true
+    bool Open() noexcept override;
+    bool Close() noexcept override;
+    bool Flush() noexcept override;
+    bool IsOpen() const noexcept override;
+
+    // Does nothing (there is no backtrace)
+    void DumpBacktrace() noexcept override;
+
+    // Always false: SetEnabled() is ignored, so the LogForce*Fmt() methods never format either
+    bool IsEnabled() const noexcept override;
+    void SetEnabled(bool enabled) noexcept override;
+
+    // Read back as set, though nothing is written at any level
+    Level GetMinimumLevel() const noexcept override;
+    void SetMinimumLevel(Level level) noexcept override;
+
+    // Always false
+    bool ShouldLog(Level level) const noexcept override;
+    bool ShouldLog(const TASWLogRecord& record) const noexcept override;
+
+    // Does nothing
+    void Write(const TASWLogRecord& record) noexcept override;
+};
+
+} // namespace ASWLog
+
+#endif // #ifndef ASWLog_NullLogH
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c69d801..178f297 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -136,6 +136,13 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   logger's own lines (startup, shutdown, backtrace markers, crash lines)
   don't pass through it. A multi-log runs its hook once per entry and
   passes its config on without it.
+- `TASWNullLog` (new `ASWLog_NullLog.h`): a logger that writes nothing,
+  e.g. to turn logging off behind an `IASWLog&` or to pass to code under
+  test; `TASWNullLog::GetInstance()` gives a shared one, e.g. for a default
+  argument. No logging call formats or copies anything (`ShouldLog()` and
+  `IsEnabled()` are always false), while the lifecycle methods succeed,
+  `GetConfig()` returns the config last passed in, and the minimum level
+  reads back as set.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8ff3738..353b617 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,6 +38,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_Interface.h
     ASWLog/ASWLog_MultiLog.cpp
     ASWLog/ASWLog_MultiLog.h
+    ASWLog/ASWLog_NullLog.cpp
+    ASWLog/ASWLog_NullLog.h
     ASWLog/ASWLog_TextLogBase.cpp
     ASWLog/ASWLog_TextLogBase.h
     ASWLog/ASWLog_Types.cpp
diff --git a/Deploy.bat b/Deploy.bat
index 3428670..e26f444 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -104,6 +104,10 @@ call :CopyFile "ASWLog\ASWLog_MultiLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_MultiLog
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_MultiLog.h" "%TARGET_DIR%\ASWLog\ASWLog_MultiLog.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_NullLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_NullLog.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_NullLog.h" "%TARGET_DIR%\ASWLog\ASWLog_NullLog.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_TextLogBase.cpp" "%TARGET_DIR%\ASWLog\ASWLog_TextLogBase.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_TextLogBase.h" "%TARGET_DIR%\ASWLog\ASWLog_TextLogBase.h"
diff --git a/README.md b/README.md
index b406287..dea6b93 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   or drop noisy entries by content, category or field.
 - Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
   entry on the thread carries, e.g. `ASWLog::TASWLogScope scope{{"requestId", id}};` (`ASWLog_Fields.h`).
+- A null logger (`ASWLog::TASWNullLog`) that writes nothing, to turn logging off behind an `IASWLog&` or to pass to
+  code under test.
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
   or derive a new text logger from `TASWTextLogBase` and implement only its output.
 
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index 80045fc..e323de5 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -175,6 +175,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>7</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_NullLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_NullLog.h</DependentOn>
+            <BuildOrder>16</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>10</BuildOrder>
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index c7bfdd6..dc24eb5 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -41,6 +41,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_FileLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Formatter.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_MultiLog.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_NullLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_TextLogBase.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Types.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Utils.cpp"
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index 6f76ec1..b60870f 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -190,6 +190,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>5</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_NullLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_NullLog.h</DependentOn>
+            <BuildOrder>41</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>26</BuildOrder>
@@ -246,6 +250,10 @@
             <DependentOn>..\tests\Test_ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>23</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_NullLog.cpp">
+            <DependentOn>..\tests\Test_ASWLog_NullLog.h</DependentOn>
+            <BuildOrder>42</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_TextLogBase.cpp">
             <DependentOn>..\tests\Test_ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>27</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_NullLog.cpp b/tests/tests/Test_ASWLog_NullLog.cpp
new file mode 100644
index 0000000..580e4c4
--- /dev/null
+++ b/tests/tests/Test_ASWLog_NullLog.cpp
@@ -0,0 +1,265 @@
+/* **************************************************************************
+Test_ASWLog_NullLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_NullLog.h"
+//---------------------------------------------------------------------------
+#include <atomic>
+#include <format>
+#include <string>
+#include <thread>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_CategoryLog.h"
+#include "ASWLog_MultiLog.h"
+#include "ASWLog_NullLog.h"
+#include "ASWLog_Version.h"
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+// A value whose formatting is counted in NullLogFormatCount, to check that no *Fmt call formats
+struct TNullLogCountedValue
+{
+};
+
+int NullLogFormatCount = 0;
+
+} // namespace
+
+template<>
+struct std::formatter<TNullLogCountedValue>
+{
+    constexpr std::format_parse_context::iterator parse(std::format_parse_context& context)
+    {
+        return context.begin();
+    }
+
+    std::format_context::iterator format(const TNullLogCountedValue& /*value*/, std::format_context& context) const
+    {
+        ++NullLogFormatCount;
+        return std::format_to(context.out(), "counted");
+    }
+};
+
+namespace ASWUnitTests
+{
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_NullLog
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_NullLog::TTest_ASWLog_NullLog()
+    : inherited("ASWLog_NullLog_Tests")
+{
+    RegisterTest(&TTest_ASWLog_NullLog::Test_Fmt_NeverFormats, "Fmt_NeverFormats");
+    RegisterTest(&TTest_ASWLog_NullLog::Test_GetConfig_IsSafeWhileReconfiguring, "GetConfig_IsSafeWhileReconfiguring");
+    RegisterTest(&TTest_ASWLog_NullLog::Test_GetInstance_ReturnsTheSameLogger, "GetInstance_ReturnsTheSameLogger");
+    RegisterTest(&TTest_ASWLog_NullLog::Test_Lifecycle_SucceedsAndKeepsTheConfig, "Lifecycle_SucceedsAndKeepsTheConfig");
+    RegisterTest(&TTest_ASWLog_NullLog::Test_ShouldLog_IsAlwaysFalse, "ShouldLog_IsAlwaysFalse");
+    RegisterTest(&TTest_ASWLog_NullLog::Test_Wrapped_WritesNothing, "Wrapped_WritesNothing");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_NullLog::~TTest_ASWLog_NullLog()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::SetUp_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::SetUp_Test(ITestCase& /*testCase*/)
+{
+    NullLogFormatCount = 0;
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::TearDown_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::TearDown_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::Test_Fmt_NeverFormats()
+{
+    // Arrange: everything a real logger would need to write an entry
+    ASWLog::TASWNullLog log;
+    log.SetMinimumLevel(ASWLog::Level::Trace);
+    log.SetEnabled(true);
+
+    // Act
+    log.LogTraceFmt("{}", TNullLogCountedValue{});
+    log.LogCriticalFmt("{}", TNullLogCountedValue{});
+    log.LogRawFmt(ASWLog::Level::Error, "{}", TNullLogCountedValue{});
+    log.LogForceFmt(ASWLog::Level::Critical, "{}", TNullLogCountedValue{});
+    log.LogForceRawFmt(ASWLog::Level::Critical, "{}", TNullLogCountedValue{});
+    log.LogInfoFmt({ { "orderId", 17 } }, "{}", TNullLogCountedValue{});
+
+    // Assert
+    CheckEquals(0, NullLogFormatCount, "No *Fmt call should format its message");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::Test_GetConfig_IsSafeWhileReconfiguring()
+{
+    // Arrange: two threads reconfigure while two read the config (for ThreadSanitizer)
+    ASWLog::TASWNullLog log;
+    ASWLog::TASWLogConfig first;
+    first.Startup.Banner = "first";
+    ASWLog::TASWLogConfig second;
+    second.Startup.Banner = "second";
+    log.Initialize(first);
+    std::atomic<int> unexpectedCount{ 0 };
+    std::atomic<int> failedCount{ 0 };
+
+    // Act
+    std::vector<std::thread> threads;
+    for (int threadIndex = 0; threadIndex < 4; ++threadIndex)
+    {
+        threads.emplace_back([&, threadIndex] {
+                for (int index = 0; index < 500; ++index)
+                {
+                    if (threadIndex < 2)
+                    {
+                        if (!log.Reconfigure(index % 2 == 0 ? second : first))
+                            failedCount.fetch_add(1);
+                    }
+                    else
+                    {
+                        const auto banner = log.GetConfig()->Startup.Banner;
+                        if (banner != "first" && banner != "second")
+                            unexpectedCount.fetch_add(1);
+                    }
+                }
+            });
+    }
+
+    for (auto& thread : threads)
+        thread.join();
+
+    // Assert
+    CheckEquals(0, failedCount.load(), "Every Reconfigure() should succeed");
+    CheckEquals(0, unexpectedCount.load(), "Every read should see one of the configs whole");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::Test_GetInstance_ReturnsTheSameLogger()
+{
+    // Act
+    auto& first = ASWLog::TASWNullLog::GetInstance();
+    auto& second = ASWLog::TASWNullLog::GetInstance();
+
+    // Assert
+    CheckSame(&first, &second, "GetInstance() should always return the same logger");
+    CheckFalse(first.ShouldLog(ASWLog::Level::Critical), "The shared instance should write nothing either");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::Test_Lifecycle_SucceedsAndKeepsTheConfig()
+{
+    // Arrange
+    ASWLog::TASWNullLog log;
+    ASWLog::TASWLogConfig config;
+    config.Startup.Banner = "initialized";
+    config.InitialMinimumLevel = ASWLog::Level::Debug;
+    auto changedConfig = config;
+    changedConfig.Startup.Banner = "reconfigured";
+    changedConfig.InitialMinimumLevel = ASWLog::Level::Error;
+
+    // Act
+    const auto defaultConfig = log.GetConfig();
+    const bool initialized = log.Initialize(config);
+    const auto initializedConfig = log.GetConfig();
+    const auto levelAfterInitialize = log.GetMinimumLevel();
+    const bool reconfigured = log.Reconfigure(changedConfig);
+    const auto levelAfterReconfigure = log.GetMinimumLevel();
+    log.SetMinimumLevel(ASWLog::Level::Warn);
+    log.DumpBacktrace();
+
+    // Assert
+    AssertNotNull(defaultConfig, "GetConfig() should return a config before Initialize()");
+    CheckEmpty(defaultConfig->Startup.Banner, "The config before Initialize() should be the default");
+    CheckTrue(initialized && reconfigured, "Initialize() and Reconfigure() should succeed");
+    CheckEquals(std::string("initialized"), initializedConfig->Startup.Banner, "An earlier snapshot should stay unchanged");
+    CheckEquals(std::string("reconfigured"), log.GetConfig()->Startup.Banner, "GetConfig() should return the last config passed in");
+    CheckEquals(ASWLog::Level::Debug, levelAfterInitialize, "Initialize() should seed the minimum level");
+    CheckEquals(ASWLog::Level::Debug, levelAfterReconfigure, "Reconfigure() should keep the minimum level");
+    CheckEquals(ASWLog::Level::Warn, log.GetMinimumLevel(), "The minimum level should read back as set");
+    CheckTrue(log.Open() && log.Flush() && log.IsOpen() && log.Close(), "Open(), Flush(), IsOpen() and Close() should succeed");
+    CheckContains(log.GetFullVersionStr(), "TASWNullLog", "The full version should name the logger");
+    CheckEquals(std::string(ASWLog::Version), std::string(log.GetVersionStr()), "The version should be the library's");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::Test_ShouldLog_IsAlwaysFalse()
+{
+    // Arrange
+    ASWLog::TASWNullLog log;
+    log.SetMinimumLevel(ASWLog::Level::Trace);
+    log.SetEnabled(true);
+    ASWLog::TASWLogRecord forced;
+    forced.LogLevel = ASWLog::Level::Critical;
+    forced.Forced = true;
+
+    // Act & Assert
+    for (const auto level : { ASWLog::Level::Trace, ASWLog::Level::Info, ASWLog::Level::Critical })
+        CheckFalse(log.ShouldLog(level), std::format("ShouldLog({}) should be false", ASWLog::Level_ToString(level)));
+
+    CheckFalse(log.ShouldLog(forced), "ShouldLog() should be false for a forced record");
+    CheckFalse(log.IsEnabled(), "IsEnabled() should stay false after SetEnabled(true)");
+    log.Write(forced);
+    log.LogCritical("not written");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_NullLog::Test_Wrapped_WritesNothing()
+{
+    // Arrange: a category and a multi-log in front of a null log
+    ASWLog::TASWNullLog log;
+    ASWLog::TASWCategoryLog netLog("Net", log);
+    netLog.SetMinimumLevel(ASWLog::Level::Trace);
+    ASWLog::TASWMultiLog multiLog;
+    multiLog.AddLogger(log);
+    multiLog.SetMinimumLevel(ASWLog::Level::Trace);
+
+    // Act
+    netLog.LogInfoFmt("{}", TNullLogCountedValue{});
+    multiLog.LogInfoFmt("{}", TNullLogCountedValue{});
+
+    // Assert
+    CheckFalse(netLog.ShouldLog(ASWLog::Level::Critical), "A category over a null log should write nothing");
+    CheckFalse(multiLog.ShouldLog(ASWLog::Level::Critical), "A multi-log holding only a null log should write nothing");
+    CheckEquals(0, NullLogFormatCount, "Neither should format a message for the null log");
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_NullLog)
diff --git a/tests/tests/Test_ASWLog_NullLog.h b/tests/tests/Test_ASWLog_NullLog.h
new file mode 100644
index 0000000..3f60a25
--- /dev/null
+++ b/tests/tests/Test_ASWLog_NullLog.h
@@ -0,0 +1,61 @@
+/* **************************************************************************
+Test_ASWLog_NullLog.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_NullLogH
+#define Test_ASWLog_NullLogH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_NullLog
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_NullLog : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_Fmt_NeverFormats();
+    void Test_GetConfig_IsSafeWhileReconfiguring();
+    void Test_GetInstance_ReturnsTheSameLogger();
+    void Test_Lifecycle_SucceedsAndKeepsTheConfig();
+    void Test_ShouldLog_IsAlwaysFalse();
+    void Test_Wrapped_WritesNothing();
+
+public:
+    TTest_ASWLog_NullLog();
+    ~TTest_ASWLog_NullLog() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_NullLogH
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index 90800a6..935bd6f 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -228,6 +228,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>7</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_NullLog.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_NullLog.h</DependentOn>
+            <BuildOrder>52</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>34</BuildOrder>
@@ -280,6 +284,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>31</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_NullLog.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_NullLog.h</DependentOn>
+            <BuildOrder>53</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>35</BuildOrder>

From 5ccedc37a024314350eb8990624d777158ebdb48 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 08:31:31 -0700
Subject: [PATCH 14/38] Add TASWMemoryLog

---
 ASWLog/ASWLog_Config.h                        |  15 +
 ASWLog/ASWLog_MemoryLog.cpp                   | 223 +++++++++++
 ASWLog/ASWLog_MemoryLog.h                     | 130 ++++++
 CHANGELOG.md                                  |  11 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 README.md                                     |   3 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_Config.cpp            |   2 +
 tests/tests/Test_ASWLog_MemoryLog.cpp         | 372 ++++++++++++++++++
 tests/tests/Test_ASWLog_MemoryLog.h           |  65 +++
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 14 files changed, 848 insertions(+)
 create mode 100644 ASWLog/ASWLog_MemoryLog.cpp
 create mode 100644 ASWLog/ASWLog_MemoryLog.h
 create mode 100644 tests/tests/Test_ASWLog_MemoryLog.cpp
 create mode 100644 tests/tests/Test_ASWLog_MemoryLog.h

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index b36610f..0dfc90c 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -247,6 +247,20 @@ struct TASWLineConfig
 };
 
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWMemoryConfig
+//
+// How much a TASWMemoryLog keeps (TASWLogConfig::Memory). When a new line doesn't fit, the oldest lines go.
+/////////////////////////////////////////////////////////////////////////////
+struct TASWMemoryConfig
+{
+    std::size_t MaxLines = 1000; // 0 = no limit
+    // The most bytes of text kept, the lines' characters (not the memory each line takes beyond them); 0 = no limit. A
+    // line longer than this on its own is kept cut to fit, ending with " [cut]".
+    std::size_t MaxBytes = 0;
+};
+
+
 /////////////////////////////////////////////////////////////////////////////
 // TASWShutdownConfig
 //
@@ -300,6 +314,7 @@ struct TASWLogConfig
     TASWFileConfig File;
     TASWAsyncConfig Async;
     TASWBacktraceConfig Backtrace;
+    TASWMemoryConfig Memory;
 
     // --- Pre-write Hook ---
     // A last chance for the application to drop or change each of its entries before the logger writes it, e.g. to
diff --git a/ASWLog/ASWLog_MemoryLog.cpp b/ASWLog/ASWLog_MemoryLog.cpp
new file mode 100644
index 0000000..b3afa80
--- /dev/null
+++ b/ASWLog/ASWLog_MemoryLog.cpp
@@ -0,0 +1,223 @@
+/* **************************************************************************
+ASWLog_MemoryLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_MemoryLog.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <algorithm>
+#include <mutex>
+#include <utility>
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+namespace
+{
+
+// Ends a line cut to fit TASWMemoryConfig::MaxBytes
+constexpr std::string_view CutMarker = " [cut]";
+
+//---------------------------------------------------------------------------
+
+void CutToFit(std::string& text, std::size_t maxBytes);
+
+//---------------------------------------------------------------------------
+
+/*
+  CutToFit
+
+  Cuts 'text' to at most 'maxBytes' bytes, between UTF-8 characters, ending with CutMarker if that fits too
+*/
+void CutToFit(std::string& text, std::size_t maxBytes)
+{
+    if (text.size() <= maxBytes)
+        return;
+
+    const bool hasMarker = maxBytes >= CutMarker.size();
+    std::size_t keptSize = hasMarker ? maxBytes - CutMarker.size() : maxBytes;
+
+    // Back to the start of a UTF-8 character (a continuation byte is 10xxxxxx)
+    while (keptSize > 0 && (static_cast<unsigned char>(text[keptSize]) & 0xC0) == 0x80)
+        --keptSize;
+
+    text.resize(keptSize);
+
+    if (hasMarker)
+        text.append(CutMarker);
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWMemoryLog
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWMemoryLog::~TASWMemoryLog()
+{
+    Finalize();
+}
+
+//---------------------------------------------------------------------------
+/*
+    TASWMemoryLog::ApplyLimitsUnlocked
+
+    Takes the limits from the current config (TASWLogConfig::Memory), dropping the oldest lines that no longer fit
+*/
+void TASWMemoryLog::ApplyLimitsUnlocked()
+{
+    const auto& config = GetConfigUnlocked().Memory;
+    std::lock_guard<std::mutex> lock(m_LinesMutex);
+    m_MaxLines = config.MaxLines;
+    m_MaxBytes = config.MaxBytes;
+    DropOldestLines();
+}
+
+//---------------------------------------------------------------------------
+void TASWMemoryLog::Clear() noexcept
+{
+    std::lock_guard<std::mutex> lock(m_LinesMutex);
+    m_Lines.clear();
+    m_ByteCount = 0;
+}
+
+//---------------------------------------------------------------------------
+bool TASWMemoryLog::CloseUnlocked()
+{
+    m_IsOpen.store(false);
+    m_IsInitialized.store(false);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+// Drops the oldest lines until the kept ones fit the limits
+void TASWMemoryLog::DropOldestLines() noexcept
+{
+    while (!m_Lines.empty() && ((m_MaxLines > 0 && m_Lines.size() > m_MaxLines) || (m_MaxBytes > 0 && m_ByteCount > m_MaxBytes)))
+    {
+        m_ByteCount -= m_Lines.front().size();
+        m_Lines.pop_front();
+    }
+}
+
+//---------------------------------------------------------------------------
+bool TASWMemoryLog::FlushUnlocked()
+{
+    return m_IsOpen.load();
+}
+
+//---------------------------------------------------------------------------
+std::size_t TASWMemoryLog::GetLineCount() const noexcept
+{
+    std::lock_guard<std::mutex> lock(m_LinesMutex);
+    return m_Lines.size();
+}
+
+//---------------------------------------------------------------------------
+std::vector<std::string> TASWMemoryLog::GetLines() const
+{
+    std::lock_guard<std::mutex> lock(m_LinesMutex);
+    return std::vector<std::string>(m_Lines.begin(), m_Lines.end());
+}
+
+//---------------------------------------------------------------------------
+TASWMemoryLines TASWMemoryLog::GetLinesSince(std::uint64_t sequence) const
+{
+    TASWMemoryLines result;
+    std::lock_guard<std::mutex> lock(m_LinesMutex);
+
+    // The first line ever kept is 1
+    const std::uint64_t first = std::max<std::uint64_t>(sequence, 1);
+    const std::uint64_t oldestKept = m_NextSequence - m_Lines.size();
+    result.NextSequence = m_NextSequence;
+
+    if (first < oldestKept)
+        result.MissedCount = oldestKept - first;
+
+    if (first < m_NextSequence)
+    {
+        const auto skipped = static_cast<std::size_t>(std::max(first, oldestKept) - oldestKept);
+        result.Lines.assign(m_Lines.begin() + static_cast<std::ptrdiff_t>(skipped), m_Lines.end());
+    }
+
+    return result;
+}
+
+//---------------------------------------------------------------------------
+bool TASWMemoryLog::InitializeUnlocked()
+{
+    ApplyLimitsUnlocked();
+
+    return OpenUnlocked();
+}
+
+//---------------------------------------------------------------------------
+bool TASWMemoryLog::OpenUnlocked()
+{
+    m_IsOpen.store(true);
+    m_IsInitialized.store(true);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWMemoryLog::ReconfigureUnlocked(const TASWLogConfig& /*previous*/)
+{
+    ApplyLimitsUnlocked();
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+void TASWMemoryLog::WriteLineUnlocked(Level /*level*/, std::string_view line, bool endsLine)
+{
+    // Kept without the line ending the formatted line ends with
+    if (endsLine)
+    {
+        const std::string_view ending = GetConfigUnlocked().Line.Ending == LineEnding::CRLF ? "\r\n" : "\n";
+        if (line.ends_with(ending))
+            line.remove_suffix(ending.size());
+    }
+
+    // Made before taking the lock; a failed allocation drops the entry (see TASWTextLogBase::WriteRecord())
+    std::string text(line);
+    std::lock_guard<std::mutex> lock(m_LinesMutex);
+
+    if (m_MaxBytes > 0)
+        CutToFit(text, m_MaxBytes);
+
+    const std::size_t size = text.size();
+    m_Lines.push_back(std::move(text));
+    m_ByteCount += size;
+    ++m_NextSequence;
+    DropOldestLines();
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_MemoryLog.h b/ASWLog/ASWLog_MemoryLog.h
new file mode 100644
index 0000000..b0bc05c
--- /dev/null
+++ b/ASWLog/ASWLog_MemoryLog.h
@@ -0,0 +1,130 @@
+/* **************************************************************************
+ASWLog_MemoryLog.h
+Author: Anthony S. West - ASW Software
+
+A light-weight logging tool.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_MemoryLogH
+#define ASWLog_MemoryLogH
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <deque>
+#include <string>
+#include <string_view>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWLog_TextLogBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWMemoryLines struct
+//
+// The lines TASWMemoryLog::GetLinesSince() returns.
+/////////////////////////////////////////////////////////////////////////////
+struct TASWMemoryLines
+{
+    std::vector<std::string> Lines; // Oldest first
+    std::uint64_t NextSequence = 1; // The sequence number to pass to the next GetLinesSince()
+    std::uint64_t MissedCount = 0; // Lines from the asked sequence number on that are no longer kept (dropped, cleared)
+};
+
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWMemoryLog
+//
+// A text logger that keeps its newest lines in memory instead of writing them out, e.g. for an in-app log viewer,
+// for a crash report (see HandleCrash()), or for tests of code that logs. Each line is formatted like a file logger's
+// (TASWLogConfig::Line, including its formatter) and kept without its line ending; a LogRaw() entry written as is is
+// kept as given. TASWLogConfig::Memory sets how many lines and bytes it keeps; the oldest go first. Like the other text
+// loggers, it writes the startup lines (TASWLogConfig::Startup) and the shutdown line, and supports asynchronous
+// writing, OnLogEntry, OnBeforeWrite and the backtrace.
+//
+// Each kept line has a sequence number, from 1, so a viewer can fetch only the new ones, e.g. on a timer:
+//     const auto newLines = memoryLog.GetLinesSince(nextSequence);
+//     nextSequence = newLines.NextSequence;
+//
+// Thread-safe. Close() keeps the lines (entries logged while closed are dropped); Clear() forgets them.
+/////////////////////////////////////////////////////////////////////////////
+class TASWMemoryLog : public TASWTextLogBase
+{
+private:
+    typedef TASWTextLogBase inherited;
+
+private:
+    // The kept lines, guarded by m_LinesMutex (lock order: m_Mutex before it), so reading doesn't wait for a write
+    mutable Detail::TMutex m_LinesMutex;
+    std::deque<std::string> m_Lines; // Oldest first
+    std::size_t m_ByteCount = 0; // Of the kept lines' text
+    std::uint64_t m_NextSequence = 1; // The next line's; the oldest kept line's is m_NextSequence - m_Lines.size()
+    std::size_t m_MaxLines = 0; // TASWMemoryConfig, as last applied; 0 = no limit
+    std::size_t m_MaxBytes = 0;
+
+private:
+    void ApplyLimitsUnlocked();
+    void DropOldestLines() noexcept; // Holding m_LinesMutex
+
+protected:
+    bool CloseUnlocked() override;
+    bool FlushUnlocked() override;
+
+    std::string_view GetLoggerClassName() const noexcept override
+    {
+        return "TASWMemoryLog";
+    }
+
+    bool InitializeUnlocked() override;
+    bool OpenUnlocked() override;
+    bool ReconfigureUnlocked(const TASWLogConfig& previous) override;
+    void WriteLineUnlocked(Level level, std::string_view line, bool endsLine) override;
+
+public:
+    TASWMemoryLog() = default;
+    // Writes the shutdown line (see TASWTextLogBase::Finalize())
+    ~TASWMemoryLog() override;
+
+    TASWMemoryLog(const TASWMemoryLog&) = delete;
+    TASWMemoryLog& operator=(const TASWMemoryLog&) = delete;
+
+    // Forgets the kept lines. The sequence numbers go on (see GetLinesSince()).
+    void Clear() noexcept;
+
+    // How many lines are kept
+    std::size_t GetLineCount() const noexcept;
+
+    // A copy of the kept lines, oldest first. Throws std::bad_alloc if they can't be copied.
+    std::vector<std::string> GetLines() const;
+
+    // A copy of the kept lines whose sequence number is 'sequence' or higher (the first line ever kept is 1), the
+    // sequence number to pass next time, and how many lines from 'sequence' on are no longer kept. Throws
+    // std::bad_alloc if they can't be copied.
+    TASWMemoryLines GetLinesSince(std::uint64_t sequence) const;
+};
+
+} // namespace ASWLog
+
+#endif // #ifndef ASWLog_MemoryLogH
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 178f297..f0106ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -143,6 +143,17 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   `IsEnabled()` are always false), while the lifecycle methods succeed,
   `GetConfig()` returns the config last passed in, and the minimum level
   reads back as set.
+- `TASWMemoryLog` (new `ASWLog_MemoryLog.h`): a text logger that keeps its
+  newest lines in memory, formatted like a file logger's and without the
+  line ending, e.g. for an in-app log viewer, a crash report or tests of
+  code that logs. The new `TASWLogConfig::Memory` group sets how much it
+  keeps: `MaxLines` (default 1000) and `MaxBytes` (default 0, no limit; a
+  single longer line is cut to fit, ending with " [cut]"); the oldest lines
+  go first. `GetLines()`, `GetLineCount()` and `Clear()` read and clear
+  them, and `GetLinesSince(n)` returns only the lines numbered n and up
+  (every kept line gets the next sequence number), with the number to ask
+  for next and how many lines were missed, so a viewer can poll for new
+  lines.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 353b617..02667b4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,6 +36,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_Formatter.h
     ASWLog/ASWLog_Interface.cpp
     ASWLog/ASWLog_Interface.h
+    ASWLog/ASWLog_MemoryLog.cpp
+    ASWLog/ASWLog_MemoryLog.h
     ASWLog/ASWLog_MultiLog.cpp
     ASWLog/ASWLog_MultiLog.h
     ASWLog/ASWLog_NullLog.cpp
diff --git a/Deploy.bat b/Deploy.bat
index e26f444..85afe81 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -100,6 +100,10 @@ call :CopyFile "ASWLog\ASWLog_Interface.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Interfa
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Interface.h" "%TARGET_DIR%\ASWLog\ASWLog_Interface.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_MemoryLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_MemoryLog.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_MemoryLog.h" "%TARGET_DIR%\ASWLog\ASWLog_MemoryLog.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_MultiLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_MultiLog.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_MultiLog.h" "%TARGET_DIR%\ASWLog\ASWLog_MultiLog.h"
diff --git a/README.md b/README.md
index dea6b93..e954f86 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,9 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   or drop noisy entries by content, category or field.
 - Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
   entry on the thread carries, e.g. `ASWLog::TASWLogScope scope{{"requestId", id}};` (`ASWLog_Fields.h`).
+- A memory logger (`ASWLog::TASWMemoryLog`) that keeps the newest lines, limited by count and size
+  (`TASWLogConfig::Memory`), for an in-app log viewer (`GetLinesSince()` returns only the new ones), a crash report or
+  tests.
 - A null logger (`ASWLog::TASWNullLog`) that writes nothing, to turn logging off behind an `IASWLog&` or to pass to
   code under test.
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index e323de5..f582c2d 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -171,6 +171,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Interface.h</DependentOn>
             <BuildOrder>6</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_MemoryLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_MemoryLog.h</DependentOn>
+            <BuildOrder>17</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_MultiLog.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>7</BuildOrder>
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index dc24eb5..e2c3492 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -40,6 +40,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Fields.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_FileLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Formatter.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_MemoryLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_MultiLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_NullLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_TextLogBase.cpp"
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index b60870f..b0dcc05 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -186,6 +186,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Interface.h</DependentOn>
             <BuildOrder>4</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_MemoryLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_MemoryLog.h</DependentOn>
+            <BuildOrder>43</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_MultiLog.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>5</BuildOrder>
@@ -246,6 +250,10 @@
             <DependentOn>..\tests\Test_ASWLog_Formatter.h</DependentOn>
             <BuildOrder>29</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_MemoryLog.cpp">
+            <DependentOn>..\tests\Test_ASWLog_MemoryLog.h</DependentOn>
+            <BuildOrder>44</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_MultiLog.cpp">
             <DependentOn>..\tests\Test_ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>23</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index d669d59..a128816 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -81,6 +81,8 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     CheckEquals(ASWLog::Level::Error, config.OnLogEntryMinimumLevel, "OnLogEntryMinimumLevel should default to Error");
     CheckNull(config.OnError, "OnError should default to unset (reports go to stderr)");
     CheckNull(config.OnBeforeWrite, "OnBeforeWrite should default to unset");
+    CheckEquals(1000, config.Memory.MaxLines, "Memory.MaxLines should default to 1000");
+    CheckEquals(0, config.Memory.MaxBytes, "Memory.MaxBytes should default to 0 (no limit)");
     CheckFalse(config.Async.Enabled, "Async.Enabled should default to false");
     CheckEquals(8192, config.Async.QueueCapacity, "Async.QueueCapacity should default to 8192");
     CheckEquals(ASWLog::AsyncOverflowPolicy::Block, config.Async.OverflowPolicy, "Async.OverflowPolicy should default to Block");
diff --git a/tests/tests/Test_ASWLog_MemoryLog.cpp b/tests/tests/Test_ASWLog_MemoryLog.cpp
new file mode 100644
index 0000000..8a3f029
--- /dev/null
+++ b/tests/tests/Test_ASWLog_MemoryLog.cpp
@@ -0,0 +1,372 @@
+/* **************************************************************************
+Test_ASWLog_MemoryLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_MemoryLog.h"
+//---------------------------------------------------------------------------
+#include <atomic>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <format>
+#include <set>
+#include <string>
+#include <thread>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_MemoryLog.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+// How long a test waits for something another thread does, before it fails
+constexpr std::chrono::milliseconds WaitTimeout = std::chrono::seconds(5);
+
+//---------------------------------------------------------------------------
+
+// A config with no startup or shutdown lines and only the level in each line, e.g. "[INFO]: message", keeping at most
+// 'maxLines' lines and 'maxBytes' bytes
+ASWLog::TASWLogConfig MakeMemoryConfig(std::size_t maxLines = 1000, std::size_t maxBytes = 0)
+{
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Info;
+    config.Line.ShowTimestamp = false;
+    config.Line.ShowProcessId = false;
+    config.Line.ShowThreadId = false;
+    config.Shutdown.WriteLine = false;
+    config.Startup.WriteTimeInfo = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    config.Memory.MaxLines = maxLines;
+    config.Memory.MaxBytes = maxBytes;
+    return config;
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_MemoryLog
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_MemoryLog::TTest_ASWLog_MemoryLog()
+    : inherited("ASWLog_MemoryLog_Tests")
+{
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_Async_KeepsTheQueuedLines, "Async_KeepsTheQueuedLines");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_Clear_ForgetsTheLinesButNotTheSequence, "Clear_ForgetsTheLinesButNotTheSequence");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_Close_KeepsTheLines, "Close_KeepsTheLines");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_GetLinesSince_ReturnsNewLinesAndCountsMissedOnes, "GetLinesSince_ReturnsNewLinesAndCountsMissedOnes");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_KeepsLinesWithoutTheirEnding, "KeepsLinesWithoutTheirEnding");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_MaxBytes_CutsALineThatAloneIsTooLong, "MaxBytes_CutsALineThatAloneIsTooLong");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_MaxBytes_DropsTheOldestLines, "MaxBytes_DropsTheOldestLines");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_MaxLines_KeepsTheNewest, "MaxLines_KeepsTheNewest");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_Reconfigure_AppliesTheNewLimits, "Reconfigure_AppliesTheNewLimits");
+    RegisterTest(&TTest_ASWLog_MemoryLog::Test_Threads_ReaderGetsEveryLineOnce, "Threads_ReaderGetsEveryLineOnce");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_MemoryLog::~TTest_ASWLog_MemoryLog()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::SetUp_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::SetUp_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::TearDown_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::TearDown_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_Async_KeepsTheQueuedLines()
+{
+    // Arrange
+    auto config = MakeMemoryConfig();
+    config.Async.Enabled = true;
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+
+    // Act
+    log.LogInfo("one");
+    log.LogWarn("two");
+    log.Flush(); // Waits for the queued entries
+
+    // Assert
+    CheckTrue(log.GetLines() == std::vector<std::string>{ "[INFO]: one", "[WARN]: two" }, "The queued lines should be kept in order");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_Clear_ForgetsTheLinesButNotTheSequence()
+{
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeMemoryConfig()), "Initialize should succeed");
+    log.LogInfo("one");
+    log.LogInfo("two");
+
+    // Act
+    log.Clear();
+    const auto countAfterClear = log.GetLineCount();
+    const auto afterClear = log.GetLinesSince(1);
+    log.LogInfo("three");
+    const auto afterNewLine = log.GetLinesSince(afterClear.NextSequence);
+
+    // Assert
+    CheckEquals(0, countAfterClear, "Clear() should forget the lines");
+    CheckEmpty(afterClear.Lines, "No line should be left after Clear()");
+    CheckEquals(2, afterClear.MissedCount, "The cleared lines should count as missed");
+    CheckEquals(3, afterClear.NextSequence, "The sequence should go on after Clear()");
+    CheckTrue(afterNewLine.Lines == std::vector<std::string>{ "[INFO]: three" }, "A new line should follow the cleared ones");
+    CheckEquals(0, afterNewLine.MissedCount, "Nothing should be missed after the cleared lines");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_Close_KeepsTheLines()
+{
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeMemoryConfig()), "Initialize should succeed");
+    log.LogInfo("kept");
+
+    // Act
+    const bool closed = log.Close();
+    log.LogInfo("dropped");
+
+    // Assert
+    CheckTrue(closed, "Close() should succeed");
+    CheckFalse(log.IsOpen(), "The logger should be closed");
+    CheckFalse(log.Flush(), "Flush() should fail while closed");
+    CheckTrue(log.GetLines() == std::vector<std::string>{ "[INFO]: kept" }, "The lines should be kept after Close(), and no more added");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_GetLinesSince_ReturnsNewLinesAndCountsMissedOnes()
+{
+    // Arrange: lines 1 to 3 kept, then 4 and 5, which push 1 and 2 out
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeMemoryConfig(3)), "Initialize should succeed");
+    for (int index = 1; index <= 3; ++index)
+        log.LogInfo(std::format("line {}", index));
+
+    // Act
+    const auto all = log.GetLinesSince(1);
+    const auto fromZero = log.GetLinesSince(0);
+    const auto last = log.GetLinesSince(3);
+    const auto none = log.GetLinesSince(4);
+    log.LogInfo("line 4");
+    log.LogInfo("line 5");
+    const auto afterDrops = log.GetLinesSince(1);
+    const auto ahead = log.GetLinesSince(10);
+
+    // Assert
+    const std::vector<std::string> firstThree{ "[INFO]: line 1", "[INFO]: line 2", "[INFO]: line 3" };
+    CheckTrue(all.Lines == firstThree, "Every kept line should be returned from 1");
+    CheckEquals(4, all.NextSequence, "The next sequence number should follow the last line");
+    CheckEquals(0, all.MissedCount, "Nothing should be missed yet");
+    CheckTrue(fromZero.Lines == firstThree, "0 should read like 1, the first line's number");
+    CheckEquals(0, fromZero.MissedCount, "0 shouldn't count a line that never existed");
+    CheckTrue(last.Lines == std::vector<std::string>{ "[INFO]: line 3" }, "Only the lines from the given number should be returned");
+    CheckEmpty(none.Lines, "No line should be returned when there is none newer");
+    CheckEquals(4, none.NextSequence, "The next sequence number should stay when there is no new line");
+    CheckTrue(afterDrops.Lines == std::vector<std::string>{ "[INFO]: line 3", "[INFO]: line 4", "[INFO]: line 5" },
+        "The lines still kept should be returned");
+    CheckEquals(2, afterDrops.MissedCount, "The dropped lines should count as missed");
+    CheckEquals(6, afterDrops.NextSequence, "The next sequence number should follow line 5");
+    CheckEmpty(ahead.Lines, "A number past the last line should return nothing");
+    CheckEquals(0, ahead.MissedCount, "A number past the last line should miss nothing");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_KeepsLinesWithoutTheirEnding()
+{
+    // Arrange: LF, and CRLF with indented continuation lines
+    ASWLog::TASWMemoryLog log;
+    ASWLog::TASWMemoryLog crlfLog;
+    auto crlfConfig = MakeMemoryConfig();
+    crlfConfig.Line.Ending = ASWLog::LineEnding::CRLF;
+    crlfConfig.Line.Multiline = ASWLog::MultilineMode::Indent;
+    CheckTrue(log.Initialize(MakeMemoryConfig()), "Initialize should succeed");
+    CheckTrue(crlfLog.Initialize(crlfConfig), "Initialize should succeed (CRLF)");
+
+    // Act
+    log.LogInfo("plain");
+    log.LogInfo("ends with a break\n");
+    log.LogRaw(ASWLog::Level::Info, "raw\n");
+    log.LogRaw(ASWLog::Level::Info, "partial");
+    crlfLog.LogInfo("first\nsecond");
+    crlfLog.LogRaw(ASWLog::Level::Info, "raw\r\n");
+
+    // Assert
+    const std::vector<std::string> expected{ "[INFO]: plain", "[INFO]: ends with a break\n", "raw\n", "partial" };
+    CheckTrue(log.GetLines() == expected, "Formatted lines should lose only their line ending; raw ones should be kept as given");
+    CheckTrue(crlfLog.GetLines() == std::vector<std::string>{ "[INFO]: first\r\n    | second", "raw\r\n" },
+        "A CRLF ending should be left off, and the line breaks inside the line kept");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_MaxBytes_CutsALineThatAloneIsTooLong()
+{
+    // Arrange: 20 bytes, so the line "[INFO]: abcde" + a 2-byte UTF-8 character + more is cut inside that character;
+    // and 4 bytes, too few for the marker
+    ASWLog::TASWMemoryLog log;
+    ASWLog::TASWMemoryLog tinyLog;
+    CheckTrue(log.Initialize(MakeMemoryConfig(1000, 20)), "Initialize should succeed");
+    CheckTrue(tinyLog.Initialize(MakeMemoryConfig(1000, 4)), "Initialize should succeed (tiny)");
+    log.LogInfo("first");
+
+    // Act
+    log.LogInfo("abcde\xCE\xBBxxxxxxxxxxxxxxxxxxxx");
+    tinyLog.LogInfo("hello");
+
+    // Assert
+    CheckTrue(log.GetLines() == std::vector<std::string>{ "[INFO]: abcde [cut]" },
+        "The line should be cut between UTF-8 characters, marked, and the older line dropped");
+    CheckTrue(tinyLog.GetLines() == std::vector<std::string>{ "[INF" }, "Without room for the marker, the line should only be cut");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_MaxBytes_DropsTheOldestLines()
+{
+    // Arrange: 30 bytes, two 15-byte lines
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeMemoryConfig(1000, 30)), "Initialize should succeed");
+
+    // Act
+    log.LogInfo("1111111");
+    log.LogInfo("2222222");
+    const auto atTheLimit = log.GetLines();
+    log.LogInfo("3333333");
+
+    // Assert
+    CheckTrue(atTheLimit == std::vector<std::string>{ "[INFO]: 1111111", "[INFO]: 2222222" }, "Lines that fit exactly should all be kept");
+    CheckTrue(log.GetLines() == std::vector<std::string>{ "[INFO]: 2222222", "[INFO]: 3333333" }, "The oldest line should go to make room");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_MaxLines_KeepsTheNewest()
+{
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeMemoryConfig(3)), "Initialize should succeed");
+
+    // Act
+    for (int index = 1; index <= 5; ++index)
+        log.LogInfo(std::format("line {}", index));
+
+    // Assert
+    CheckEquals(3, log.GetLineCount(), "At most MaxLines lines should be kept");
+    CheckTrue(log.GetLines() == std::vector<std::string>{ "[INFO]: line 3", "[INFO]: line 4", "[INFO]: line 5" },
+        "The newest lines should be kept, oldest first");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_Reconfigure_AppliesTheNewLimits()
+{
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeMemoryConfig(10)), "Initialize should succeed");
+    for (int index = 1; index <= 5; ++index)
+        log.LogInfo(std::format("line {}", index));
+
+    // Act
+    const bool fewerLines = log.Reconfigure(MakeMemoryConfig(3));
+    const auto afterFewerLines = log.GetLines();
+    const bool fewerBytes = log.Reconfigure(MakeMemoryConfig(3, 30));
+    const auto afterFewerBytes = log.GetLines();
+    const bool unlimited = log.Reconfigure(MakeMemoryConfig(0, 0));
+    for (int index = 6; index <= 9; ++index)
+        log.LogInfo(std::format("line {}", index));
+
+    // Assert
+    CheckTrue(fewerLines && fewerBytes && unlimited, "Reconfigure should succeed");
+    CheckTrue(afterFewerLines == std::vector<std::string>{ "[INFO]: line 3", "[INFO]: line 4", "[INFO]: line 5" },
+        "A smaller MaxLines should keep the newest lines");
+    CheckTrue(afterFewerBytes == std::vector<std::string>{ "[INFO]: line 4", "[INFO]: line 5" }, "A smaller MaxBytes should keep the newest lines");
+    CheckEquals(6, log.GetLineCount(), "With no limits, every new line should be kept");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_MemoryLog::Test_Threads_ReaderGetsEveryLineOnce()
+{
+    // Arrange: four threads log while another reads the new lines as they come (for ThreadSanitizer)
+    constexpr int ThreadCount = 4;
+    constexpr int EntryCount = 250;
+    constexpr std::size_t Total = ThreadCount * EntryCount;
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeMemoryConfig(0)), "Initialize should succeed");
+    std::set<std::string> seen;
+    std::uint64_t missedCount = 0;
+    std::size_t readCount = 0;
+
+    // Act
+    std::thread reader([&] {
+        std::uint64_t next = 1;
+        const auto deadline = std::chrono::steady_clock::now() + WaitTimeout;
+        while (readCount < Total && std::chrono::steady_clock::now() < deadline)
+        {
+            const auto newLines = log.GetLinesSince(next);
+            missedCount += newLines.MissedCount;
+            readCount += newLines.Lines.size();
+            seen.insert(newLines.Lines.begin(), newLines.Lines.end());
+            next = newLines.NextSequence;
+            std::this_thread::yield();
+        }
+            });
+
+    std::vector<std::thread> writers;
+    for (int threadIndex = 0; threadIndex < ThreadCount; ++threadIndex)
+    {
+        writers.emplace_back([&log, threadIndex] {
+                for (int index = 0; index < EntryCount; ++index)
+                    log.LogInfo(std::format("{} {}", threadIndex, index));
+            });
+    }
+
+    for (auto& writer : writers)
+        writer.join();
+
+    reader.join();
+
+    // Assert
+    CheckEquals(Total, readCount, "The reader should get every line");
+    CheckEquals(Total, seen.size(), "The reader should get each line once");
+    CheckEquals(0, missedCount, "Nothing should be missed without limits");
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_MemoryLog)
diff --git a/tests/tests/Test_ASWLog_MemoryLog.h b/tests/tests/Test_ASWLog_MemoryLog.h
new file mode 100644
index 0000000..dea6a02
--- /dev/null
+++ b/tests/tests/Test_ASWLog_MemoryLog.h
@@ -0,0 +1,65 @@
+/* **************************************************************************
+Test_ASWLog_MemoryLog.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_MemoryLogH
+#define Test_ASWLog_MemoryLogH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_MemoryLog
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_MemoryLog : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_Async_KeepsTheQueuedLines();
+    void Test_Clear_ForgetsTheLinesButNotTheSequence();
+    void Test_Close_KeepsTheLines();
+    void Test_GetLinesSince_ReturnsNewLinesAndCountsMissedOnes();
+    void Test_KeepsLinesWithoutTheirEnding();
+    void Test_MaxBytes_CutsALineThatAloneIsTooLong();
+    void Test_MaxBytes_DropsTheOldestLines();
+    void Test_MaxLines_KeepsTheNewest();
+    void Test_Reconfigure_AppliesTheNewLimits();
+    void Test_Threads_ReaderGetsEveryLineOnce();
+
+public:
+    TTest_ASWLog_MemoryLog();
+    ~TTest_ASWLog_MemoryLog() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_MemoryLogH
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index 935bd6f..b628722 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -224,6 +224,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Interface.h</DependentOn>
             <BuildOrder>6</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_MemoryLog.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_MemoryLog.h</DependentOn>
+            <BuildOrder>54</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_MultiLog.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>7</BuildOrder>
@@ -280,6 +284,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_Formatter.h</DependentOn>
             <BuildOrder>37</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_MemoryLog.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_MemoryLog.h</DependentOn>
+            <BuildOrder>55</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_MultiLog.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_MultiLog.h</DependentOn>
             <BuildOrder>31</BuildOrder>

From 4574faca7ba0ddc39501c1f17434447670fff284 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 08:31:46 -0700
Subject: [PATCH 15/38] Add TASWDebuggerLog for OutputDebugString

---
 ASWLog/ASWLog_DebuggerLog.cpp                 | 154 ++++++++
 ASWLog/ASWLog_DebuggerLog.h                   |  93 +++++
 ASWLog/ASWLog_Utils.cpp                       |  20 ++
 ASWLog/ASWLog_Utils.h                         |  10 +
 CHANGELOG.md                                  |   8 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 README.md                                     |   2 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_DebuggerLog.cpp       | 339 ++++++++++++++++++
 tests/tests/Test_ASWLog_DebuggerLog.h         |  59 +++
 tests/tests/Test_ASWLog_Utils.cpp             |  24 ++
 tests/tests/Test_ASWLog_Utils.h               |   1 +
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 16 files changed, 737 insertions(+)
 create mode 100644 ASWLog/ASWLog_DebuggerLog.cpp
 create mode 100644 ASWLog/ASWLog_DebuggerLog.h
 create mode 100644 tests/tests/Test_ASWLog_DebuggerLog.cpp
 create mode 100644 tests/tests/Test_ASWLog_DebuggerLog.h

diff --git a/ASWLog/ASWLog_DebuggerLog.cpp b/ASWLog/ASWLog_DebuggerLog.cpp
new file mode 100644
index 0000000..3c7fa26
--- /dev/null
+++ b/ASWLog/ASWLog_DebuggerLog.cpp
@@ -0,0 +1,154 @@
+/* **************************************************************************
+ASWLog_DebuggerLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_DebuggerLog.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstdlib>
+#include <string>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+//---------------------------------------------------------------------------
+#include "ASWLog_CrashHandler.h"
+#include "ASWLog_Utils.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+namespace
+{
+
+// The platform has a debugger output to write to
+#if defined(_WIN32)
+constexpr bool HasDebuggerOutput = true;
+#else
+constexpr bool HasDebuggerOutput = false;
+#endif
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWDebuggerLog
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWDebuggerLog::~TASWDebuggerLog()
+{
+    Finalize();
+}
+
+//---------------------------------------------------------------------------
+bool TASWDebuggerLog::CloseUnlocked()
+{
+    m_IsOpen.store(false);
+    m_IsInitialized.store(false);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWDebuggerLog::FlushUnlocked()
+{
+    return m_IsOpen.load();
+}
+
+//---------------------------------------------------------------------------
+TASWDebuggerLog& TASWDebuggerLog::GetInstance()
+{
+    // Never deleted, so the instance stays usable through static destruction. It is only finalized at exit, by a
+    // handler registered right after it is created, which runs where a static instance's destructor would have run.
+    static TASWDebuggerLog* const instance = new TASWDebuggerLog();
+    [[maybe_unused]] static const int atExitResult = std::atexit([] {
+            instance->Finalize();
+        });
+    return *instance;
+}
+
+//---------------------------------------------------------------------------
+bool TASWDebuggerLog::InitializeUnlocked()
+{
+    return OpenUnlocked();
+}
+
+//---------------------------------------------------------------------------
+bool TASWDebuggerLog::OpenUnlocked()
+{
+    m_IsOpen.store(true);
+    m_IsInitialized.store(true);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWDebuggerLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point /*now*/)
+{
+    // Before the line is formatted, so nothing is formatted where it would be dropped
+    return HasDebuggerOutput;
+}
+
+//---------------------------------------------------------------------------
+bool TASWDebuggerLog::ShouldLog(Level level) const noexcept
+{
+    return HasDebuggerOutput && inherited::ShouldLog(level);
+}
+
+//---------------------------------------------------------------------------
+bool TASWDebuggerLog::ShouldLog(const TASWLogRecord& record) const noexcept
+{
+    return HasDebuggerOutput && inherited::ShouldLog(record);
+}
+
+//---------------------------------------------------------------------------
+void TASWDebuggerLog::WriteCrashLineDirect(std::string_view line) noexcept
+{
+#if defined(_WIN32)
+    // Converted in a buffer on the stack, since the heap may be damaged in a crash
+    wchar_t wide[Detail::TCrashText::Capacity + 1];
+    const int size = static_cast<int>(line.size() < Detail::TCrashText::Capacity ? line.size() : Detail::TCrashText::Capacity);
+    const int wideSize = size > 0 ? MultiByteToWideChar(CP_UTF8, 0, line.data(), size, wide, static_cast<int>(Detail::TCrashText::Capacity)) : 0;
+    wide[wideSize > 0 ? wideSize : 0] = L'\0';
+    OutputDebugStringW(wide);
+#else
+    static_cast<void>(line);
+#endif
+}
+
+//---------------------------------------------------------------------------
+void TASWDebuggerLog::WriteLineUnlocked(Level /*level*/, std::string_view line, bool /*endsLine*/)
+{
+#if defined(_WIN32)
+    OutputDebugStringW(Detail::UTF8ToWideString(line).c_str());
+#else
+    static_cast<void>(line);
+#endif
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_DebuggerLog.h b/ASWLog/ASWLog_DebuggerLog.h
new file mode 100644
index 0000000..5c5c6e6
--- /dev/null
+++ b/ASWLog/ASWLog_DebuggerLog.h
@@ -0,0 +1,93 @@
+/* **************************************************************************
+ASWLog_DebuggerLog.h
+Author: Anthony S. West - ASW Software
+
+A light-weight logging tool.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_DebuggerLogH
+#define ASWLog_DebuggerLogH
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <string_view>
+//---------------------------------------------------------------------------
+#include "ASWLog_TextLogBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWDebuggerLog
+//
+// Writes each line to the debugger's output: on Windows with OutputDebugStringW, so it shows in the RAD Studio Event
+// Log, Visual Studio's Output window, and DebugView (which needs no debugger). With nobody listening, each line still
+// costs some microseconds, so add it where it's wanted, e.g. in debug builds. Each line is formatted like a file
+// logger's (TASWLogConfig::Line), including its line ending; the text is converted from UTF-8 to UTF-16.
+//
+// Other platforms have no debugger output, so there it writes nothing: the class builds everywhere, so the same code
+// can add it on every platform, but there ShouldLog() is false and no line is formatted. (On Linux, see the syslog
+// logger.)
+//
+// Takes the same TASWLogConfig as the other text loggers, ignoring its File settings. Thread-safe.
+/////////////////////////////////////////////////////////////////////////////
+class TASWDebuggerLog : public TASWTextLogBase
+{
+private:
+    typedef TASWTextLogBase inherited;
+
+protected: // TASWTextLogBase hooks
+    bool CloseUnlocked() override;
+    bool FlushUnlocked() override; // Nothing is buffered: true while open
+    bool InitializeUnlocked() override;
+    bool OpenUnlocked() override;
+    bool PrepareWriteUnlocked(std::chrono::system_clock::time_point now) override; // False where it writes nothing
+    void WriteCrashLineDirect(std::string_view line) noexcept override;
+    void WriteLineUnlocked(Level level, std::string_view line, bool endsLine) override;
+
+protected:
+    std::string_view GetLoggerClassName() const noexcept override
+    {
+        return "TASWDebuggerLog";
+    }
+
+public: // Static methods
+    // Singleton support for the common static instance. Never destroyed; finalized at exit in static destruction
+    // order, like TASWFileLog::GetInstance() (see there).
+    static TASWDebuggerLog& GetInstance();
+
+public:
+    TASWDebuggerLog() = default;
+    // Writes the shutdown line (see TASWTextLogBase::Finalize())
+    ~TASWDebuggerLog() override;
+
+    TASWDebuggerLog(const TASWDebuggerLog&) = delete;
+    TASWDebuggerLog& operator=(const TASWDebuggerLog&) = delete;
+
+    // As for the other loggers on Windows; always false where it writes nothing
+    bool ShouldLog(Level level) const noexcept override;
+    bool ShouldLog(const TASWLogRecord& record) const noexcept override;
+};
+
+} // namespace ASWLog
+
+#endif // #ifndef ASWLog_DebuggerLogH
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index d07828d..8d1647c 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -29,6 +29,7 @@ limitations under the License.
 #include <cerrno>
 #include <charconv>
 #include <chrono>
+#include <climits>
 #include <cstring>
 #include <ctime>
 #include <filesystem>
@@ -911,6 +912,25 @@ TMultilinePiece NextMultilinePiece(std::string_view text, std::size_t& index, Mu
     return TMultilinePiece{ isNextLineEmpty ? indented.substr(0, indented.size() - 1) : indented, true };
 }
 
+#if defined(_WIN32)
+//---------------------------------------------------------------------------
+std::wstring UTF8ToWideString(std::string_view text)
+{
+    // MultiByteToWideChar takes an int length; a longer text is cut (no log line is that long)
+    const int size = text.size() > static_cast<std::size_t>(INT_MAX) ? INT_MAX : static_cast<int>(text.size());
+
+    // Without MB_ERR_INVALID_CHARS, invalid sequences become U+FFFD
+    const int wideSize = size > 0 ? MultiByteToWideChar(CP_UTF8, 0, text.data(), size, nullptr, 0) : 0;
+    if (wideSize <= 0)
+        return {};
+
+    std::wstring wide(static_cast<std::size_t>(wideSize), L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, text.data(), size, wide.data(), wideSize);
+
+    return wide;
+}
+#endif
+
 } // namespace Detail
 
 //---------------------------------------------------------------------------
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index c6fcd9b..b81c7e5 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -184,6 +184,16 @@ void ApplyMultilineMode(std::string& line, MultilineMode mode, LineEnding ending
 [[nodiscard]] TMultilinePiece NextMultilinePiece(std::string_view text, std::size_t& index, MultilineMode mode,
     LineEnding ending) noexcept;
 
+#if defined(_WIN32)
+/*
+    UTF8ToWideString
+
+    'text' (UTF-8) as UTF-16, for the Windows API's wide functions. Each invalid UTF-8 sequence becomes U+FFFD. Throws
+    std::bad_alloc if the result can't be made.
+*/
+[[nodiscard]] std::wstring UTF8ToWideString(std::string_view text);
+#endif
+
 } // namespace Detail
 
 namespace JSON
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f0106ca..3af3352 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -154,6 +154,14 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   (every kept line gets the next sequence number), with the number to ask
   for next and how many lines were missed, so a viewer can poll for new
   lines.
+- `TASWDebuggerLog` (new `ASWLog_DebuggerLog.h`): writes each line to the
+  debugger's output with `OutputDebugStringW` on Windows, shown in the RAD
+  Studio Event Log, Visual Studio's Output window and DebugView (even
+  without a debugger; each line then still costs some microseconds, so add
+  it where wanted, e.g. in debug builds). `TASWDebuggerLog::GetInstance()`
+  gives the shared one. Other platforms have no debugger output: there the
+  class builds but writes nothing (`ShouldLog()` is false and no line is
+  formatted), so the same code can add it everywhere.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02667b4..e16a0fc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -28,6 +28,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_ConsoleLog.h
     ASWLog/ASWLog_CrashHandler.cpp
     ASWLog/ASWLog_CrashHandler.h
+    ASWLog/ASWLog_DebuggerLog.cpp
+    ASWLog/ASWLog_DebuggerLog.h
     ASWLog/ASWLog_Fields.cpp
     ASWLog/ASWLog_Fields.h
     ASWLog/ASWLog_FileLog.cpp
diff --git a/Deploy.bat b/Deploy.bat
index 85afe81..a0ec0b9 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -84,6 +84,10 @@ call :CopyFile "ASWLog\ASWLog_CrashHandler.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Cras
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_CrashHandler.h" "%TARGET_DIR%\ASWLog\ASWLog_CrashHandler.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_DebuggerLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_DebuggerLog.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_DebuggerLog.h" "%TARGET_DIR%\ASWLog\ASWLog_DebuggerLog.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Fields.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Fields.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Fields.h" "%TARGET_DIR%\ASWLog\ASWLog_Fields.h"
diff --git a/README.md b/README.md
index e954f86..63fa685 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   or drop noisy entries by content, category or field.
 - Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
   entry on the thread carries, e.g. `ASWLog::TASWLogScope scope{{"requestId", id}};` (`ASWLog_Fields.h`).
+- A debugger output logger (`ASWLog::TASWDebuggerLog`) for the RAD Studio Event Log, Visual Studio's Output window and
+  DebugView (Windows; it writes nothing elsewhere).
 - A memory logger (`ASWLog::TASWMemoryLog`) that keeps the newest lines, limited by count and size
   (`TASWLogConfig::Memory`), for an in-app log viewer (`GetLinesSince()` returns only the new ones), a crash report or
   tests.
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index f582c2d..e925baa 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -155,6 +155,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>13</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_DebuggerLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_DebuggerLog.h</DependentOn>
+            <BuildOrder>18</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_Fields.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_Fields.h</DependentOn>
             <BuildOrder>15</BuildOrder>
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index e2c3492..ba4ac17 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -37,6 +37,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Config.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_ConsoleLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_CrashHandler.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_DebuggerLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Fields.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_FileLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Formatter.cpp"
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index b0dcc05..d358f2d 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -170,6 +170,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>33</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_DebuggerLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_DebuggerLog.h</DependentOn>
+            <BuildOrder>45</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_Fields.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_Fields.h</DependentOn>
             <BuildOrder>39</BuildOrder>
@@ -238,6 +242,10 @@
             <DependentOn>..\tests\Test_ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>34</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_DebuggerLog.cpp">
+            <DependentOn>..\tests\Test_ASWLog_DebuggerLog.h</DependentOn>
+            <BuildOrder>46</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_Fields.cpp">
             <DependentOn>..\tests\Test_ASWLog_Fields.h</DependentOn>
             <BuildOrder>40</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_DebuggerLog.cpp b/tests/tests/Test_ASWLog_DebuggerLog.cpp
new file mode 100644
index 0000000..c91ec50
--- /dev/null
+++ b/tests/tests/Test_ASWLog_DebuggerLog.cpp
@@ -0,0 +1,339 @@
+/* **************************************************************************
+Test_ASWLog_DebuggerLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_DebuggerLog.h"
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <cstring>
+#include <format>
+#include <initializer_list>
+#include <optional>
+#include <string>
+#include <string_view>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_CrashHandler.h"
+#include "ASWLog_DebuggerLog.h"
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+// A value whose formatting is counted in DebuggerLogFormatCount, to check whether a *Fmt call formats
+struct TDebuggerLogCountedValue
+{
+};
+
+int DebuggerLogFormatCount = 0;
+
+} // namespace
+
+template<>
+struct std::formatter<TDebuggerLogCountedValue>
+{
+    constexpr std::format_parse_context::iterator parse(std::format_parse_context& context)
+    {
+        return context.begin();
+    }
+
+    std::format_context::iterator format(const TDebuggerLogCountedValue& /*value*/, std::format_context& context) const
+    {
+        ++DebuggerLogFormatCount;
+        return std::format_to(context.out(), "counted");
+    }
+};
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+// A config with no startup or shutdown lines and only the level in each line, e.g. "[INFO]: message\n"
+ASWLog::TASWLogConfig MakeDebuggerConfig()
+{
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Info;
+    config.Line.ShowTimestamp = false;
+    config.Line.ShowProcessId = false;
+    config.Line.ShowThreadId = false;
+    config.Shutdown.WriteLine = false;
+    config.Startup.WriteTimeInfo = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    return config;
+}
+
+#if defined(_WIN32)
+// A debugger logger whose crash write a test can call
+class TCrashTestDebuggerLog final : public ASWLog::TASWDebuggerLog
+{
+public:
+    void WriteCrashLine(std::string_view line) noexcept
+    {
+        WriteCrashLineDirect(line);
+    }
+};
+
+// Receives what OutputDebugString sends while no debugger is attached, as DebugView does: a writer waits for the
+// DBWIN_BUFFER_READY event, puts its process id and the text (in the ANSI code page) in the DBWIN_BUFFER shared memory,
+// and sets DBWIN_DATA_READY. Only one listener can have these at a time.
+class TDebugOutputListener
+{
+private:
+    static constexpr DWORD BufferSize = 4096;
+
+    HANDLE m_BufferReady = nullptr;
+    HANDLE m_DataReady = nullptr;
+    HANDLE m_Mapping = nullptr;
+    const char* m_View = nullptr;
+    bool m_IsListening = false;
+
+public:
+    TDebugOutputListener()
+    {
+        m_BufferReady = CreateEventW(nullptr, FALSE, FALSE, L"DBWIN_BUFFER_READY");
+        bool isTaken = GetLastError() == ERROR_ALREADY_EXISTS;
+        m_DataReady = CreateEventW(nullptr, FALSE, FALSE, L"DBWIN_DATA_READY");
+        isTaken = isTaken || GetLastError() == ERROR_ALREADY_EXISTS;
+        m_Mapping = CreateFileMappingW(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, BufferSize, L"DBWIN_BUFFER");
+        isTaken = isTaken || GetLastError() == ERROR_ALREADY_EXISTS;
+
+        if (m_Mapping != nullptr)
+            m_View = static_cast<const char*>(MapViewOfFile(m_Mapping, FILE_MAP_READ, 0, 0, BufferSize));
+
+        m_IsListening = !isTaken && m_BufferReady != nullptr && m_DataReady != nullptr && m_View != nullptr;
+    }
+
+    ~TDebugOutputListener()
+    {
+        if (m_View != nullptr)
+            UnmapViewOfFile(m_View);
+
+        for (const HANDLE handle : { m_Mapping, m_DataReady, m_BufferReady })
+        {
+            if (handle != nullptr)
+                CloseHandle(handle);
+        }
+    }
+
+    TDebugOutputListener(const TDebugOutputListener&) = delete;
+    TDebugOutputListener& operator=(const TDebugOutputListener&) = delete;
+
+    // False if another listener (e.g. DebugView) has the shared objects
+    bool IsListening() const
+    {
+        return m_IsListening;
+    }
+
+    // Runs 'write', which sends one string, and returns the text this process sent, or nothing if none came within
+    // a second. Strings from other processes (which may write too) are skipped.
+    template<typename TWrite>
+    std::optional<std::string> Capture(const TWrite& write)
+    {
+        SetEvent(m_BufferReady);
+        write();
+
+        const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(1);
+        while (std::chrono::steady_clock::now() < deadline)
+        {
+            if (WaitForSingleObject(m_DataReady, 100) != WAIT_OBJECT_0)
+                continue;
+
+            DWORD processId = 0;
+            std::memcpy(&processId, m_View, sizeof(processId));
+            const std::string_view text(m_View + sizeof(processId), BufferSize - sizeof(processId));
+
+            if (processId == GetCurrentProcessId())
+                return std::string(text.substr(0, text.find('\0')));
+
+            SetEvent(m_BufferReady); // Another process's string: wait for ours
+        }
+
+        return std::nullopt;
+    }
+};
+
+#endif
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_DebuggerLog
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_DebuggerLog::TTest_ASWLog_DebuggerLog()
+    : inherited("ASWLog_DebuggerLog_Tests")
+{
+    RegisterTest(&TTest_ASWLog_DebuggerLog::Test_GetInstance_ReturnsTheSameLogger, "GetInstance_ReturnsTheSameLogger");
+    RegisterTest(&TTest_ASWLog_DebuggerLog::Test_ShouldLog_FollowsThePlatform, "ShouldLog_FollowsThePlatform");
+    RegisterTest(&TTest_ASWLog_DebuggerLog::Test_Windows_SendsEachLineToTheDebugOutput, "Windows_SendsEachLineToTheDebugOutput");
+    RegisterTest(&TTest_ASWLog_DebuggerLog::Test_Windows_WritesTheCrashLineDirectly, "Windows_WritesTheCrashLineDirectly");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_DebuggerLog::~TTest_ASWLog_DebuggerLog()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::SetUp_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::SetUp_Test(ITestCase& /*testCase*/)
+{
+    DebuggerLogFormatCount = 0;
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::TearDown_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::TearDown_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::Test_GetInstance_ReturnsTheSameLogger()
+{
+    // Act
+    auto& first = ASWLog::TASWDebuggerLog::GetInstance();
+    auto& second = ASWLog::TASWDebuggerLog::GetInstance();
+
+    // Assert
+    CheckSame(&first, &second, "GetInstance() should always return the same logger");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::Test_ShouldLog_FollowsThePlatform()
+{
+    // Arrange
+    ASWLog::TASWDebuggerLog log;
+    const bool initialized = log.Initialize(MakeDebuggerConfig());
+    ASWLog::TASWLogRecord infoRecord;
+    infoRecord.LogLevel = ASWLog::Level::Info;
+
+    // Act
+    log.LogInfoFmt("{}", TDebuggerLogCountedValue{});
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed on every platform");
+#if defined(_WIN32)
+    CheckTrue(log.ShouldLog(ASWLog::Level::Info), "On Windows, ShouldLog() should follow the minimum level (Info)");
+    CheckFalse(log.ShouldLog(ASWLog::Level::Debug), "On Windows, ShouldLog() should follow the minimum level (Debug)");
+    CheckTrue(log.ShouldLog(infoRecord), "On Windows, ShouldLog(record) should follow the minimum level");
+    CheckEquals(1, DebuggerLogFormatCount, "On Windows, a *Fmt entry should be formatted");
+#else
+    CheckFalse(log.ShouldLog(ASWLog::Level::Critical), "Without a debugger output, ShouldLog() should be false");
+    CheckFalse(log.ShouldLog(infoRecord), "Without a debugger output, ShouldLog(record) should be false");
+    CheckEquals(0, DebuggerLogFormatCount, "Without a debugger output, nothing should be formatted");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::Test_Windows_SendsEachLineToTheDebugOutput()
+{
+#if defined(_WIN32)
+    // Arrange: listen like DebugView, which needs no debugger attached and no other listener
+    if (IsDebuggerPresent())
+        Skip("A debugger receives the debug output instead of a listener");
+
+    TDebugOutputListener listener;
+    if (!listener.IsListening())
+        Skip("Another debug output listener (e.g. DebugView) is running");
+
+    ASWLog::TASWDebuggerLog log;
+    CheckTrue(log.Initialize(MakeDebuggerConfig()), "Initialize should succeed");
+    auto crlfConfig = MakeDebuggerConfig();
+    crlfConfig.Line.Ending = ASWLog::LineEnding::CRLF;
+
+    // Act
+    const auto formatted = listener.Capture([&log] {
+            log.LogInfo("hello");
+        });
+    const auto raw = listener.Capture([&log] {
+            log.LogRaw(ASWLog::Level::Warn, "raw text");
+        });
+    const bool reconfigured = log.Reconfigure(crlfConfig);
+    const auto crlf = listener.Capture([&log] {
+            log.LogError("crlf");
+        });
+
+    // Assert
+    CheckTrue(reconfigured, "Reconfigure should succeed");
+    CheckTrue(formatted == std::string("[INFO]: hello\n"), "The formatted line, with its ending, should be sent: " + formatted.value_or("(none)"));
+    CheckTrue(raw == std::string("raw text"), "A raw entry should be sent as is: " + raw.value_or("(none)"));
+    CheckTrue(crlf == std::string("[ERROR]: crlf\r\n"), "The line should end with the configured ending: " + crlf.value_or("(none)"));
+#else
+    Skip("Only Windows has a debugger output");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_DebuggerLog::Test_Windows_WritesTheCrashLineDirectly()
+{
+#if defined(_WIN32)
+    // Arrange
+    if (IsDebuggerPresent())
+        Skip("A debugger receives the debug output instead of a listener");
+
+    TDebugOutputListener listener;
+    if (!listener.IsListening())
+        Skip("Another debug output listener (e.g. DebugView) is running");
+
+    TCrashTestDebuggerLog log;
+    const std::string longLine(ASWLog::Detail::TCrashText::Capacity + 500, 'x');
+
+    // Act
+    const auto crashLine = listener.Capture([&log] {
+            log.WriteCrashLine("[CRITICAL]: Crash: test\n");
+        });
+    const auto cutLine = listener.Capture([&log, &longLine] {
+            log.WriteCrashLine(longLine);
+        });
+
+    // Assert
+    CheckTrue(crashLine == std::string("[CRITICAL]: Crash: test\n"), "The crash line should be sent as is: " + crashLine.value_or("(none)"));
+    AssertTrue(cutLine.has_value(), "A line longer than a crash line can be should still be sent");
+    CheckEquals(ASWLog::Detail::TCrashText::Capacity, cutLine->size(), "It should be cut to a crash line's capacity");
+#else
+    Skip("Only Windows has a debugger output");
+#endif
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_DebuggerLog)
diff --git a/tests/tests/Test_ASWLog_DebuggerLog.h b/tests/tests/Test_ASWLog_DebuggerLog.h
new file mode 100644
index 0000000..cc6d992
--- /dev/null
+++ b/tests/tests/Test_ASWLog_DebuggerLog.h
@@ -0,0 +1,59 @@
+/* **************************************************************************
+Test_ASWLog_DebuggerLog.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_DebuggerLogH
+#define Test_ASWLog_DebuggerLogH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_DebuggerLog
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_DebuggerLog : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_GetInstance_ReturnsTheSameLogger();
+    void Test_ShouldLog_FollowsThePlatform();
+    void Test_Windows_SendsEachLineToTheDebugOutput();
+    void Test_Windows_WritesTheCrashLineDirectly();
+
+public:
+    TTest_ASWLog_DebuggerLog();
+    ~TTest_ASWLog_DebuggerLog() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_DebuggerLogH
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index ca03a37..4db7397 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -130,6 +130,7 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_CalendarEdges, "Time_WriteISO8601_CalendarEdges");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_LocalTimeWithEachPrecision, "Time_WriteISO8601_LocalTimeWithEachPrecision");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision, "Time_WriteISO8601_UTCWithEachPrecision");
+    RegisterTest(&TTest_ASWLog_Utils::Test_UTF8ToWideString_ConvertsToUTF16, "UTF8ToWideString_ConvertsToUTF16");
 }
 //---------------------------------------------------------------------------
 TTest_ASWLog_Utils::~TTest_ASWLog_Utils()
@@ -818,6 +819,29 @@ void TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision()
     }
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_UTF8ToWideString_ConvertsToUTF16()
+{
+#if defined(_WIN32)
+    // Arrange: ASCII, a 2-byte and a 4-byte character (a surrogate pair in UTF-16), and an invalid byte
+    struct TCase
+    {
+        std::string Text;
+        std::wstring Expected;
+    };
+
+    const std::vector<TCase> cases{
+        { "", L"" }, { "plain text\n", L"plain text\n" }, { "a\xCE\xBB" "b", L"a\x03BB" L"b" },
+        { "\xF0\x9F\x98\x80", L"\xD83D\xDE00" }, { "x\xFFy", L"x\xFFFDy" }
+    };
+
+    // Act & Assert
+    for (const auto& item : cases)
+        CheckTrue(ASWLog::Detail::UTF8ToWideString(item.Text) == item.Expected, "UTF-8 should become UTF-16: " + ToHex(item.Text));
+#else
+    Skip("UTF8ToWideString() exists only on Windows");
+#endif
+}
+//---------------------------------------------------------------------------
 
 } // namespace ASWUnitTests
 
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index 10ef84e..1a9a560 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -63,6 +63,7 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_Time_WriteISO8601_CalendarEdges();
     void Test_Time_WriteISO8601_LocalTimeWithEachPrecision();
     void Test_Time_WriteISO8601_UTCWithEachPrecision();
+    void Test_UTF8ToWideString_ConvertsToUTF16();
 
 public:
     TTest_ASWLog_Utils();
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index b628722..9fff869 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -208,6 +208,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>42</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_DebuggerLog.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_DebuggerLog.h</DependentOn>
+            <BuildOrder>56</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_Fields.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Fields.h</DependentOn>
             <BuildOrder>50</BuildOrder>
@@ -272,6 +276,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_CrashHandler.h</DependentOn>
             <BuildOrder>43</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_DebuggerLog.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_DebuggerLog.h</DependentOn>
+            <BuildOrder>57</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_Fields.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_Fields.h</DependentOn>
             <BuildOrder>51</BuildOrder>

From 763efb7a75b7addf3375909aec94b1842d6da382 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 08:31:59 -0700
Subject: [PATCH 16/38] Add TASWSyslogLog sink for Linux syslog

---
 ASWLog/ASWLog_Config.h                        |  16 +
 ASWLog/ASWLog_SyslogLog.cpp                   | 269 +++++++++++
 ASWLog/ASWLog_SyslogLog.h                     | 125 +++++
 ASWLog/ASWLog_Types.cpp                       |  13 +
 ASWLog/ASWLog_Types.h                         |  58 +++
 CHANGELOG.md                                  |  13 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 README.md                                     |   2 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_SyslogLog.cpp         | 447 ++++++++++++++++++
 tests/tests/Test_ASWLog_SyslogLog.h           |  63 +++
 tests/tests/Test_ASWLog_Types.cpp             |  33 ++
 tests/tests/Test_ASWLog_Types.h               |   2 +
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 17 files changed, 1068 insertions(+)
 create mode 100644 ASWLog/ASWLog_SyslogLog.cpp
 create mode 100644 ASWLog/ASWLog_SyslogLog.h
 create mode 100644 tests/tests/Test_ASWLog_SyslogLog.cpp
 create mode 100644 tests/tests/Test_ASWLog_SyslogLog.h

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 0dfc90c..94b99ea 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -294,6 +294,21 @@ struct TASWStartupConfig
 };
 
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWSyslogConfig
+//
+// How a TASWSyslogLog sends its entries to syslog (TASWLogConfig::Syslog).
+/////////////////////////////////////////////////////////////////////////////
+struct TASWSyslogConfig
+{
+    // The name syslog shows for each message, e.g. "myapp" in "myapp[1234]: ...". Empty: the executable's file name.
+    // Process-wide: the syslog logger initialized or reconfigured last sets it, and the application's own openlog()
+    // call replaces it (see TASWSyslogLog).
+    std::string Ident;
+    SyslogFacility Facility = SyslogFacility::User; // Sent with each message, so each syslog logger can have its own
+};
+
+
 /////////////////////////////////////////////////////////////////////////////
 // TASWLogConfig
 //
@@ -315,6 +330,7 @@ struct TASWLogConfig
     TASWAsyncConfig Async;
     TASWBacktraceConfig Backtrace;
     TASWMemoryConfig Memory;
+    TASWSyslogConfig Syslog;
 
     // --- Pre-write Hook ---
     // A last chance for the application to drop or change each of its entries before the logger writes it, e.g. to
diff --git a/ASWLog/ASWLog_SyslogLog.cpp b/ASWLog/ASWLog_SyslogLog.cpp
new file mode 100644
index 0000000..cce8aca
--- /dev/null
+++ b/ASWLog/ASWLog_SyslogLog.cpp
@@ -0,0 +1,269 @@
+/* **************************************************************************
+ASWLog_SyslogLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_SyslogLog.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstdlib>
+
+#if !defined(_WIN32)
+#include <limits>
+#include <mutex>
+#include <utility>
+
+#include <syslog.h>
+#endif
+//---------------------------------------------------------------------------
+#include "ASWLog_Utils.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+namespace
+{
+
+// The platform has a syslog to send to
+#if defined(_WIN32)
+constexpr bool HasSyslog = false;
+#else
+constexpr bool HasSyslog = true;
+#endif
+
+// The severities of RFC 5424 that the levels map to, the same values as <syslog.h>'s LOG_CRIT to LOG_DEBUG
+constexpr int SeverityCritical = 2;
+constexpr int SeverityError    = 3;
+constexpr int SeverityWarning  = 4;
+constexpr int SeverityInfo     = 6;
+constexpr int SeverityDebug    = 7;
+
+#if !defined(_WIN32)
+static_assert(SeverityCritical == LOG_CRIT && SeverityError == LOG_ERR && SeverityWarning == LOG_WARNING);
+static_assert(SeverityInfo == LOG_INFO && SeverityDebug == LOG_DEBUG);
+static_assert(LOG_USER == static_cast<int>(SyslogFacility::User) << 3);
+static_assert(LOG_DAEMON == static_cast<int>(SyslogFacility::Daemon) << 3);
+static_assert(LOG_LOCAL0 == static_cast<int>(SyslogFacility::Local0) << 3);
+static_assert(LOG_LOCAL7 == static_cast<int>(SyslogFacility::Local7) << 3);
+#endif
+
+//---------------------------------------------------------------------------
+
+int ToSyslogFacility(SyslogFacility facility) noexcept;
+int ToSyslogPriority(Level level, SyslogFacility facility) noexcept;
+
+//---------------------------------------------------------------------------
+
+/*
+  ToSyslogFacility
+
+  The facility as syslog() and openlog() take it, e.g. LOG_USER
+*/
+int ToSyslogFacility(SyslogFacility facility) noexcept
+{
+    return static_cast<int>(facility) << 3;
+}
+
+/*
+  ToSyslogPriority
+
+  The priority syslog() takes for an entry at 'level': the facility and the level's severity combined
+*/
+int ToSyslogPriority(Level level, SyslogFacility facility) noexcept
+{
+    int severity = SeverityDebug; // Trace and Debug (an entry at Off is never written)
+
+    switch (level)
+    {
+        case Level::Info:
+            severity = SeverityInfo;
+            break;
+
+        case Level::Warn:
+            severity = SeverityWarning;
+            break;
+
+        case Level::Error:
+            severity = SeverityError;
+            break;
+
+        case Level::Critical:
+            severity = SeverityCritical;
+            break;
+
+        default:
+            break;
+    }
+
+    return ToSyslogFacility(facility) | severity;
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWSyslogLog
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWSyslogLog::~TASWSyslogLog()
+{
+    Finalize();
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::CloseUnlocked()
+{
+    m_IsOpen.store(false);
+    m_IsInitialized.store(false);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::FlushUnlocked()
+{
+    return m_IsOpen.load();
+}
+
+//---------------------------------------------------------------------------
+TASWSyslogLog& TASWSyslogLog::GetInstance()
+{
+    // Never deleted, so the instance stays usable through static destruction. It is only finalized at exit, by a
+    // handler registered right after it is created, which runs where a static instance's destructor would have run.
+    static TASWSyslogLog* const instance = new TASWSyslogLog();
+    [[maybe_unused]] static const int atExitResult = std::atexit([] {
+            instance->Finalize();
+        });
+    return *instance;
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::InitializeUnlocked()
+{
+    OpenSyslogFromConfigUnlocked();
+
+    return OpenUnlocked();
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::OpenUnlocked()
+{
+    m_IsOpen.store(true);
+    m_IsInitialized.store(true);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+// Calls OpenSyslogUnlocked() with the current config's Syslog settings
+void TASWSyslogLog::OpenSyslogFromConfigUnlocked()
+{
+    const auto& config = GetConfigUnlocked().Syslog;
+    const std::string ident = config.Ident.empty() ? PathToUTF8String(GetExecutablePath().filename()) : config.Ident;
+
+    OpenSyslogUnlocked(ident, config.Facility);
+}
+
+//---------------------------------------------------------------------------
+void TASWSyslogLog::OpenSyslogUnlocked(const std::string& ident, SyslogFacility facility)
+{
+#if defined(_WIN32)
+    static_cast<void>(ident);
+    static_cast<void>(facility);
+#else
+    // openlog() keeps the pointer, so the ident is copied and the copy kept until the next call here replaces it. The C
+    // library uses the ident only while it holds its syslog lock, as openlog() does, so once openlog() has returned
+    // with the new copy, the previous one is no longer used. The current copy and the lock are never destroyed, so
+    // syslog() can still use the ident at exit.
+    static std::mutex* const identMutex = new std::mutex();
+    static std::string* identCopy = nullptr;
+
+    auto* newCopy = new std::string(ident);
+    std::lock_guard<std::mutex> lock(*identMutex);
+    openlog(newCopy->c_str(), LOG_PID, ToSyslogFacility(facility));
+    delete std::exchange(identCopy, newCopy);
+#endif
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point /*now*/)
+{
+    // Before the line is formatted, so nothing is formatted where it would be dropped
+    return HasSyslog;
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::ReconfigureUnlocked(const TASWLogConfig& /*previous*/)
+{
+    OpenSyslogFromConfigUnlocked();
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+void TASWSyslogLog::SendToSyslogUnlocked(int priority, std::string_view message)
+{
+#if defined(_WIN32)
+    static_cast<void>(priority);
+    static_cast<void>(message);
+#else
+    // As "%.*s", so the message isn't read as a format string and needs no terminating null
+    constexpr std::size_t maxSize = static_cast<std::size_t>(std::numeric_limits<int>::max());
+    const int size = static_cast<int>(message.size() < maxSize ? message.size() : maxSize);
+    syslog(priority, "%.*s", size, message.data());
+#endif
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::ShouldLog(Level level) const noexcept
+{
+    return HasSyslog && inherited::ShouldLog(level);
+}
+
+//---------------------------------------------------------------------------
+bool TASWSyslogLog::ShouldLog(const TASWLogRecord& record) const noexcept
+{
+    return HasSyslog && inherited::ShouldLog(record);
+}
+
+//---------------------------------------------------------------------------
+void TASWSyslogLog::WriteLineUnlocked(Level level, std::string_view line, bool endsLine)
+{
+    const auto& config = GetConfigUnlocked();
+
+    // Sent without the line ending the formatted line ends with
+    if (endsLine)
+    {
+        const std::string_view ending = config.Line.Ending == LineEnding::CRLF ? "\r\n" : "\n";
+        if (line.ends_with(ending))
+            line.remove_suffix(ending.size());
+    }
+
+    SendToSyslogUnlocked(ToSyslogPriority(level, config.Syslog.Facility), line);
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_SyslogLog.h b/ASWLog/ASWLog_SyslogLog.h
new file mode 100644
index 0000000..013dec8
--- /dev/null
+++ b/ASWLog/ASWLog_SyslogLog.h
@@ -0,0 +1,125 @@
+/* **************************************************************************
+ASWLog_SyslogLog.h
+Author: Anthony S. West - ASW Software
+
+A light-weight logging tool.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_SyslogLogH
+#define ASWLog_SyslogLogH
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <string>
+#include <string_view>
+//---------------------------------------------------------------------------
+#include "ASWLog_TextLogBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWSyslogLog
+//
+// Sends each line to the system log with syslog() from the C library; on systemd hosts it lands in the journal
+// (journalctl). The level becomes the message's priority: Trace and Debug LOG_DEBUG, Info LOG_INFO, Warn LOG_WARNING,
+// Error LOG_ERR, Critical LOG_CRIT; the facility is TASWLogConfig::Syslog.Facility. Each line is formatted like a file
+// logger's (TASWLogConfig::Line) and sent without its line ending; line breaks inside it are sent as Line.Multiline
+// says (with the default, Preserve, journald keeps them, and rsyslog writes them as #012). ASWLog doesn't limit a
+// message's size, but the syslog daemon may cut a very long one.
+//
+// syslog adds the time, the host, the ident and the process id to each message itself, so the default line repeats
+// two of them. For syslog alone, consider:
+//
+//     config.Line.ShowTimestamp = false;
+//     config.Line.ShowProcessId = false;
+//
+// The timestamp is still worth keeping where the moment of the call matters: syslog's time is when the line is sent,
+// which with TASWLogConfig::Async is a little later, and has less precision in a classic syslog file. A multi-log
+// passes one config to all its loggers, so a syslog logger behind one writes the same layout as the others.
+//
+// Initialize() and Reconfigure() call openlog() with Syslog.Ident (or the executable's file name) and LOG_PID; the
+// logger never calls closelog(). The ident is process-wide, so with several syslog loggers the one initialized or
+// reconfigured last sets it, and the application's own openlog() call replaces it. The facility is sent with each
+// message, so each logger keeps its own.
+//
+// A crash line formatted in normal context (e.g. std::terminate, HandleCrash()) is sent as LOG_CRIT; syslog() isn't
+// async-signal-safe, so nothing is sent from a POSIX signal handler, or if the logger's lock stays busy (see
+// ASWLog_CrashHandler.h).
+//
+// Windows has no syslog, so there it writes nothing: the class builds everywhere, so the same code can add it on every
+// platform, but there ShouldLog() is false and no line is formatted. (On Windows, see the debugger logger.)
+//
+// Takes the same TASWLogConfig as the other text loggers, ignoring its File settings. Thread-safe.
+/////////////////////////////////////////////////////////////////////////////
+class TASWSyslogLog : public TASWTextLogBase
+{
+private:
+    typedef TASWTextLogBase inherited;
+
+private:
+    void OpenSyslogFromConfigUnlocked();
+
+protected: // TASWTextLogBase hooks
+    bool CloseUnlocked() override;
+    bool FlushUnlocked() override; // Nothing is buffered: true while open
+    bool InitializeUnlocked() override;
+    bool OpenUnlocked() override;
+    bool PrepareWriteUnlocked(std::chrono::system_clock::time_point now) override; // False where it writes nothing
+    bool ReconfigureUnlocked(const TASWLogConfig& previous) override;
+    void WriteLineUnlocked(Level level, std::string_view line, bool endsLine) override;
+
+protected:
+    std::string_view GetLoggerClassName() const noexcept override
+    {
+        return "TASWSyslogLog";
+    }
+
+    // Called by Initialize() and Reconfigure() with the ident (Syslog.Ident, or the executable's file name if that is
+    // empty) and Syslog.Facility: calls openlog() with LOG_PID. Does nothing where there is no syslog.
+    virtual void OpenSyslogUnlocked(const std::string& ident, SyslogFacility facility);
+
+    // Sends one message: 'priority' is the facility and the severity combined, as syslog() takes it (e.g. 14 for
+    // LOG_USER | LOG_INFO). Does nothing where there is no syslog.
+    virtual void SendToSyslogUnlocked(int priority, std::string_view message);
+
+public: // Static methods
+    // Singleton support for the common static instance. Never destroyed; finalized at exit in static destruction
+    // order, like TASWFileLog::GetInstance() (see there).
+    static TASWSyslogLog& GetInstance();
+
+public:
+    TASWSyslogLog() = default;
+    // Writes the shutdown line (see TASWTextLogBase::Finalize())
+    ~TASWSyslogLog() override;
+
+    TASWSyslogLog(const TASWSyslogLog&) = delete;
+    TASWSyslogLog& operator=(const TASWSyslogLog&) = delete;
+
+    // As for the other loggers where there is a syslog; always false on Windows
+    bool ShouldLog(Level level) const noexcept override;
+    bool ShouldLog(const TASWLogRecord& record) const noexcept override;
+};
+
+} // namespace ASWLog
+
+#endif // #ifndef ASWLog_SyslogLogH
diff --git a/ASWLog/ASWLog_Types.cpp b/ASWLog/ASWLog_Types.cpp
index fd8220f..4e4e063 100644
--- a/ASWLog/ASWLog_Types.cpp
+++ b/ASWLog/ASWLog_Types.cpp
@@ -27,6 +27,7 @@ limitations under the License.
 #include <algorithm>
 #include <cctype>
 #include <format>
+#include <initializer_list>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
@@ -157,6 +158,18 @@ std::optional<MultilineMode> MultilineMode_FromString(std::string_view str) noex
     return std::nullopt;
 }
 
+//---------------------------------------------------------------------------
+std::optional<SyslogFacility> SyslogFacility_FromString(std::string_view str) noexcept
+{
+    for (const auto facility : { SyslogFacility::User, SyslogFacility::Daemon, SyslogFacility::Local0, SyslogFacility::Local1, SyslogFacility::Local2, SyslogFacility::Local3, SyslogFacility::Local4, SyslogFacility::Local5, SyslogFacility::Local6, SyslogFacility::Local7 })
+    {
+        if (iequals(str, SyslogFacility_ToString(facility)))
+            return facility;
+    }
+
+    return std::nullopt;
+}
+
 //---------------------------------------------------------------------------
 std::optional<TimePrecision> TimePrecision_FromString(std::string_view str) noexcept
 {
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index a96c3b0..49c5af1 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -364,6 +364,64 @@ enum class MultilineMode
 
 //---------------------------------------------------------------------------
 
+// The syslog facility a TASWSyslogLog sends its entries with (see TASWSyslogConfig::Facility). The values are the
+// facility codes of RFC 5424, the same as the LOG_* facilities of <syslog.h> divided by 8.
+enum class SyslogFacility
+{
+    User   = 1,  // LOG_USER: an application's messages
+    Daemon = 3,  // LOG_DAEMON: a system service's
+    Local0 = 16, // LOG_LOCAL0 to LOG_LOCAL7: for the site's own use, e.g. to route an application's messages to a file
+    Local1 = 17,
+    Local2 = 18,
+    Local3 = 19,
+    Local4 = 20,
+    Local5 = 21,
+    Local6 = 22,
+    Local7 = 23,
+};
+
+[[nodiscard]] std::optional<SyslogFacility> SyslogFacility_FromString(std::string_view str) noexcept;
+
+[[nodiscard]] constexpr std::string_view SyslogFacility_ToString(SyslogFacility facility) noexcept
+{
+    switch (facility)
+    {
+        case SyslogFacility::User:
+            return "USER";
+
+        case SyslogFacility::Daemon:
+            return "DAEMON";
+
+        case SyslogFacility::Local0:
+            return "LOCAL0";
+
+        case SyslogFacility::Local1:
+            return "LOCAL1";
+
+        case SyslogFacility::Local2:
+            return "LOCAL2";
+
+        case SyslogFacility::Local3:
+            return "LOCAL3";
+
+        case SyslogFacility::Local4:
+            return "LOCAL4";
+
+        case SyslogFacility::Local5:
+            return "LOCAL5";
+
+        case SyslogFacility::Local6:
+            return "LOCAL6";
+
+        case SyslogFacility::Local7:
+            return "LOCAL7";
+    }
+
+    return "UNKNOWN";
+}
+
+//---------------------------------------------------------------------------
+
 // How many digits of the second a timestamp shows (see TASWLineConfig::TimestampPrecision). The digits past the system
 // clock's resolution are 0: with nanoseconds, the last two with MSVC and MinGW on Windows (100 ns), the last three with
 // libc++ (1 us, e.g. RAD Studio).
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3af3352..223955b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -162,6 +162,19 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   gives the shared one. Other platforms have no debugger output: there the
   class builds but writes nothing (`ShouldLog()` is false and no line is
   formatted), so the same code can add it everywhere.
+- `TASWSyslogLog` (new `ASWLog_SyslogLog.h`): sends each line to the system
+  log with `syslog()` on Linux (the journal on systemd hosts), without its
+  line ending, the level as the priority (Trace and Debug `LOG_DEBUG`, Info
+  `LOG_INFO`, Warn `LOG_WARNING`, Error `LOG_ERR`, Critical `LOG_CRIT`).
+  The new `TASWLogConfig::Syslog` group sets the ident (`Ident`, empty =
+  the executable's file name; passed to `openlog()` with `LOG_PID`, so it
+  is process-wide) and the facility (`Facility`, a new `SyslogFacility`:
+  `User`, the default, `Daemon` or `Local0` to `Local7`; sent with each
+  message). The line is formatted as configured, so consider turning off
+  `Line.ShowTimestamp` and `Line.ShowProcessId`, which syslog adds itself.
+  `TASWSyslogLog::GetInstance()` gives the shared one. Windows has no
+  syslog: there the class builds but writes nothing (`ShouldLog()` is false
+  and no line is formatted).
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e16a0fc..59c6caf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -44,6 +44,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_MultiLog.h
     ASWLog/ASWLog_NullLog.cpp
     ASWLog/ASWLog_NullLog.h
+    ASWLog/ASWLog_SyslogLog.cpp
+    ASWLog/ASWLog_SyslogLog.h
     ASWLog/ASWLog_TextLogBase.cpp
     ASWLog/ASWLog_TextLogBase.h
     ASWLog/ASWLog_Types.cpp
diff --git a/Deploy.bat b/Deploy.bat
index a0ec0b9..e42a76c 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -116,6 +116,10 @@ call :CopyFile "ASWLog\ASWLog_NullLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_NullLog.c
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_NullLog.h" "%TARGET_DIR%\ASWLog\ASWLog_NullLog.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_SyslogLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_SyslogLog.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_SyslogLog.h" "%TARGET_DIR%\ASWLog\ASWLog_SyslogLog.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_TextLogBase.cpp" "%TARGET_DIR%\ASWLog\ASWLog_TextLogBase.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_TextLogBase.h" "%TARGET_DIR%\ASWLog\ASWLog_TextLogBase.h"
diff --git a/README.md b/README.md
index 63fa685..64b3787 100644
--- a/README.md
+++ b/README.md
@@ -55,6 +55,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   tests.
 - A null logger (`ASWLog::TASWNullLog`) that writes nothing, to turn logging off behind an `IASWLog&` or to pass to
   code under test.
+- A syslog logger (`ASWLog::TASWSyslogLog`) for the Linux system log and the systemd journal, with the level as the
+  priority and the ident and facility in `TASWLogConfig::Syslog` (Linux; it writes nothing on Windows).
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
   or derive a new text logger from `TASWTextLogBase` and implement only its output.
 
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index e925baa..b5d36cd 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -187,6 +187,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_NullLog.h</DependentOn>
             <BuildOrder>16</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_SyslogLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_SyslogLog.h</DependentOn>
+            <BuildOrder>19</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>10</BuildOrder>
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index ba4ac17..fa07ebc 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -44,6 +44,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_MemoryLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_MultiLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_NullLog.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_SyslogLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_TextLogBase.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Types.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Utils.cpp"
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index d358f2d..b0001d2 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -202,6 +202,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_NullLog.h</DependentOn>
             <BuildOrder>41</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_SyslogLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_SyslogLog.h</DependentOn>
+            <BuildOrder>47</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>26</BuildOrder>
@@ -270,6 +274,10 @@
             <DependentOn>..\tests\Test_ASWLog_NullLog.h</DependentOn>
             <BuildOrder>42</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_SyslogLog.cpp">
+            <DependentOn>..\tests\Test_ASWLog_SyslogLog.h</DependentOn>
+            <BuildOrder>48</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_TextLogBase.cpp">
             <DependentOn>..\tests\Test_ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>27</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_SyslogLog.cpp b/tests/tests/Test_ASWLog_SyslogLog.cpp
new file mode 100644
index 0000000..60822ff
--- /dev/null
+++ b/tests/tests/Test_ASWLog_SyslogLog.cpp
@@ -0,0 +1,447 @@
+/* **************************************************************************
+Test_ASWLog_SyslogLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_SyslogLog.h"
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <format>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_CrashHandler.h"
+#include "ASWLog_SyslogLog.h"
+#include "ASWLog_Utils.h"
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+// A value whose formatting is counted in SyslogLogFormatCount, to check whether a *Fmt call formats
+struct TSyslogLogCountedValue
+{
+};
+
+int SyslogLogFormatCount = 0;
+
+} // namespace
+
+template<>
+struct std::formatter<TSyslogLogCountedValue>
+{
+    constexpr std::format_parse_context::iterator parse(std::format_parse_context& context)
+    {
+        return context.begin();
+    }
+
+    std::format_context::iterator format(const TSyslogLogCountedValue& /*value*/, std::format_context& context) const
+    {
+        ++SyslogLogFormatCount;
+        return std::format_to(context.out(), "counted");
+    }
+};
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+// The syslog priorities of the LOG_USER facility (8) with each severity, as in <syslog.h>
+constexpr int UserCritical = 8 | 2;
+constexpr int UserError    = 8 | 3;
+constexpr int UserWarning  = 8 | 4;
+constexpr int UserInfo     = 8 | 6;
+constexpr int UserDebug    = 8 | 7;
+
+//---------------------------------------------------------------------------
+
+// A config with no startup or shutdown lines and only the level in each line, e.g. "[INFO]: message"
+ASWLog::TASWLogConfig MakeSyslogConfig()
+{
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Info;
+    config.Line.ShowTimestamp = false;
+    config.Line.ShowProcessId = false;
+    config.Line.ShowThreadId = false;
+    config.Shutdown.WriteLine = false;
+    config.Startup.WriteTimeInfo = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    return config;
+}
+
+// Counts the lines it formats
+class TCountingFormatter final : public ASWLog::IASWLogFormatter
+{
+public:
+    mutable int FormatCount = 0;
+
+    std::string Format(const ASWLog::TASWLogRecord& record, const ASWLog::TASWLogConfig& /*config*/) const override
+    {
+        ++FormatCount;
+        return std::string(record.Message);
+    }
+};
+
+// A syslog logger that keeps what it would pass to openlog() and syslog(), on every platform (on Windows, the
+// logger's own ShouldLog() and PrepareWriteUnlocked() would drop every entry)
+class TCapturingSyslogLog final : public ASWLog::TASWSyslogLog
+{
+public:
+    struct TOpen
+    {
+        std::string Ident;
+        ASWLog::SyslogFacility Facility = ASWLog::SyslogFacility::User;
+    };
+
+    struct TMessage
+    {
+        int Priority = 0;
+        std::string Text;
+    };
+
+    std::vector<TOpen> Opens;
+    std::vector<TMessage> Messages;
+
+protected:
+    void OpenSyslogUnlocked(const std::string& ident, ASWLog::SyslogFacility facility) override
+    {
+        Opens.push_back({ ident, facility });
+    }
+
+    bool PrepareWriteUnlocked(std::chrono::system_clock::time_point /*now*/) override
+    {
+        return true;
+    }
+
+    void SendToSyslogUnlocked(int priority, std::string_view message) override
+    {
+        Messages.push_back({ priority, std::string(message) });
+    }
+
+public:
+    // The overrides above are used until the shutdown line
+    ~TCapturingSyslogLog() override
+    {
+        Finalize();
+    }
+
+    bool ShouldLog(ASWLog::Level level) const noexcept override
+    {
+        return ASWLog::TASWTextLogBase::ShouldLog(level);
+    }
+
+    bool ShouldLog(const ASWLog::TASWLogRecord& record) const noexcept override
+    {
+        return ASWLog::TASWTextLogBase::ShouldLog(record);
+    }
+
+    void WriteCrashLine(std::string_view line) noexcept
+    {
+        WriteCrashLineDirect(line);
+    }
+};
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_SyslogLog
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_SyslogLog::TTest_ASWLog_SyslogLog()
+    : inherited("ASWLog_SyslogLog_Tests")
+{
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_GetInstance_ReturnsTheSameLogger, "GetInstance_ReturnsTheSameLogger");
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_HandleCrash_SendsTheFormattedCrashLineOnly, "HandleCrash_SendsTheFormattedCrashLineOnly");
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_Initialize_OpensSyslogWithTheIdentAndFacility, "Initialize_OpensSyslogWithTheIdentAndFacility");
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_Linux_SendsToTheRealSyslog, "Linux_SendsToTheRealSyslog");
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_Send_FollowsTheMultilineMode, "Send_FollowsTheMultilineMode");
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_Send_MapsEachLevelToAPriority, "Send_MapsEachLevelToAPriority");
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_Send_StripsOnlyTheLineEnding, "Send_StripsOnlyTheLineEnding");
+    RegisterTest(&TTest_ASWLog_SyslogLog::Test_ShouldLog_FollowsThePlatform, "ShouldLog_FollowsThePlatform");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_SyslogLog::~TTest_ASWLog_SyslogLog()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::SetUp_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::SetUp_Test(ITestCase& /*testCase*/)
+{
+    SyslogLogFormatCount = 0;
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::TearDown_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::TearDown_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_GetInstance_ReturnsTheSameLogger()
+{
+    // Act
+    auto& first = ASWLog::TASWSyslogLog::GetInstance();
+    auto& second = ASWLog::TASWSyslogLog::GetInstance();
+
+    // Assert
+    CheckSame(&first, &second, "GetInstance() should always return the same logger");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_HandleCrash_SendsTheFormattedCrashLineOnly()
+{
+    // Arrange
+    TCapturingSyslogLog log;
+    CheckTrue(log.Initialize(MakeSyslogConfig()), "Initialize should succeed");
+
+    // Act: a crash in normal context, then the direct write a POSIX signal handler (or a busy lock) would use
+    ASWLog::HandleCrash("test crash");
+    log.WriteCrashLine("[CRITICAL]: Crash: direct\n");
+
+    // Assert
+    AssertEquals(1, log.Messages.size(), "Only the formatted crash line should be sent");
+    CheckEquals(UserCritical, log.Messages[0].Priority, "The crash line should be sent as LOG_CRIT");
+    CheckEquals(std::string("[CRITICAL]: Crash: test crash"), log.Messages[0].Text, "The crash line should be sent without its line ending");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_Initialize_OpensSyslogWithTheIdentAndFacility()
+{
+    // Arrange
+    TCapturingSyslogLog log;
+    const auto config = MakeSyslogConfig();
+    auto appConfig = config;
+    appConfig.Syslog.Ident = "MyApp";
+    appConfig.Syslog.Facility = ASWLog::SyslogFacility::Local3;
+    const std::string executableName = ASWLog::PathToUTF8String(ASWLog::GetExecutablePath().filename());
+
+    // Act
+    const bool initialized = log.Initialize(config);
+    const bool reconfigured = log.Reconfigure(appConfig);
+    const bool closed = log.Close();
+    const bool opened = log.Open();
+
+    // Assert
+    CheckTrue(initialized && reconfigured && closed && opened, "Initialize, Reconfigure, Close and Open should succeed");
+    CheckEmpty(config.Syslog.Ident, "The default ident should be empty (the executable's file name)");
+    CheckEquals(ASWLog::SyslogFacility::User, config.Syslog.Facility, "The default facility should be User");
+    AssertEquals(2, log.Opens.size(), "Initialize and Reconfigure should open syslog; Close and Open should not");
+    CheckNotEmpty(executableName, "The executable's file name should be known");
+    CheckEquals(executableName, log.Opens[0].Ident, "Without an ident, the executable's file name should be used");
+    CheckEquals(ASWLog::SyslogFacility::User, log.Opens[0].Facility, "Initialize should pass the configured facility");
+    CheckEquals(std::string("MyApp"), log.Opens[1].Ident, "Reconfigure should pass the new ident");
+    CheckEquals(ASWLog::SyslogFacility::Local3, log.Opens[1].Facility, "Reconfigure should pass the new facility");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_Linux_SendsToTheRealSyslog()
+{
+#if defined(_WIN32)
+    Skip("Only Linux has a syslog");
+#else
+    // Arrange: the real openlog() and syslog() (each Reconfigure replaces the ident's copy). This writes three Debug
+    // lines to the system log; nothing here can read them back, so it only checks that the calls work.
+    ASWLog::TASWSyslogLog log;
+    auto config = MakeSyslogConfig();
+    config.InitialMinimumLevel = ASWLog::Level::Debug;
+    config.Syslog.Ident = "ASWLogTests";
+    auto otherConfig = config;
+    otherConfig.Syslog.Ident = "ASWLogTests_Other";
+    otherConfig.Syslog.Facility = ASWLog::SyslogFacility::Local7;
+
+    // Act
+    const bool initialized = log.Initialize(config);
+    log.LogDebug("ASWLog unit test: syslog smoke test (1 of 3)");
+    const bool reconfigured = log.Reconfigure(otherConfig);
+    log.LogDebug("ASWLog unit test: syslog smoke test (2 of 3)");
+    const bool reconfiguredBack = log.Reconfigure(config);
+    log.LogDebug("ASWLog unit test: syslog smoke test (3 of 3)");
+    const bool flushed = log.Flush();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(reconfigured && reconfiguredBack, "Reconfigure should succeed");
+    CheckTrue(flushed, "Flush should succeed while open");
+    CheckTrue(log.ShouldLog(ASWLog::Level::Debug), "ShouldLog() should follow the minimum level on Linux");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_Send_FollowsTheMultilineMode()
+{
+    // Arrange
+    TCapturingSyslogLog log;
+    auto indentConfig = MakeSyslogConfig();
+    indentConfig.Line.Multiline = ASWLog::MultilineMode::Indent;
+    auto escapeConfig = MakeSyslogConfig();
+    escapeConfig.Line.Multiline = ASWLog::MultilineMode::Escape;
+    CheckTrue(log.Initialize(MakeSyslogConfig()), "Initialize should succeed");
+
+    // Act
+    log.LogInfo("first\nsecond");
+    CheckTrue(log.Reconfigure(indentConfig), "Reconfigure should succeed");
+    log.LogInfo("first\nsecond");
+    CheckTrue(log.Reconfigure(escapeConfig), "Reconfigure should succeed");
+    log.LogInfo("first\r\nsecond");
+
+    // Assert
+    AssertEquals(3, log.Messages.size(), "Each entry should be one message");
+    CheckEquals(std::string("[INFO]: first\nsecond"), log.Messages[0].Text, "Preserve should keep the line break");
+    CheckEquals(std::string("[INFO]: first\n    | second"), log.Messages[1].Text, "Indent should mark the next line");
+    CheckEquals(std::string("[INFO]: first\\r\\nsecond"), log.Messages[2].Text, "Escape should write \\r and \\n");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_Send_MapsEachLevelToAPriority()
+{
+    // Arrange
+    TCapturingSyslogLog log;
+    auto config = MakeSyslogConfig();
+    config.InitialMinimumLevel = ASWLog::Level::Trace;
+    auto local3Config = config;
+    local3Config.Syslog.Facility = ASWLog::SyslogFacility::Local3;
+    auto daemonConfig = config;
+    daemonConfig.Syslog.Facility = ASWLog::SyslogFacility::Daemon;
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+
+    // Act
+    log.LogTrace("trace");
+    log.LogDebug("debug");
+    log.LogInfo("info");
+    log.LogWarn("warn");
+    log.LogError("error");
+    log.LogCritical("critical");
+    log.LogRaw(ASWLog::Level::Warn, "raw");
+    CheckTrue(log.Reconfigure(local3Config), "Reconfigure should succeed");
+    log.LogError("local3");
+    CheckTrue(log.Reconfigure(daemonConfig), "Reconfigure should succeed");
+    log.LogInfo("daemon");
+
+    // Assert
+    AssertEquals(9, log.Messages.size(), "Each entry should be one message");
+    CheckEquals(UserDebug, log.Messages[0].Priority, "Trace should be LOG_DEBUG");
+    CheckEquals(UserDebug, log.Messages[1].Priority, "Debug should be LOG_DEBUG");
+    CheckEquals(UserInfo, log.Messages[2].Priority, "Info should be LOG_INFO");
+    CheckEquals(UserWarning, log.Messages[3].Priority, "Warn should be LOG_WARNING");
+    CheckEquals(UserError, log.Messages[4].Priority, "Error should be LOG_ERR");
+    CheckEquals(UserCritical, log.Messages[5].Priority, "Critical should be LOG_CRIT");
+    CheckEquals(UserWarning, log.Messages[6].Priority, "A raw entry should get its level's priority");
+    CheckEquals((19 << 3) | 3, log.Messages[7].Priority, "The facility should be sent with each message (LOG_LOCAL3 | LOG_ERR)");
+    CheckEquals((3 << 3) | 6, log.Messages[8].Priority, "The facility should be sent with each message (LOG_DAEMON | LOG_INFO)");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_Send_StripsOnlyTheLineEnding()
+{
+    // Arrange
+    TCapturingSyslogLog log;
+    auto crlfConfig = MakeSyslogConfig();
+    crlfConfig.Line.Ending = ASWLog::LineEnding::CRLF;
+    CheckTrue(log.Initialize(MakeSyslogConfig()), "Initialize should succeed");
+
+    // Act
+    log.LogInfo("hello");
+    log.LogInfo("ends with a break\n");
+    log.LogRaw(ASWLog::Level::Info, "raw text\n");
+    CheckTrue(log.Reconfigure(crlfConfig), "Reconfigure should succeed");
+    log.LogInfo("crlf");
+    log.LogInfo("ends with LF\n");
+
+    // Assert
+    AssertEquals(5, log.Messages.size(), "Each entry should be one message");
+    CheckEquals(std::string("[INFO]: hello"), log.Messages[0].Text, "The LF ending should be stripped");
+    CheckEquals(std::string("[INFO]: ends with a break\n"), log.Messages[1].Text, "Only the line ending should be stripped, not the message's own break");
+    CheckEquals(std::string("raw text\n"), log.Messages[2].Text, "A raw entry should be sent as is");
+    CheckEquals(std::string("[INFO]: crlf"), log.Messages[3].Text, "The CRLF ending should be stripped");
+    CheckEquals(std::string("[INFO]: ends with LF\n"), log.Messages[4].Text, "With CRLF endings, the message's own LF should stay");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_SyslogLog::Test_ShouldLog_FollowsThePlatform()
+{
+#if defined(_WIN32)
+    // Arrange: a startup and a shutdown line too, each of which would be formatted
+    auto config = MakeSyslogConfig();
+    const auto formatter = std::make_shared<const TCountingFormatter>();
+    config.Line.Formatter = formatter;
+    config.Startup.Banner = "banner";
+    config.Shutdown.WriteLine = true;
+    ASWLog::TASWLogRecord criticalRecord;
+    criticalRecord.LogLevel = ASWLog::Level::Critical;
+    bool initialized = false;
+    bool shouldLog = true;
+    bool shouldLogRecord = true;
+
+    // Act
+    {
+        ASWLog::TASWSyslogLog log;
+        initialized = log.Initialize(config);
+        shouldLog = log.ShouldLog(ASWLog::Level::Critical);
+        shouldLogRecord = log.ShouldLog(criticalRecord);
+        log.LogCriticalFmt("{}", TSyslogLogCountedValue{});
+        log.LogCritical("not formatted");
+    }
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed on every platform");
+    CheckFalse(shouldLog, "Without a syslog, ShouldLog() should be false");
+    CheckFalse(shouldLogRecord, "Without a syslog, ShouldLog(record) should be false");
+    CheckEquals(0, SyslogLogFormatCount, "Without a syslog, no *Fmt arguments should be formatted");
+    CheckEquals(0, formatter->FormatCount, "Without a syslog, no line (startup, entry or shutdown) should be formatted");
+#else
+    // Arrange: no startup or shutdown lines, and only checks, so nothing reaches the system log
+    ASWLog::TASWSyslogLog log;
+    ASWLog::TASWLogRecord infoRecord;
+    infoRecord.LogLevel = ASWLog::Level::Info;
+
+    // Act
+    const bool initialized = log.Initialize(MakeSyslogConfig());
+    log.LogDebugFmt("{}", TSyslogLogCountedValue{});
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed on every platform");
+    CheckEquals(0, SyslogLogFormatCount, "An entry below the minimum level should not be formatted");
+    CheckTrue(log.ShouldLog(ASWLog::Level::Info), "On Linux, ShouldLog() should follow the minimum level (Info)");
+    CheckFalse(log.ShouldLog(ASWLog::Level::Debug), "On Linux, ShouldLog() should follow the minimum level (Debug)");
+    CheckTrue(log.ShouldLog(infoRecord), "On Linux, ShouldLog(record) should follow the minimum level");
+#endif
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_SyslogLog)
diff --git a/tests/tests/Test_ASWLog_SyslogLog.h b/tests/tests/Test_ASWLog_SyslogLog.h
new file mode 100644
index 0000000..17bfb65
--- /dev/null
+++ b/tests/tests/Test_ASWLog_SyslogLog.h
@@ -0,0 +1,63 @@
+/* **************************************************************************
+Test_ASWLog_SyslogLog.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_SyslogLogH
+#define Test_ASWLog_SyslogLogH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_SyslogLog
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_SyslogLog : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_GetInstance_ReturnsTheSameLogger();
+    void Test_HandleCrash_SendsTheFormattedCrashLineOnly();
+    void Test_Initialize_OpensSyslogWithTheIdentAndFacility();
+    void Test_Linux_SendsToTheRealSyslog();
+    void Test_Send_FollowsTheMultilineMode();
+    void Test_Send_MapsEachLevelToAPriority();
+    void Test_Send_StripsOnlyTheLineEnding();
+    void Test_ShouldLog_FollowsThePlatform();
+
+public:
+    TTest_ASWLog_SyslogLog();
+    ~TTest_ASWLog_SyslogLog() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_SyslogLogH
diff --git a/tests/tests/Test_ASWLog_Types.cpp b/tests/tests/Test_ASWLog_Types.cpp
index 066f175..ced9c88 100644
--- a/tests/tests/Test_ASWLog_Types.cpp
+++ b/tests/tests/Test_ASWLog_Types.cpp
@@ -83,6 +83,8 @@ TTest_ASWLog_Types::TTest_ASWLog_Types()
     RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_RemoveFieldRemovesItForThisEntry, "PendingEntry_RemoveFieldRemovesItForThisEntry");
     RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_SetFieldReplacesOrAddsACopy, "PendingEntry_SetFieldReplacesOrAddsACopy");
     RegisterTest(&TTest_ASWLog_Types::Test_PendingEntry_SetMessageOwnsTheText, "PendingEntry_SetMessageOwnsTheText");
+    RegisterTest(&TTest_ASWLog_Types::Test_SyslogFacility_FromString, "SyslogFacility_FromString");
+    RegisterTest(&TTest_ASWLog_Types::Test_SyslogFacility_ToString, "SyslogFacility_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_FromString, "TimePrecision_FromString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimePrecision_ToString, "TimePrecision_ToString");
     RegisterTest(&TTest_ASWLog_Types::Test_TimeZone_FromString, "TimeZone_FromString");
@@ -503,6 +505,37 @@ void TTest_ASWLog_Types::Test_PendingEntry_SetMessageOwnsTheText()
     CheckEquals(std::string("Net"), std::string(entry.GetRecord().Category), "The category should be kept");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_SyslogFacility_FromString()
+{
+    // Arrange
+    const auto user = ASWLog::SyslogFacility_FromString("USER");
+    const auto daemon = ASWLog::SyslogFacility_FromString("daemon");
+    const auto local0 = ASWLog::SyslogFacility_FromString("Local0");
+    const auto local7 = ASWLog::SyslogFacility_FromString("LOCAL7");
+    const auto local8 = ASWLog::SyslogFacility_FromString("LOCAL8");
+    const auto kernel = ASWLog::SyslogFacility_FromString("KERN");
+
+    // Act & Assert
+    CheckTrue(user == ASWLog::SyslogFacility::User, "USER should map to User");
+    CheckTrue(daemon == ASWLog::SyslogFacility::Daemon, "daemon should map to Daemon, ignoring case");
+    CheckTrue(local0 == ASWLog::SyslogFacility::Local0, "Local0 should map to Local0, ignoring case");
+    CheckTrue(local7 == ASWLog::SyslogFacility::Local7, "LOCAL7 should map to Local7");
+    CheckFalse(local8.has_value(), "There is no LOCAL8");
+    CheckFalse(kernel.has_value(), "A facility the logger doesn't offer should not parse");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Types::Test_SyslogFacility_ToString()
+{
+    // Act & Assert
+    CheckEquals(std::string("USER"), std::string(ASWLog::SyslogFacility_ToString(ASWLog::SyslogFacility::User)), "User should stringify as USER");
+    CheckEquals(std::string("DAEMON"), std::string(ASWLog::SyslogFacility_ToString(ASWLog::SyslogFacility::Daemon)), "Daemon should stringify as DAEMON");
+    CheckEquals(std::string("LOCAL0"), std::string(ASWLog::SyslogFacility_ToString(ASWLog::SyslogFacility::Local0)), "Local0 should stringify as LOCAL0");
+    CheckEquals(std::string("LOCAL4"), std::string(ASWLog::SyslogFacility_ToString(ASWLog::SyslogFacility::Local4)), "Local4 should stringify as LOCAL4");
+    CheckEquals(std::string("LOCAL7"), std::string(ASWLog::SyslogFacility_ToString(ASWLog::SyslogFacility::Local7)), "Local7 should stringify as LOCAL7");
+    CheckEquals(8, static_cast<int>(ASWLog::SyslogFacility::User) << 3, "User should be RFC 5424 facility 1 (LOG_USER = 8)");
+    CheckEquals(184, static_cast<int>(ASWLog::SyslogFacility::Local7) << 3, "Local7 should be RFC 5424 facility 23 (LOG_LOCAL7 = 184)");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_TimePrecision_FromString()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_Types.h b/tests/tests/Test_ASWLog_Types.h
index efbe2fd..ffdad6f 100644
--- a/tests/tests/Test_ASWLog_Types.h
+++ b/tests/tests/Test_ASWLog_Types.h
@@ -55,6 +55,8 @@ class TTest_ASWLog_Types : public TTestGroupBase
     void Test_PendingEntry_SetFieldReplacesOrAddsACopy();
     void Test_PendingEntry_SetMessageOwnsTheText();
     void Test_LogError_ToString();
+    void Test_SyslogFacility_FromString();
+    void Test_SyslogFacility_ToString();
     void Test_TimePrecision_FromString();
     void Test_TimePrecision_ToString();
     void Test_TimeZone_FromString();
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index 9fff869..34ef252 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -240,6 +240,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_NullLog.h</DependentOn>
             <BuildOrder>52</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_SyslogLog.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_SyslogLog.h</DependentOn>
+            <BuildOrder>58</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>34</BuildOrder>
@@ -304,6 +308,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_NullLog.h</DependentOn>
             <BuildOrder>53</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_SyslogLog.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_SyslogLog.h</DependentOn>
+            <BuildOrder>59</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_TextLogBase.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_TextLogBase.h</DependentOn>
             <BuildOrder>35</BuildOrder>

From db1c1b14d7a99677d68437eabc2095ce6642db0a Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 08:32:07 -0700
Subject: [PATCH 17/38] Add TASWWindowsEventLog sink for Windows Event Log

---
 ASWLog/ASWLog_Config.h                        |  17 +
 ASWLog/ASWLog_MemoryLog.cpp                   |  41 +-
 ASWLog/ASWLog_Types.h                         |   3 +-
 ASWLog/ASWLog_Utils.cpp                       |  22 +
 ASWLog/ASWLog_Utils.h                         |   8 +
 ASWLog/ASWLog_WindowsEventLog.cpp             | 356 ++++++++++
 ASWLog/ASWLog_WindowsEventLog.h               | 163 +++++
 CHANGELOG.md                                  |  15 +
 CMakeLists.txt                                |   7 +-
 Deploy.bat                                    |   4 +
 README.md                                     |   2 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_WindowsEventLog.cpp   | 639 ++++++++++++++++++
 tests/tests/Test_ASWLog_WindowsEventLog.h     |  66 ++
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 17 files changed, 1323 insertions(+), 41 deletions(-)
 create mode 100644 ASWLog/ASWLog_WindowsEventLog.cpp
 create mode 100644 ASWLog/ASWLog_WindowsEventLog.h
 create mode 100644 tests/tests/Test_ASWLog_WindowsEventLog.cpp
 create mode 100644 tests/tests/Test_ASWLog_WindowsEventLog.h

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 94b99ea..05c0df9 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -29,6 +29,7 @@ limitations under the License.
 #ifndef ASWLog_ConfigH
 #define ASWLog_ConfigH
 //---------------------------------------------------------------------------
+#include <array>
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
@@ -111,6 +112,21 @@ struct TASWBackupInfo
 };
 
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWEventLogConfig
+//
+// How a TASWWindowsEventLog reports its entries to the Windows Event Log (TASWLogConfig::EventLog).
+/////////////////////////////////////////////////////////////////////////////
+struct TASWEventLogConfig
+{
+    // The event source Event Viewer shows, in the Application log. Empty: the executable's file name without its
+    // extension. Register it once to get plain messages (see TASWWindowsEventLog::RegisterSource()).
+    std::string Source;
+    // The event ID of each level's entries, indexed by Level (Trace first): by default 1000 to 1005, Critical 1005
+    std::array<std::uint16_t, LevelCount> EventIds{ 1000, 1001, 1002, 1003, 1004, 1005 };
+};
+
+
 /////////////////////////////////////////////////////////////////////////////
 // TASWFileConfig
 //
@@ -331,6 +347,7 @@ struct TASWLogConfig
     TASWBacktraceConfig Backtrace;
     TASWMemoryConfig Memory;
     TASWSyslogConfig Syslog;
+    TASWEventLogConfig EventLog;
 
     // --- Pre-write Hook ---
     // A last chance for the application to drop or change each of its entries before the logger writes it, e.g. to
diff --git a/ASWLog/ASWLog_MemoryLog.cpp b/ASWLog/ASWLog_MemoryLog.cpp
index b3afa80..e387c00 100644
--- a/ASWLog/ASWLog_MemoryLog.cpp
+++ b/ASWLog/ASWLog_MemoryLog.cpp
@@ -29,46 +29,11 @@ limitations under the License.
 #include <mutex>
 #include <utility>
 //---------------------------------------------------------------------------
-
-namespace ASWLog
-{
-
-namespace
-{
-
-// Ends a line cut to fit TASWMemoryConfig::MaxBytes
-constexpr std::string_view CutMarker = " [cut]";
-
-//---------------------------------------------------------------------------
-
-void CutToFit(std::string& text, std::size_t maxBytes);
-
+#include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
 
-/*
-  CutToFit
-
-  Cuts 'text' to at most 'maxBytes' bytes, between UTF-8 characters, ending with CutMarker if that fits too
-*/
-void CutToFit(std::string& text, std::size_t maxBytes)
+namespace ASWLog
 {
-    if (text.size() <= maxBytes)
-        return;
-
-    const bool hasMarker = maxBytes >= CutMarker.size();
-    std::size_t keptSize = hasMarker ? maxBytes - CutMarker.size() : maxBytes;
-
-    // Back to the start of a UTF-8 character (a continuation byte is 10xxxxxx)
-    while (keptSize > 0 && (static_cast<unsigned char>(text[keptSize]) & 0xC0) == 0x80)
-        --keptSize;
-
-    text.resize(keptSize);
-
-    if (hasMarker)
-        text.append(CutMarker);
-}
-
-} // namespace
 
 //---------------------------------------------------------------------------
 
@@ -209,7 +174,7 @@ void TASWMemoryLog::WriteLineUnlocked(Level /*level*/, std::string_view line, bo
     std::lock_guard<std::mutex> lock(m_LinesMutex);
 
     if (m_MaxBytes > 0)
-        CutToFit(text, m_MaxBytes);
+        Detail::CutToFit(text, m_MaxBytes);
 
     const std::size_t size = text.size();
     m_Lines.push_back(std::move(text));
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index 49c5af1..a929257 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -129,7 +129,8 @@ enum class ColorMode
 */
 enum class ErrorKind
 {
-    // The log file couldn't be opened (or its folder created), so entries are dropped until it can be.
+    // The log file couldn't be opened (or its folder created), or another output (e.g. a Windows Event Log source), so
+    // entries are dropped until it can be.
     OpenFailed,
 
     // An entry couldn't be written to the output (e.g. the disk is full).
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index 8d1647c..033c947 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -625,6 +625,9 @@ namespace Detail
 namespace
 {
 
+// Ends a text CutToFit() cut
+constexpr std::string_view CutMarker = " [cut]";
+
 // The line breaks MultilineMode::Escape writes
 constexpr std::string_view EscapedCR = "\\r";
 constexpr std::string_view EscapedLF = "\\n";
@@ -779,6 +782,25 @@ void ApplyMultilineMode(std::string& line, MultilineMode mode, LineEnding ending
     line = std::move(rewritten);
 }
 
+//---------------------------------------------------------------------------
+void CutToFit(std::string& text, std::size_t maxBytes)
+{
+    if (text.size() <= maxBytes)
+        return;
+
+    const bool hasMarker = maxBytes >= CutMarker.size();
+    std::size_t keptSize = hasMarker ? maxBytes - CutMarker.size() : maxBytes;
+
+    // Back to the start of a UTF-8 character (a continuation byte is 10xxxxxx)
+    while (keptSize > 0 && (static_cast<unsigned char>(text[keptSize]) & 0xC0) == 0x80)
+        --keptSize;
+
+    text.resize(keptSize);
+
+    if (hasMarker)
+        text.append(CutMarker);
+}
+
 //---------------------------------------------------------------------------
 TJSONPiece NextJSONPiece(std::string_view text, std::size_t& index, char (& escape)[6]) noexcept
 {
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index b81c7e5..93f8799 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -163,6 +163,14 @@ struct TMultilinePiece
 */
 void ApplyMultilineMode(std::string& line, MultilineMode mode, LineEnding ending);
 
+/*
+    CutToFit
+
+    Cuts 'text' to at most 'maxBytes' bytes, between UTF-8 characters, ending with " [cut]" if that fits too. Leaves a
+    text that fits as it is.
+*/
+void CutToFit(std::string& text, std::size_t maxBytes);
+
 /*
     NextJSONPiece
 
diff --git a/ASWLog/ASWLog_WindowsEventLog.cpp b/ASWLog/ASWLog_WindowsEventLog.cpp
new file mode 100644
index 0000000..3960315
--- /dev/null
+++ b/ASWLog/ASWLog_WindowsEventLog.cpp
@@ -0,0 +1,356 @@
+/* **************************************************************************
+ASWLog_WindowsEventLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_WindowsEventLog.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstdlib>
+#include <system_error>
+#include <utility>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+//---------------------------------------------------------------------------
+#include "ASWLog_Utils.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+namespace
+{
+
+// The platform has a Windows Event Log to report to
+#if defined(_WIN32)
+constexpr bool HasEventLog = true;
+
+// The registry key that holds the Application log's sources
+constexpr std::wstring_view ApplicationLogKey = L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\";
+
+// A message file that ships with Windows (.NET Framework 4) and shows every event ID 0-65535 as its text ("%1")
+constexpr std::wstring_view MessageFile = L"%SystemRoot%\\Microsoft.NET\\Framework\\v4.0.30319\\EventLogMessages.dll";
+#else
+constexpr bool HasEventLog = false;
+#endif
+
+//---------------------------------------------------------------------------
+
+std::string ResolveSource(std::string_view source);
+TASWWindowsEventLog::EventType ToEventType(Level level) noexcept;
+
+#if defined(_WIN32)
+bool ToSourceKey(std::string_view source, std::wstring& key);
+#endif
+
+//---------------------------------------------------------------------------
+
+/*
+  ResolveSource
+
+  The event source 'source' names: itself, or the executable's file name without its extension if it is empty
+*/
+std::string ResolveSource(std::string_view source)
+{
+    return source.empty() ? PathToUTF8String(GetExecutablePath().stem()) : std::string(source);
+}
+
+/*
+  ToEventType
+
+  The type of an event for an entry at 'level'
+*/
+TASWWindowsEventLog::EventType ToEventType(Level level) noexcept
+{
+    if (level >= Level::Error)
+        return TASWWindowsEventLog::EventType::Error;
+
+    if (level == Level::Warn)
+        return TASWWindowsEventLog::EventType::Warning;
+
+    return TASWWindowsEventLog::EventType::Information;
+}
+
+#if defined(_WIN32)
+/*
+  ToSourceKey
+
+  Sets 'key' to the registry key (under HKEY_LOCAL_MACHINE) of 'source' (see ResolveSource()); false if the name can't
+  be a source's (empty, or holding a '\', which would name a key below another source's)
+*/
+bool ToSourceKey(std::string_view source, std::wstring& key)
+{
+    const std::string name = ResolveSource(source);
+
+    if (name.empty() || name.find('\\') != std::string::npos)
+        return false;
+
+    key = std::wstring(ApplicationLogKey) + Detail::UTF8ToWideString(name);
+
+    return true;
+}
+#endif
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWWindowsEventLog
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TASWWindowsEventLog::~TASWWindowsEventLog()
+{
+    Finalize();
+}
+
+//---------------------------------------------------------------------------
+// Closes the source opened by OpenEventSourceUnlocked(), if any
+void TASWWindowsEventLog::CloseEventSource() noexcept
+{
+#if defined(_WIN32)
+    if (m_EventSource != nullptr)
+        DeregisterEventSource(static_cast<HANDLE>(m_EventSource));
+#endif
+
+    m_EventSource = nullptr;
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::CloseUnlocked()
+{
+    CloseEventSource();
+    m_IsOpen.store(false);
+    m_IsInitialized.store(false);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::FlushUnlocked()
+{
+    return m_IsOpen.load();
+}
+
+//---------------------------------------------------------------------------
+TASWWindowsEventLog& TASWWindowsEventLog::GetInstance()
+{
+    // Never deleted, so the instance stays usable through static destruction. It is only finalized at exit, by a
+    // handler registered right after it is created, which runs where a static instance's destructor would have run.
+    static TASWWindowsEventLog* const instance = new TASWWindowsEventLog();
+    [[maybe_unused]] static const int atExitResult = std::atexit([] {
+            instance->Finalize();
+        });
+    return *instance;
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::InitializeUnlocked()
+{
+    return OpenUnlocked();
+}
+
+//---------------------------------------------------------------------------
+// Calls OpenEventSourceUnlocked() with the current config's source
+bool TASWWindowsEventLog::OpenEventSourceFromConfigUnlocked()
+{
+    return OpenEventSourceUnlocked(ResolveSource(GetConfigUnlocked().EventLog.Source));
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::OpenEventSourceUnlocked(const std::string& source)
+{
+#if defined(_WIN32)
+    const HANDLE eventSource = RegisterEventSourceW(nullptr, Detail::UTF8ToWideString(source).c_str());
+
+    if (eventSource == nullptr)
+    {
+        TASWLogError error;
+        error.Kind = ErrorKind::OpenFailed;
+        error.Code = std::error_code(static_cast<int>(GetLastError()), std::system_category());
+        error.Message = "Couldn't open the event source '" + source + "'";
+        ReportErrorUnlocked(std::move(error));
+
+        return false;
+    }
+
+    CloseEventSource();
+    m_EventSource = eventSource;
+#else
+    static_cast<void>(source);
+#endif
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::OpenUnlocked()
+{
+    if (!OpenEventSourceFromConfigUnlocked())
+        return false;
+
+    m_IsOpen.store(true);
+    m_IsInitialized.store(true);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point /*now*/)
+{
+    // Before the line is formatted, so nothing is formatted where it would be dropped
+    return HasEventLog;
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::ReconfigureUnlocked(const TASWLogConfig& /*previous*/)
+{
+    return OpenEventSourceFromConfigUnlocked();
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::RegisterSource(std::string_view source) noexcept
+{
+#if defined(_WIN32)
+    try
+    {
+        std::wstring key;
+        HKEY sourceKey = nullptr;
+
+        if (!ToSourceKey(source, key) || RegCreateKeyExW(HKEY_LOCAL_MACHINE, key.c_str(), 0, nullptr, REG_OPTION_NON_VOLATILE,
+            KEY_SET_VALUE, nullptr, &sourceKey, nullptr) != ERROR_SUCCESS)
+            return false;
+
+        const DWORD typesSupported = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
+        const bool isRegistered = RegSetValueExW(sourceKey, L"EventMessageFile", 0, REG_EXPAND_SZ,
+            reinterpret_cast<const BYTE*>(MessageFile.data()), static_cast<DWORD>((MessageFile.size() + 1) * sizeof(wchar_t))) == ERROR_SUCCESS &&
+            RegSetValueExW(sourceKey, L"TypesSupported", 0, REG_DWORD, reinterpret_cast<const BYTE*>(&typesSupported),
+            sizeof(typesSupported)) == ERROR_SUCCESS;
+        RegCloseKey(sourceKey);
+
+        return isRegistered;
+    }
+    catch (...)
+    {
+        return false;
+    }
+#else
+    static_cast<void>(source);
+    return false;
+#endif
+}
+
+//---------------------------------------------------------------------------
+void TASWWindowsEventLog::ReportEventUnlocked(EventType type, std::uint16_t eventId, std::string_view message)
+{
+#if defined(_WIN32)
+    if (m_EventSource == nullptr)
+        return;
+
+    const std::wstring text = Detail::UTF8ToWideString(message);
+    const wchar_t* strings[] = { text.c_str() };
+
+    if (!ReportEventW(static_cast<HANDLE>(m_EventSource), static_cast<WORD>(type), 0, eventId, nullptr, 1, 0, strings, nullptr))
+    {
+        TASWLogError error;
+        error.Kind = ErrorKind::WriteFailed;
+        error.Code = std::error_code(static_cast<int>(GetLastError()), std::system_category());
+        error.Message = "Couldn't report an event to the Windows Event Log";
+        ReportErrorUnlocked(std::move(error));
+    }
+#else
+    static_cast<void>(type);
+    static_cast<void>(eventId);
+    static_cast<void>(message);
+#endif
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::ShouldLog(Level level) const noexcept
+{
+    return HasEventLog && inherited::ShouldLog(level);
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::ShouldLog(const TASWLogRecord& record) const noexcept
+{
+    return HasEventLog && inherited::ShouldLog(record);
+}
+
+//---------------------------------------------------------------------------
+bool TASWWindowsEventLog::UnregisterSource(std::string_view source) noexcept
+{
+#if defined(_WIN32)
+    try
+    {
+        std::wstring key;
+
+        if (!ToSourceKey(source, key))
+            return false;
+
+        const LSTATUS status = RegDeleteKeyW(HKEY_LOCAL_MACHINE, key.c_str());
+
+        return status == ERROR_SUCCESS || status == ERROR_FILE_NOT_FOUND;
+    }
+    catch (...)
+    {
+        return false;
+    }
+#else
+    static_cast<void>(source);
+    return false;
+#endif
+}
+
+//---------------------------------------------------------------------------
+void TASWWindowsEventLog::WriteLineUnlocked(Level level, std::string_view line, bool endsLine)
+{
+    const auto& config = GetConfigUnlocked();
+
+    // Reported without the line ending the formatted line ends with
+    if (endsLine)
+    {
+        const std::string_view ending = config.Line.Ending == LineEnding::CRLF ? "\r\n" : "\n";
+        if (line.ends_with(ending))
+            line.remove_suffix(ending.size());
+    }
+
+    const auto levelIndex = static_cast<std::size_t>(level);
+    const std::uint16_t eventId = config.EventLog.EventIds[levelIndex < LevelCount ? levelIndex : LevelCount - 1];
+
+    if (line.size() <= MaxMessageSize)
+    {
+        ReportEventUnlocked(ToEventType(level), eventId, line);
+        return;
+    }
+
+    std::string text(line);
+    Detail::CutToFit(text, MaxMessageSize);
+    ReportEventUnlocked(ToEventType(level), eventId, text);
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_WindowsEventLog.h b/ASWLog/ASWLog_WindowsEventLog.h
new file mode 100644
index 0000000..787075d
--- /dev/null
+++ b/ASWLog/ASWLog_WindowsEventLog.h
@@ -0,0 +1,163 @@
+/* **************************************************************************
+ASWLog_WindowsEventLog.h
+Author: Anthony S. West - ASW Software
+
+A logging library.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_WindowsEventLogH
+#define ASWLog_WindowsEventLogH
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <string_view>
+//---------------------------------------------------------------------------
+#include "ASWLog_TextLogBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWWindowsEventLog
+//
+// Reports each line to the Windows Event Log, in the Application log, under the event source
+// TASWLogConfig::EventLog.Source (empty: the executable's file name without its extension). The level sets the event's
+// type, as Event Viewer shows it: Trace, Debug and Info an Information event, Warn a Warning, Error and Critical an
+// Error; and its event ID, from EventLog.EventIds (by default 1000 for Trace to 1005 for Critical). Each line is
+// formatted like a file logger's (TASWLogConfig::Line) and reported without its line ending; a line longer than
+// MaxMessageSize bytes is cut to fit, ending with " [cut]" (the Event Log refuses longer ones).
+//
+// Each event takes the Event Log service about a hundred microseconds, and the Application log has a limited size, so
+// this logger suits warnings and errors, not a stream of details. Consider:
+//
+//     ASWLog::TASWWindowsEventLog::GetInstance().SetMinimumLevel(ASWLog::Level::Warn);
+//
+// and turning off config.Line.ShowTimestamp, since Event Viewer shows each event's time (it doesn't show the process
+// id). A multi-log passes one config to all its loggers, so an Event Log logger behind one writes the same layout as
+// the others.
+//
+// Registering the source: until a source is registered, Event Viewer shows each of its events with "The description
+// for Event ID ... cannot be found" before the text. RegisterSource() registers it, with the .NET Framework's
+// EventLogMessages.dll (part of Windows) as its message file, which shows the text as it is. That needs administrator
+// rights, once, e.g. in the application's installer; the registry entries it makes are the same as these two commands
+// (the first is shown on two lines; in a .bat file, write each % as %%):
+//
+//     reg add "HKLM\SYSTEM\CurrentControlSet\Services\EventLog\Application\MyApp" /v EventMessageFile
+//         /t REG_EXPAND_SZ /d "%SystemRoot%\Microsoft.NET\Framework\v4.0.30319\EventLogMessages.dll"
+//     reg add "HKLM\SYSTEM\CurrentControlSet\Services\EventLog\Application\MyApp" /v TypesSupported /t REG_DWORD /d 7
+//
+// Initialize(), Open() and Reconfigure() open the source with RegisterEventSourceW() (which doesn't need the
+// registration); Close() closes it. A crash line formatted in normal context (e.g. std::terminate, the unhandled
+// exception filter, HandleCrash()) is reported as an Error event; nothing is reported if the logger's lock stays busy
+// in a crash (see ASWLog_CrashHandler.h), since reporting an event allocates and could wait for a lock the crashed
+// thread holds.
+//
+// Other platforms have no Windows Event Log, so there it writes nothing: the class builds everywhere, so the same code
+// can add it on every platform, but there ShouldLog() is false and no line is formatted. (On Linux, see the syslog
+// logger.)
+//
+// Takes the same TASWLogConfig as the other text loggers, ignoring its File settings. Thread-safe.
+/////////////////////////////////////////////////////////////////////////////
+class TASWWindowsEventLog : public TASWTextLogBase
+{
+private:
+    typedef TASWTextLogBase inherited;
+
+public:
+    // An event's type, as Event Viewer shows it (the values of EVENTLOG_ERROR_TYPE etc.)
+    enum class EventType : std::uint16_t
+    {
+        Error       = 1,
+        Warning     = 2,
+        Information = 4,
+    };
+
+    // The longest message reported, in bytes of UTF-8: the Event Log's limit of 31,839 characters (UTF-16 code units),
+    // which a text of that many bytes never exceeds
+    static constexpr std::size_t MaxMessageSize = 31839;
+
+private:
+    void* m_EventSource = nullptr; // The HANDLE from RegisterEventSourceW(), or null
+
+private:
+    void CloseEventSource() noexcept;
+    bool OpenEventSourceFromConfigUnlocked();
+
+protected: // TASWTextLogBase hooks
+    bool CloseUnlocked() override;
+    bool FlushUnlocked() override; // Nothing is buffered: true while open
+    bool InitializeUnlocked() override;
+    bool OpenUnlocked() override;
+    bool PrepareWriteUnlocked(std::chrono::system_clock::time_point now) override; // False where it writes nothing
+    bool ReconfigureUnlocked(const TASWLogConfig& previous) override;
+    void WriteLineUnlocked(Level level, std::string_view line, bool endsLine) override;
+
+protected:
+    std::string_view GetLoggerClassName() const noexcept override
+    {
+        return "TASWWindowsEventLog";
+    }
+
+    // Called by Initialize(), Open() and Reconfigure() with the source (EventLog.Source, or the executable's file name
+    // without its extension if that is empty): opens it with RegisterEventSourceW(), replacing the source opened
+    // before. Reports an ErrorKind::OpenFailed error and returns false if it can't, keeping the previous source. Does
+    // nothing and returns true where there is no Event Log.
+    virtual bool OpenEventSourceUnlocked(const std::string& source);
+
+    // Reports one event with 'message' (UTF-8, at most MaxMessageSize bytes) as its text, through ReportEventW().
+    // Reports an ErrorKind::WriteFailed error if that fails. Does nothing where there is no Event Log.
+    virtual void ReportEventUnlocked(EventType type, std::uint16_t eventId, std::string_view message);
+
+public: // Static methods
+    // Singleton support for the common static instance. Never destroyed; finalized at exit in static destruction
+    // order, like TASWFileLog::GetInstance() (see there).
+    static TASWWindowsEventLog& GetInstance();
+
+    // Registers 'source' (empty: the executable's file name without its extension) in the Application log, with
+    // EventLogMessages.dll as its message file (see above), replacing an earlier registration of that name. Needs
+    // administrator rights; returns false if it couldn't (or where there is no Event Log, or if 'source' holds a '\').
+    static bool RegisterSource(std::string_view source = {}) noexcept;
+
+    // Removes the registration of 'source' (empty: as for RegisterSource()). Needs administrator rights; returns true
+    // if the source isn't registered afterwards (also if it wasn't), false if it couldn't be removed (or where there is
+    // no Event Log, or if 'source' holds a '\').
+    static bool UnregisterSource(std::string_view source = {}) noexcept;
+
+public:
+    TASWWindowsEventLog() = default;
+    // Writes the shutdown line (see TASWTextLogBase::Finalize())
+    ~TASWWindowsEventLog() override;
+
+    TASWWindowsEventLog(const TASWWindowsEventLog&) = delete;
+    TASWWindowsEventLog& operator=(const TASWWindowsEventLog&) = delete;
+
+    // As for the other loggers on Windows; always false where there is no Event Log
+    bool ShouldLog(Level level) const noexcept override;
+    bool ShouldLog(const TASWLogRecord& record) const noexcept override;
+};
+
+} // namespace ASWLog
+
+#endif // #ifndef ASWLog_WindowsEventLogH
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 223955b..713bc7b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -175,6 +175,21 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   `TASWSyslogLog::GetInstance()` gives the shared one. Windows has no
   syslog: there the class builds but writes nothing (`ShouldLog()` is false
   and no line is formatted).
+- `TASWWindowsEventLog` (new `ASWLog_WindowsEventLog.h`): reports each line
+  to the Windows Event Log (Application log), without its line ending: Trace,
+  Debug and Info as Information events, Warn as Warning, Error and Critical
+  as Error. The new `TASWLogConfig::EventLog` group sets the event source
+  (`Source`, empty = the executable's file name without its extension) and
+  the event ID per level (`EventIds`, by default 1000 for Trace to 1005 for
+  Critical). A line longer than `TASWWindowsEventLog::MaxMessageSize`
+  (31,839 bytes) is cut to fit, ending with ` [cut]`. Each event takes
+  about a hundred microseconds, so it suits warnings and errors.
+  `TASWWindowsEventLog::RegisterSource()` and `UnregisterSource()` register
+  a source (administrator rights, e.g. in an installer) with the .NET
+  Framework's `EventLogMessages.dll`, so that Event Viewer shows the text
+  without "The description for Event ID ... cannot be found".
+  `TASWWindowsEventLog::GetInstance()` gives the shared one. Other platforms
+  have no Event Log: there the class builds but writes nothing.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59c6caf..0eea1de 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -54,6 +54,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_Utils.h
     ASWLog/ASWLog_Version.cpp
     ASWLog/ASWLog_Version.h
+    ASWLog/ASWLog_WindowsEventLog.cpp
+    ASWLog/ASWLog_WindowsEventLog.h
 )
 add_library(ASWLog::ASWLog ALIAS ASWLog)
 
@@ -63,8 +65,9 @@ set_target_properties(ASWLog PROPERTIES CXX_EXTENSIONS OFF)
 target_include_directories(ASWLog PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/ASWLog")
 
 if(WIN32)
-    # ASWLog_Utils.cpp uses the process memory APIs from psapi.
-    target_link_libraries(ASWLog PRIVATE psapi)
+    # ASWLog_Utils.cpp uses the process memory APIs from psapi, and ASWLog_WindowsEventLog.cpp the Event Log and
+    # registry APIs from advapi32.
+    target_link_libraries(ASWLog PRIVATE psapi advapi32)
 endif()
 
 # TASWTextLogBase runs a std::thread (e.g. for FlushMode::Periodic). Public, since the thread is part of the class
diff --git a/Deploy.bat b/Deploy.bat
index e42a76c..c9c9d7d 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -136,6 +136,10 @@ call :CopyFile "ASWLog\ASWLog_Version.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Version.c
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Version.h" "%TARGET_DIR%\ASWLog\ASWLog_Version.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_WindowsEventLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_WindowsEventLog.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_WindowsEventLog.h" "%TARGET_DIR%\ASWLog\ASWLog_WindowsEventLog.h"
+if errorlevel 1 exit /b 1
 
 call :CopyFile "example\cmake\CMakeLists.txt" "%TARGET_DIR%\example\cmake\CMakeLists.txt"
 if errorlevel 1 exit /b 1
diff --git a/README.md b/README.md
index 64b3787..66877ee 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,8 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
   code under test.
 - A syslog logger (`ASWLog::TASWSyslogLog`) for the Linux system log and the systemd journal, with the level as the
   priority and the ident and facility in `TASWLogConfig::Syslog` (Linux; it writes nothing on Windows).
+- A Windows Event Log logger (`ASWLog::TASWWindowsEventLog`) for warnings and errors in Event Viewer, with an event ID
+  per level and a helper to register the event source (Windows; it writes nothing elsewhere).
 - Extensible: assign your own formatter (`IASWLogFormatter`) to `TASWLogConfig::Line.Formatter` for your own line layout,
   or derive a new text logger from `TASWTextLogBase` and implement only its output.
 
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index b5d36cd..edbbab7 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -207,6 +207,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Version.h</DependentOn>
             <BuildOrder>12</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_WindowsEventLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_WindowsEventLog.h</DependentOn>
+            <BuildOrder>20</BuildOrder>
+        </CppCompile>
         <PCHCompile Include="ASWLogExamplePCH1.h">
             <BuildOrder>0</BuildOrder>
             <PCH>true</PCH>
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index fa07ebc..0690883 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -49,6 +49,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Types.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Utils.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Version.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_WindowsEventLog.cpp"
     "${ASWLOG_TESTS_DIR}/UT_Helper_DateTime.cpp"
     "${ASWLOG_TESTS_DIR}/UT_Helper_JSON.cpp"
 )
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index b0001d2..9850d1b 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -222,6 +222,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Version.h</DependentOn>
             <BuildOrder>30</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_WindowsEventLog.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_WindowsEventLog.h</DependentOn>
+            <BuildOrder>49</BuildOrder>
+        </CppCompile>
         <PCHCompile Include="ASWLogTestsPCH1.h">
             <BuildOrder>0</BuildOrder>
             <PCH>true</PCH>
@@ -294,6 +298,10 @@
             <DependentOn>..\tests\Test_ASWLog_Version.h</DependentOn>
             <BuildOrder>31</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_WindowsEventLog.cpp">
+            <DependentOn>..\tests\Test_ASWLog_WindowsEventLog.h</DependentOn>
+            <BuildOrder>50</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\UT_Helper_DateTime.cpp">
             <DependentOn>..\tests\UT_Helper_DateTime.h</DependentOn>
             <BuildOrder>35</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_WindowsEventLog.cpp b/tests/tests/Test_ASWLog_WindowsEventLog.cpp
new file mode 100644
index 0000000..400b6e6
--- /dev/null
+++ b/tests/tests/Test_ASWLog_WindowsEventLog.cpp
@@ -0,0 +1,639 @@
+/* **************************************************************************
+Test_ASWLog_WindowsEventLog.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_WindowsEventLog.h"
+//---------------------------------------------------------------------------
+#include <chrono>
+#include <cstdint>
+#include <format>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_CrashHandler.h"
+#include "ASWLog_Utils.h"
+#include "ASWLog_WindowsEventLog.h"
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+// A value whose formatting is counted in EventLogFormatCount, to check whether a *Fmt call formats
+struct TEventLogCountedValue
+{
+};
+
+int EventLogFormatCount = 0;
+
+} // namespace
+
+template<>
+struct std::formatter<TEventLogCountedValue>
+{
+    constexpr std::format_parse_context::iterator parse(std::format_parse_context& context)
+    {
+        return context.begin();
+    }
+
+    std::format_context::iterator format(const TEventLogCountedValue& /*value*/, std::format_context& context) const
+    {
+        ++EventLogFormatCount;
+        return std::format_to(context.out(), "counted");
+    }
+};
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+using EventType = ASWLog::TASWWindowsEventLog::EventType;
+
+// A config with no startup or shutdown lines and only the level in each line, e.g. "[INFO]: message"
+ASWLog::TASWLogConfig MakeEventLogConfig()
+{
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Info;
+    config.Line.ShowTimestamp = false;
+    config.Line.ShowProcessId = false;
+    config.Line.ShowThreadId = false;
+    config.Shutdown.WriteLine = false;
+    config.Startup.WriteTimeInfo = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    return config;
+}
+
+// Counts the lines it formats
+class TCountingFormatter final : public ASWLog::IASWLogFormatter
+{
+public:
+    mutable int FormatCount = 0;
+
+    std::string Format(const ASWLog::TASWLogRecord& record, const ASWLog::TASWLogConfig& /*config*/) const override
+    {
+        ++FormatCount;
+        return std::string(record.Message);
+    }
+};
+
+// An Event Log logger that keeps the sources it would open and the events it would report, on every platform (where
+// there is no Event Log, the logger's own ShouldLog() and PrepareWriteUnlocked() would drop every entry)
+class TCapturingEventLog final : public ASWLog::TASWWindowsEventLog
+{
+public:
+    struct TEvent
+    {
+        EventType Type = EventType::Information;
+        std::uint16_t EventId = 0;
+        std::string Text;
+    };
+
+    std::vector<std::string> Sources;
+    std::vector<TEvent> Events;
+
+protected:
+    bool OpenEventSourceUnlocked(const std::string& source) override
+    {
+        Sources.push_back(source);
+        return true;
+    }
+
+    bool PrepareWriteUnlocked(std::chrono::system_clock::time_point /*now*/) override
+    {
+        return true;
+    }
+
+    void ReportEventUnlocked(EventType type, std::uint16_t eventId, std::string_view message) override
+    {
+        Events.push_back({ type, eventId, std::string(message) });
+    }
+
+public:
+    // The overrides above are used until the shutdown line
+    ~TCapturingEventLog() override
+    {
+        Finalize();
+    }
+
+    bool ShouldLog(ASWLog::Level level) const noexcept override
+    {
+        return ASWLog::TASWTextLogBase::ShouldLog(level);
+    }
+
+    bool ShouldLog(const ASWLog::TASWLogRecord& record) const noexcept override
+    {
+        return ASWLog::TASWTextLogBase::ShouldLog(record);
+    }
+
+    void WriteCrashLine(std::string_view line) noexcept
+    {
+        WriteCrashLineDirect(line);
+    }
+};
+
+#if defined(_WIN32)
+// An Event Log logger that reports each entry as an event too long for the Event Log, which refuses it
+class TOversizedEventLog final : public ASWLog::TASWWindowsEventLog
+{
+protected:
+    void WriteLineUnlocked(ASWLog::Level /*level*/, std::string_view /*line*/, bool /*endsLine*/) override
+    {
+        ReportEventUnlocked(EventType::Warning, 1003, std::string(40000, 'x'));
+    }
+
+public:
+    // The override above is used until the shutdown line
+    ~TOversizedEventLog() override
+    {
+        Finalize();
+    }
+};
+
+// An event read back from the Application log
+struct TReadEvent
+{
+    WORD Type = 0;
+    DWORD EventId = 0;
+    std::wstring Text;
+};
+
+// The newest event of 'source' in the Application log whose text contains 'token', or nothing if none came within two
+// seconds (the newest 1000 events are searched)
+std::optional<TReadEvent> FindEvent(const std::wstring& source, const std::wstring& token)
+{
+    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
+
+    do
+    {
+        const HANDLE log = OpenEventLogW(nullptr, L"Application");
+        if (log == nullptr)
+            return std::nullopt;
+
+        std::vector<BYTE> buffer(64 * 1024);
+        int recordCount = 0;
+        DWORD readSize = 0;
+        DWORD neededSize = 0;
+
+        while (recordCount < 1000)
+        {
+            if (!ReadEventLogW(log, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, buffer.data(), static_cast<DWORD>(buffer.size()), &readSize, &neededSize))
+            {
+                if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+                    break;
+
+                buffer.resize(neededSize);
+                continue;
+            }
+
+            for (DWORD offset = 0; offset < readSize; ++recordCount)
+            {
+                const auto* record = reinterpret_cast<const EVENTLOGRECORD*>(buffer.data() + offset);
+                const std::wstring recordSource(reinterpret_cast<const wchar_t*>(record + 1));
+                const std::wstring text = record->NumStrings > 0 ? std::wstring(reinterpret_cast<const wchar_t*>(buffer.data() + offset + record->StringOffset)) : std::wstring();
+
+                if (recordSource == source && text.find(token) != std::wstring::npos)
+                {
+                    CloseEventLog(log);
+                    return TReadEvent{ record->EventType, record->EventID, text };
+                }
+
+                offset += record->Length;
+            }
+        }
+
+        CloseEventLog(log);
+    } while (std::chrono::steady_clock::now() < deadline);
+
+    return std::nullopt;
+}
+
+// True if the process runs with administrator rights (elevated)
+bool IsElevated()
+{
+    HANDLE token = nullptr;
+    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
+        return false;
+
+    TOKEN_ELEVATION elevation{};
+    DWORD size = 0;
+    const bool isElevated = GetTokenInformation(token, TokenElevation, &elevation, sizeof(elevation), &size) && elevation.TokenIsElevated != 0;
+    CloseHandle(token);
+
+    return isElevated;
+}
+
+// The EventMessageFile value of 'source''s registry key (empty if it has none), or nothing if it has no key
+std::optional<std::wstring> ReadMessageFile(const std::wstring& source)
+{
+    const std::wstring key = L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\" + source;
+    HKEY sourceKey = nullptr;
+    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, key.c_str(), 0, KEY_QUERY_VALUE, &sourceKey) != ERROR_SUCCESS)
+        return std::nullopt;
+
+    wchar_t value[MAX_PATH]{};
+    DWORD size = sizeof(value);
+    const LSTATUS status = RegGetValueW(sourceKey, nullptr, L"EventMessageFile", RRF_RT_REG_EXPAND_SZ | RRF_NOEXPAND, nullptr, value, &size);
+    RegCloseKey(sourceKey);
+
+    return status == ERROR_SUCCESS ? std::wstring(value) : std::wstring();
+}
+
+// 'text' (ASCII) as a wide string
+std::wstring Widen(std::string_view text)
+{
+    return std::wstring(text.begin(), text.end());
+}
+#endif
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_WindowsEventLog
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_WindowsEventLog::TTest_ASWLog_WindowsEventLog()
+    : inherited("ASWLog_WindowsEventLog_Tests")
+{
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_GetInstance_ReturnsTheSameLogger, "GetInstance_ReturnsTheSameLogger");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_HandleCrash_ReportsTheFormattedCrashLineOnly, "HandleCrash_ReportsTheFormattedCrashLineOnly");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_Open_OpensTheConfiguredSource, "Open_OpensTheConfiguredSource");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_RegisterSource_NeedsAdministratorRights, "RegisterSource_NeedsAdministratorRights");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_Report_CutsTooLongMessages, "Report_CutsTooLongMessages");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_Report_MapsEachLevelToATypeAndEventId, "Report_MapsEachLevelToATypeAndEventId");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_Report_StripsOnlyTheLineEnding, "Report_StripsOnlyTheLineEnding");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_ShouldLog_FollowsThePlatform, "ShouldLog_FollowsThePlatform");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_Windows_ReportsAFailedOpen, "Windows_ReportsAFailedOpen");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_Windows_ReportsARealEvent, "Windows_ReportsARealEvent");
+    RegisterTest(&TTest_ASWLog_WindowsEventLog::Test_Windows_ReportsARefusedEvent, "Windows_ReportsARefusedEvent");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_WindowsEventLog::~TTest_ASWLog_WindowsEventLog()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::SetUp_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::SetUp_Test(ITestCase& /*testCase*/)
+{
+    EventLogFormatCount = 0;
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::TearDown_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::TearDown_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_GetInstance_ReturnsTheSameLogger()
+{
+    // Act
+    auto& first = ASWLog::TASWWindowsEventLog::GetInstance();
+    auto& second = ASWLog::TASWWindowsEventLog::GetInstance();
+
+    // Assert
+    CheckSame(&first, &second, "GetInstance() should always return the same logger");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_HandleCrash_ReportsTheFormattedCrashLineOnly()
+{
+    // Arrange
+    TCapturingEventLog log;
+    CheckTrue(log.Initialize(MakeEventLogConfig()), "Initialize should succeed");
+
+    // Act: a crash in normal context, then the direct write a crash with a busy lock would use
+    ASWLog::HandleCrash("test crash");
+    log.WriteCrashLine("[CRITICAL]: Crash: direct\n");
+
+    // Assert
+    AssertEquals(1, log.Events.size(), "Only the formatted crash line should be reported");
+    CheckEquals(EventType::Error, log.Events[0].Type, "The crash line should be an Error event");
+    CheckEquals(1005, log.Events[0].EventId, "The crash line should have Critical's event ID");
+    CheckEquals(std::string("[CRITICAL]: Crash: test crash"), log.Events[0].Text, "The crash line should be reported without its line ending");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_Open_OpensTheConfiguredSource()
+{
+    // Arrange
+    TCapturingEventLog log;
+    const auto config = MakeEventLogConfig();
+    auto appConfig = config;
+    appConfig.EventLog.Source = "MyApp";
+    const std::string executableStem = ASWLog::PathToUTF8String(ASWLog::GetExecutablePath().stem());
+
+    // Act
+    const bool initialized = log.Initialize(config);
+    const bool reconfigured = log.Reconfigure(appConfig);
+    const bool closed = log.Close();
+    const bool opened = log.Open();
+
+    // Assert
+    CheckTrue(initialized && reconfigured && closed && opened, "Initialize, Reconfigure, Close and Open should succeed");
+    CheckEmpty(config.EventLog.Source, "The default source should be empty (the executable's file name)");
+    AssertEquals(3, log.Sources.size(), "Initialize, Reconfigure and Open should each open the source");
+    CheckNotEmpty(executableStem, "The executable's file name should be known");
+    CheckEquals(executableStem, log.Sources[0], "Without a source, the executable's file name without its extension should be used");
+    CheckEquals(std::string("MyApp"), log.Sources[1], "Reconfigure should open the new source");
+    CheckEquals(std::string("MyApp"), log.Sources[2], "Open after Close should open the current config's source again");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_RegisterSource_NeedsAdministratorRights()
+{
+#if defined(_WIN32)
+    // Arrange: a source of this test's own; elevated (e.g. on a CI runner) it is registered and removed again
+    const std::wstring source = L"ASWLogTests_Registration";
+    const bool isElevated = IsElevated();
+    if (isElevated)
+        ASWLog::TASWWindowsEventLog::UnregisterSource("ASWLogTests_Registration");
+
+    // Act
+    const bool registered = ASWLog::TASWWindowsEventLog::RegisterSource("ASWLogTests_Registration");
+    const auto messageFile = ReadMessageFile(source);
+    const bool unregistered = ASWLog::TASWWindowsEventLog::UnregisterSource("ASWLogTests_Registration");
+    const auto messageFileAfter = ReadMessageFile(source);
+    const bool registeredNested = ASWLog::TASWWindowsEventLog::RegisterSource("ASWLogTests_Registration\\Nested");
+    const bool unregisteredNested = ASWLog::TASWWindowsEventLog::UnregisterSource("ASWLogTests_Registration\\Nested");
+
+    // Assert
+    CheckEquals(isElevated, registered, "RegisterSource() should succeed exactly when the process is elevated");
+    if (isElevated)
+    {
+        CheckTrue(messageFile == std::wstring(L"%SystemRoot%\\Microsoft.NET\\Framework\\v4.0.30319\\EventLogMessages.dll"), "The source's message file should be EventLogMessages.dll");
+        CheckTrue(unregistered, "UnregisterSource() should succeed when elevated");
+    }
+    else
+    {
+        CheckTrue(unregistered, "UnregisterSource() of a source that isn't registered should succeed");
+    }
+    CheckFalse(messageFile.has_value() && !isElevated, "Without administrator rights, no registry key should be made");
+    CheckFalse(messageFileAfter.has_value(), "After UnregisterSource(), the source should have no registry key");
+    CheckFalse(registeredNested, "A source holding a '\\' should not be registered");
+    CheckFalse(unregisteredNested, "A source holding a '\\' names no source to unregister");
+#else
+    // Act & Assert
+    CheckFalse(ASWLog::TASWWindowsEventLog::RegisterSource("ASWLogTests_Registration"), "Without an Event Log, RegisterSource() should fail");
+    CheckFalse(ASWLog::TASWWindowsEventLog::UnregisterSource("ASWLogTests_Registration"), "Without an Event Log, UnregisterSource() should fail");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_Report_CutsTooLongMessages()
+{
+    // Arrange: "[INFO]: " is 8 bytes. The longer line has 2-byte characters from byte MaxSize - 9 on, so the cut, which
+    // keeps MaxSize - 6 bytes for the " [cut]" marker, falls inside one and backs off to the character before it.
+    constexpr std::size_t MaxSize = ASWLog::TASWWindowsEventLog::MaxMessageSize;
+    TCapturingEventLog log;
+    CheckTrue(log.Initialize(MakeEventLogConfig()), "Initialize should succeed");
+    const std::string fitting(MaxSize - 8, 'x');
+    std::string tooLong(MaxSize - 8 - 9, 'y');
+    for (int i = 0; i < 20; ++i)
+        tooLong += "\xC3\xA9";
+
+    // Act
+    log.LogInfo(fitting);
+    log.LogInfo(tooLong);
+
+    // Assert
+    CheckEquals(31839, MaxSize, "The limit should be the Event Log's 31,839 characters");
+    AssertEquals(2, log.Events.size(), "Each entry should be one event");
+    CheckEquals("[INFO]: " + fitting, log.Events[0].Text, "A message that fits should be reported whole");
+    CheckLessThanOrEqual(log.Events[1].Text.size(), MaxSize, "A longer one should be cut to fit");
+    CheckEquals(MaxSize - 1, log.Events[1].Text.size(), "The cut should back off to the start of a 2-byte character");
+    CheckStartsWith(log.Events[1].Text, "[INFO]: yyy", "The start of the message should be kept");
+    CheckEndsWith(log.Events[1].Text, "\xC3\xA9 [cut]", "The cut should end with a whole character and the marker");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_Report_MapsEachLevelToATypeAndEventId()
+{
+    // Arrange
+    TCapturingEventLog log;
+    auto config = MakeEventLogConfig();
+    config.InitialMinimumLevel = ASWLog::Level::Trace;
+    auto tableConfig = config;
+    tableConfig.EventLog.EventIds = { 10, 20, 30, 40, 50, 65535 };
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+
+    // Act
+    log.LogTrace("trace");
+    log.LogDebug("debug");
+    log.LogInfo("info");
+    log.LogWarn("warn");
+    log.LogError("error");
+    log.LogCritical("critical");
+    log.LogRaw(ASWLog::Level::Warn, "raw");
+    CheckTrue(log.Reconfigure(tableConfig), "Reconfigure should succeed");
+    log.LogInfo("info");
+    log.LogCritical("critical");
+
+    // Assert
+    AssertEquals(9, log.Events.size(), "Each entry should be one event");
+    const EventType types[] = { EventType::Information, EventType::Information, EventType::Information, EventType::Warning, EventType::Error, EventType::Error, EventType::Warning, EventType::Information, EventType::Error };
+    const int eventIds[] = { 1000, 1001, 1002, 1003, 1004, 1005, 1003, 30, 65535 };
+    for (std::size_t i = 0; i < log.Events.size(); ++i)
+    {
+        CheckEquals(types[i], log.Events[i].Type, std::format("Event {} ({}) should have its level's type", i, log.Events[i].Text));
+        CheckEquals(eventIds[i], log.Events[i].EventId, std::format("Event {} ({}) should have its level's event ID", i, log.Events[i].Text));
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_Report_StripsOnlyTheLineEnding()
+{
+    // Arrange
+    TCapturingEventLog log;
+    auto crlfConfig = MakeEventLogConfig();
+    crlfConfig.Line.Ending = ASWLog::LineEnding::CRLF;
+    CheckTrue(log.Initialize(MakeEventLogConfig()), "Initialize should succeed");
+
+    // Act
+    log.LogInfo("hello");
+    log.LogInfo("ends with a break\n");
+    log.LogRaw(ASWLog::Level::Info, "raw text\n");
+    CheckTrue(log.Reconfigure(crlfConfig), "Reconfigure should succeed");
+    log.LogInfo("crlf");
+    log.LogInfo("ends with LF\n");
+
+    // Assert
+    AssertEquals(5, log.Events.size(), "Each entry should be one event");
+    CheckEquals(std::string("[INFO]: hello"), log.Events[0].Text, "The LF ending should be stripped");
+    CheckEquals(std::string("[INFO]: ends with a break\n"), log.Events[1].Text, "Only the line ending should be stripped, not the message's own break");
+    CheckEquals(std::string("raw text\n"), log.Events[2].Text, "A raw entry should be reported as is");
+    CheckEquals(std::string("[INFO]: crlf"), log.Events[3].Text, "The CRLF ending should be stripped");
+    CheckEquals(std::string("[INFO]: ends with LF\n"), log.Events[4].Text, "With CRLF endings, the message's own LF should stay");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_ShouldLog_FollowsThePlatform()
+{
+#if defined(_WIN32)
+    // Arrange: no startup or shutdown lines, and only checks, so nothing reaches the Event Log
+    ASWLog::TASWWindowsEventLog log;
+    ASWLog::TASWLogRecord infoRecord;
+    infoRecord.LogLevel = ASWLog::Level::Info;
+
+    // Act
+    const bool initialized = log.Initialize(MakeEventLogConfig());
+    log.LogDebugFmt("{}", TEventLogCountedValue{});
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed on every platform");
+    CheckEquals(0, EventLogFormatCount, "An entry below the minimum level should not be formatted");
+    CheckTrue(log.ShouldLog(ASWLog::Level::Info), "On Windows, ShouldLog() should follow the minimum level (Info)");
+    CheckFalse(log.ShouldLog(ASWLog::Level::Debug), "On Windows, ShouldLog() should follow the minimum level (Debug)");
+    CheckTrue(log.ShouldLog(infoRecord), "On Windows, ShouldLog(record) should follow the minimum level");
+#else
+    // Arrange: a startup and a shutdown line too, each of which would be formatted
+    auto config = MakeEventLogConfig();
+    const auto formatter = std::make_shared<const TCountingFormatter>();
+    config.Line.Formatter = formatter;
+    config.Startup.Banner = "banner";
+    config.Shutdown.WriteLine = true;
+    ASWLog::TASWLogRecord criticalRecord;
+    criticalRecord.LogLevel = ASWLog::Level::Critical;
+    bool initialized = false;
+    bool shouldLog = true;
+    bool shouldLogRecord = true;
+
+    // Act
+    {
+        ASWLog::TASWWindowsEventLog log;
+        initialized = log.Initialize(config);
+        shouldLog = log.ShouldLog(ASWLog::Level::Critical);
+        shouldLogRecord = log.ShouldLog(criticalRecord);
+        log.LogCriticalFmt("{}", TEventLogCountedValue{});
+        log.LogCritical("not formatted");
+    }
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed on every platform");
+    CheckFalse(shouldLog, "Without an Event Log, ShouldLog() should be false");
+    CheckFalse(shouldLogRecord, "Without an Event Log, ShouldLog(record) should be false");
+    CheckEquals(0, EventLogFormatCount, "Without an Event Log, no *Fmt arguments should be formatted");
+    CheckEquals(0, formatter->FormatCount, "Without an Event Log, no line (startup, entry or shutdown) should be formatted");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_Windows_ReportsAFailedOpen()
+{
+#if defined(_WIN32)
+    // Arrange: only the system (LSA) may report to the Security log, so other processes can't open it as a source
+    ASWLog::TASWWindowsEventLog log;
+    auto config = MakeEventLogConfig();
+    config.EventLog.Source = "Security";
+    std::vector<ASWLog::TASWLogError> errors;
+    config.OnError = [&errors](const ASWLog::TASWLogError& error) {
+            errors.push_back(error);
+        };
+
+    // Act
+    const bool initialized = log.Initialize(config);
+    if (initialized)
+        Skip("This process may report to the Security log");
+
+    // Assert
+    AssertEquals(1, errors.size(), "The failed open should be reported");
+    CheckEquals(ASWLog::ErrorKind::OpenFailed, errors[0].Kind, "It should be an OpenFailed error");
+    CheckContains(errors[0].Message, "'Security'", "It should name the source");
+    CheckEquals(ERROR_ACCESS_DENIED, errors[0].Code.value(), "It should carry the system's error");
+    CheckFalse(log.IsOpen(), "The logger should not be open");
+#else
+    Skip("Only Windows has an Event Log");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_Windows_ReportsARealEvent()
+{
+#if defined(_WIN32)
+    // Arrange: one Warning event of a test source in the Application log, found again by a token of this run
+    ASWLog::TASWWindowsEventLog log;
+    auto config = MakeEventLogConfig();
+    config.EventLog.Source = "ASWLogTests";
+    config.EventLog.EventIds[static_cast<std::size_t>(ASWLog::Level::Warn)] = 4321;
+    const std::string token = std::format("token {}", std::chrono::steady_clock::now().time_since_epoch().count());
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+
+    // Act
+    log.LogWarn("ASWLog unit test event, " + token);
+    const auto event = FindEvent(L"ASWLogTests", Widen(token));
+
+    // Assert
+    AssertTrue(event.has_value(), "The event should be in the Application log");
+    CheckEquals(EVENTLOG_WARNING_TYPE, event->Type, "It should be a Warning event");
+    CheckEquals(4321, event->EventId & 0xFFFF, "It should have Warn's event ID from the config");
+    CheckTrue(event->Text == Widen("[WARN]: ASWLog unit test event, " + token), "Its text should be the line without its ending");
+#else
+    Skip("Only Windows has an Event Log");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_WindowsEventLog::Test_Windows_ReportsARefusedEvent()
+{
+#if defined(_WIN32)
+    // Arrange: a real source, and an event the Event Log refuses (ERROR_INVALID_PARAMETER), so nothing is written
+    TOversizedEventLog log;
+    auto config = MakeEventLogConfig();
+    config.EventLog.Source = "ASWLogTests";
+    std::vector<ASWLog::TASWLogError> errors;
+    config.OnError = [&errors](const ASWLog::TASWLogError& error) {
+            errors.push_back(error);
+        };
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+
+    // Act
+    log.LogWarn("refused");
+
+    // Assert
+    AssertEquals(1, errors.size(), "The refused event should be reported");
+    CheckEquals(ASWLog::ErrorKind::WriteFailed, errors[0].Kind, "It should be a WriteFailed error");
+    CheckEquals(ERROR_INVALID_PARAMETER, errors[0].Code.value(), "It should carry the system's error");
+#else
+    Skip("Only Windows has an Event Log");
+#endif
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_WindowsEventLog)
diff --git a/tests/tests/Test_ASWLog_WindowsEventLog.h b/tests/tests/Test_ASWLog_WindowsEventLog.h
new file mode 100644
index 0000000..38b5f95
--- /dev/null
+++ b/tests/tests/Test_ASWLog_WindowsEventLog.h
@@ -0,0 +1,66 @@
+/* **************************************************************************
+Test_ASWLog_WindowsEventLog.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_WindowsEventLogH
+#define Test_ASWLog_WindowsEventLogH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_WindowsEventLog
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_WindowsEventLog : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_GetInstance_ReturnsTheSameLogger();
+    void Test_HandleCrash_ReportsTheFormattedCrashLineOnly();
+    void Test_Open_OpensTheConfiguredSource();
+    void Test_RegisterSource_NeedsAdministratorRights();
+    void Test_Report_CutsTooLongMessages();
+    void Test_Report_MapsEachLevelToATypeAndEventId();
+    void Test_Report_StripsOnlyTheLineEnding();
+    void Test_ShouldLog_FollowsThePlatform();
+    void Test_Windows_ReportsAFailedOpen();
+    void Test_Windows_ReportsARealEvent();
+    void Test_Windows_ReportsARefusedEvent();
+
+public:
+    TTest_ASWLog_WindowsEventLog();
+    ~TTest_ASWLog_WindowsEventLog() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_WindowsEventLogH
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index 34ef252..8145d85 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -260,6 +260,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Version.h</DependentOn>
             <BuildOrder>38</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_WindowsEventLog.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_WindowsEventLog.h</DependentOn>
+            <BuildOrder>60</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_Base.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_Base.h</DependentOn>
             <BuildOrder>27</BuildOrder>
@@ -328,6 +332,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_Version.h</DependentOn>
             <BuildOrder>39</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_WindowsEventLog.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_WindowsEventLog.h</DependentOn>
+            <BuildOrder>61</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\UT_Helper_DateTime.cpp">
             <DependentOn>..\..\..\tests\UT_Helper_DateTime.h</DependentOn>
             <BuildOrder>44</BuildOrder>

From cf7fbde90f9126caf7e9283195dd263e423bc301 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 09:13:32 -0700
Subject: [PATCH 18/38] Add rate-limited logging helpers

---
 ASWLog/ASWLog_Limiter.cpp                     | 102 +++++
 ASWLog/ASWLog_Limiter.h                       | 186 ++++++++
 CHANGELOG.md                                  |  12 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 README.md                                     |   3 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 tests/cmake/CMakeLists.txt                    |   1 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_Limiter.cpp           | 421 ++++++++++++++++++
 tests/tests/Test_ASWLog_Limiter.h             |  65 +++
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 12 files changed, 816 insertions(+)
 create mode 100644 ASWLog/ASWLog_Limiter.cpp
 create mode 100644 ASWLog/ASWLog_Limiter.h
 create mode 100644 tests/tests/Test_ASWLog_Limiter.cpp
 create mode 100644 tests/tests/Test_ASWLog_Limiter.h

diff --git a/ASWLog/ASWLog_Limiter.cpp b/ASWLog/ASWLog_Limiter.cpp
new file mode 100644
index 0000000..42f1098
--- /dev/null
+++ b/ASWLog/ASWLog_Limiter.cpp
@@ -0,0 +1,102 @@
+/* **************************************************************************
+ASWLog_Limiter.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_Limiter.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogLimiter
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+bool TASWLogLimiter::Allow() noexcept
+{
+    std::uint64_t refusedCount = 0;
+
+    return Allow(refusedCount);
+}
+
+//---------------------------------------------------------------------------
+bool TASWLogLimiter::Allow(std::uint64_t& refusedCount) noexcept
+{
+    // Only EveryInterval() needs the time
+    return Allow(refusedCount, m_Kind == Kind::EveryInterval ? std::chrono::steady_clock::now() : std::chrono::steady_clock::time_point());
+}
+
+//---------------------------------------------------------------------------
+bool TASWLogLimiter::Allow(std::uint64_t& refusedCount, std::chrono::steady_clock::time_point now) noexcept
+{
+    refusedCount = 0;
+
+    switch (m_Kind)
+    {
+        case Kind::Once:
+            // Without a write once it has allowed its call, so the calls after it don't contend for the cache line
+            return m_CallCount.load(std::memory_order_relaxed) == 0 && m_CallCount.exchange(1, std::memory_order_relaxed) == 0;
+
+        case Kind::EveryN:
+        {
+            const std::uint64_t call = m_CallCount.fetch_add(1, std::memory_order_relaxed);
+
+            if (call % m_N != 0)
+                return false;
+
+            refusedCount = call > 0 ? m_N - 1 : 0;
+
+            return true;
+        }
+
+        case Kind::EveryInterval:
+        {
+            if (m_IntervalTicks <= 0)
+                return true;
+
+            const auto nowTicks = now.time_since_epoch().count();
+            auto nextAllowed = m_NextAllowedTicks.load(std::memory_order_relaxed);
+            constexpr auto MaxTicks = std::numeric_limits<std::chrono::steady_clock::rep>::max();
+            // The time from which the call after this one is allowed, at most the clock's end
+            const auto newNextAllowed = nowTicks > 0 && m_IntervalTicks > MaxTicks - nowTicks ? MaxTicks : nowTicks + m_IntervalTicks;
+
+            // Of the calls that see the interval over, only the one that moves the next allowed time on is allowed
+            if (nowTicks < nextAllowed || !m_NextAllowedTicks.compare_exchange_strong(nextAllowed, newNextAllowed, std::memory_order_relaxed))
+            {
+                m_RefusedCount.fetch_add(1, std::memory_order_relaxed);
+                return false;
+            }
+
+            refusedCount = m_RefusedCount.exchange(0, std::memory_order_relaxed);
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_Limiter.h b/ASWLog/ASWLog_Limiter.h
new file mode 100644
index 0000000..8bcf342
--- /dev/null
+++ b/ASWLog/ASWLog_Limiter.h
@@ -0,0 +1,186 @@
+/* **************************************************************************
+ASWLog_Limiter.h
+Author: Anthony S. West - ASW Software
+
+A logging library.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_LimiterH
+#define ASWLog_LimiterH
+//---------------------------------------------------------------------------
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <limits>
+//---------------------------------------------------------------------------
+#include "ASWLog_Fields.h"
+#include "ASWLog_Types.h"
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogLimiter
+//
+// Decides which of the calls at one place in the code may log, so that an entry that can repeat often (e.g. in a loop,
+// or for every failed retry) doesn't flood the log: only the first call (Once()), every nth call (EveryN()), or at
+// most one call per interval (EveryInterval()). Lock-free and thread-safe: calls from several threads share one
+// limiter, and exactly the calls it allows are allowed. Usually kept in a static at the place it limits, which is what
+// the ASWLOG_ONCE(), ASWLOG_EVERY_N() and ASWLOG_EVERY_INTERVAL() macros below do; it can also be used on its own:
+//
+//     static ASWLog::TASWLogLimiter limiter = ASWLog::TASWLogLimiter::EveryInterval(std::chrono::seconds(5));
+//     if (log.ShouldLog(ASWLog::Level::Warn) && limiter.Allow())
+//         log.LogWarnFmt("Retrying {}", host);
+//
+// Check the level first, as above, so that calls the logger would drop don't count against the limit.
+/////////////////////////////////////////////////////////////////////////////
+class TASWLogLimiter
+{
+private:
+    enum class Kind
+    {
+        Once,
+        EveryN,
+        EveryInterval,
+    };
+
+    Kind m_Kind;
+    std::uint64_t m_N; // EveryN's n
+    std::chrono::steady_clock::rep m_IntervalTicks; // EveryInterval's interval, in steady_clock ticks
+    std::atomic<std::uint64_t> m_CallCount{ 0 }; // Once and EveryN: the calls so far
+    // EveryInterval: the time (in steady_clock ticks) from which the next call is allowed, and the calls refused since
+    // the last one allowed
+    std::atomic<std::chrono::steady_clock::rep> m_NextAllowedTicks{ std::numeric_limits<std::chrono::steady_clock::rep>::min() };
+    std::atomic<std::uint64_t> m_RefusedCount{ 0 };
+
+    constexpr TASWLogLimiter(Kind kind, std::uint64_t n, std::chrono::steady_clock::rep intervalTicks) noexcept
+        : m_Kind(kind),
+          m_N(n),
+          m_IntervalTicks(intervalTicks)
+    {
+    }
+
+public: // Static methods
+    // Allows at most one call per 'interval', measured on std::chrono::steady_clock from the call it allowed last: the
+    // first call, then the first one after the interval has passed. An interval of 0 or less allows every call.
+    [[nodiscard]] static constexpr TASWLogLimiter EveryInterval(std::chrono::steady_clock::duration interval) noexcept
+    {
+        return TASWLogLimiter(Kind::EveryInterval, 0, interval.count());
+    }
+
+    // Allows every nth call: the 1st, the n+1st, the 2n+1st, and so on. An n of 0 or 1 allows every call.
+    [[nodiscard]] static constexpr TASWLogLimiter EveryN(std::uint64_t n) noexcept
+    {
+        return TASWLogLimiter(Kind::EveryN, n > 0 ? n : 1, 0);
+    }
+
+    // Allows the first call only
+    [[nodiscard]] static constexpr TASWLogLimiter Once() noexcept
+    {
+        return TASWLogLimiter(Kind::Once, 0, 0);
+    }
+
+public:
+    // Not copyable (the factories above are used to initialize one in place, e.g. 'static auto l = EveryN(10);')
+    TASWLogLimiter(const TASWLogLimiter&) = delete;
+    TASWLogLimiter& operator=(const TASWLogLimiter&) = delete;
+
+    // True if this call may log
+    bool Allow() noexcept;
+    // The same; when it allows the call, 'refusedCount' gets how many calls it refused since the one it allowed before
+    // (0 for the first, and always 0 for Once()), otherwise 0. With EveryInterval(), a call refused on another thread
+    // at the moment this one is allowed may be counted here or with the next allowed call (each refused call once).
+    bool Allow(std::uint64_t& refusedCount) noexcept;
+    // The same at the time 'now' (for EveryInterval(); the others ignore it), e.g. for tests
+    bool Allow(std::uint64_t& refusedCount, std::chrono::steady_clock::time_point now) noexcept;
+};
+
+} // namespace ASWLog
+
+//---------------------------------------------------------------------------
+// Rate-limited logging at one place in the code. Each macro keeps a static TASWLogLimiter where it is written, and
+// logs through logger.LogFmt(level, ...), so the arguments after 'level' are those of LogFmt(): a format string and its
+// arguments, optionally preceded by fields, e.g.
+//
+//     ASWLOG_ONCE(log, ASWLog::Level::Warn, "Config file {} not found, using defaults", path);
+//     ASWLOG_EVERY_N(log, 1000, ASWLog::Level::Debug, "Processed {} items", count);
+//     ASWLOG_EVERY_INTERVAL(log, std::chrono::seconds(5), ASWLog::Level::Warn, {{"host", host}}, "Retrying");
+//
+// The message is a format string, so write a literal brace as {{ or }}. The entry keeps the caller's source location.
+// Only calls the logger would write count against the limit: ShouldLog(level) is checked first, so a call the level
+// filters out costs what a filtered LogFmt() call does, and e.g. ASWLOG_ONCE() at Debug logs the first time the
+// logger's level lets Debug through. The arguments are only formatted for an entry that is written.
+// ASWLOG_EVERY_INTERVAL() adds a field "suppressed" with the number of calls it skipped since its previous entry, if
+// any. 'n' and 'interval' are read the first time the macro runs. In a template, each instantiation has a limiter of
+// its own.
+//---------------------------------------------------------------------------
+
+// Logs the first time it would be written
+#define ASWLOG_ONCE(logger, level, ...) \
+        do \
+        { \
+            static ::ASWLog::TASWLogLimiter aswlogLimiter = ::ASWLog::TASWLogLimiter::Once(); \
+            auto& aswlogLogger = (logger); \
+            const ::ASWLog::Level aswlogLevel = (level); \
+            if (aswlogLogger.ShouldLog(aswlogLevel) && aswlogLimiter.Allow()) \
+                aswlogLogger.LogFmt(aswlogLevel, __VA_ARGS__); \
+        } \
+        while (false)
+
+// Logs every nth time it would be written, starting with the first
+#define ASWLOG_EVERY_N(logger, n, level, ...) \
+        do \
+        { \
+            static ::ASWLog::TASWLogLimiter aswlogLimiter = ::ASWLog::TASWLogLimiter::EveryN(n); \
+            auto& aswlogLogger = (logger); \
+            const ::ASWLog::Level aswlogLevel = (level); \
+            if (aswlogLogger.ShouldLog(aswlogLevel) && aswlogLimiter.Allow()) \
+                aswlogLogger.LogFmt(aswlogLevel, __VA_ARGS__); \
+        } \
+        while (false)
+
+// Logs at most once per 'interval' (a std::chrono duration), with a "suppressed" field after skipped calls
+#define ASWLOG_EVERY_INTERVAL(logger, interval, level, ...) \
+        do \
+        { \
+            static ::ASWLog::TASWLogLimiter aswlogLimiter = ::ASWLog::TASWLogLimiter::EveryInterval(interval); \
+            auto& aswlogLogger = (logger); \
+            const ::ASWLog::Level aswlogLevel = (level); \
+            ::std::uint64_t aswlogSuppressed = 0; \
+            if (aswlogLogger.ShouldLog(aswlogLevel) && aswlogLimiter.Allow(aswlogSuppressed)) \
+            { \
+                if (aswlogSuppressed == 0) \
+                { \
+                    aswlogLogger.LogFmt(aswlogLevel, __VA_ARGS__); \
+                } \
+                else \
+                { \
+                    const ::ASWLog::TASWLogScope aswlogScope{ { "suppressed", aswlogSuppressed } }; \
+                    aswlogLogger.LogFmt(aswlogLevel, __VA_ARGS__); \
+                } \
+            } \
+        } \
+        while (false)
+
+//---------------------------------------------------------------------------
+#endif // #ifndef ASWLog_LimiterH
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 713bc7b..cc59415 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -190,6 +190,18 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   without "The description for Event ID ... cannot be found".
   `TASWWindowsEventLog::GetInstance()` gives the shared one. Other platforms
   have no Event Log: there the class builds but writes nothing.
+- Rate-limited logging (new `ASWLog_Limiter.h`): `ASWLOG_ONCE(log, level,
+  ...)`, `ASWLOG_EVERY_N(log, n, level, ...)` and `ASWLOG_EVERY_INTERVAL(log,
+  interval, level, ...)` log only the first, every nth, or at most one entry
+  per interval at the place they are written, e.g.
+  `ASWLOG_EVERY_INTERVAL(log, std::chrono::seconds(5), ASWLog::Level::Warn,
+  "Retrying {}", host);`. The arguments after the level are those of
+  `LogFmt()` (format string, arguments, optional fields). Only entries the
+  logger would write count, and only those are formatted. After skipped calls,
+  `ASWLOG_EVERY_INTERVAL` adds a `suppressed` field with their number. The
+  macros keep a lock-free `TASWLogLimiter` (`Once()`, `EveryN()`,
+  `EveryInterval()`) in a static where they are written; the class can also be
+  used on its own.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0eea1de..6a49ac8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,6 +38,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_Formatter.h
     ASWLog/ASWLog_Interface.cpp
     ASWLog/ASWLog_Interface.h
+    ASWLog/ASWLog_Limiter.cpp
+    ASWLog/ASWLog_Limiter.h
     ASWLog/ASWLog_MemoryLog.cpp
     ASWLog/ASWLog_MemoryLog.h
     ASWLog/ASWLog_MultiLog.cpp
diff --git a/Deploy.bat b/Deploy.bat
index c9c9d7d..3aa5480 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -104,6 +104,10 @@ call :CopyFile "ASWLog\ASWLog_Interface.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Interfa
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Interface.h" "%TARGET_DIR%\ASWLog\ASWLog_Interface.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_Limiter.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Limiter.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_Limiter.h" "%TARGET_DIR%\ASWLog\ASWLog_Limiter.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_MemoryLog.cpp" "%TARGET_DIR%\ASWLog\ASWLog_MemoryLog.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_MemoryLog.h" "%TARGET_DIR%\ASWLog\ASWLog_MemoryLog.h"
diff --git a/README.md b/README.md
index 66877ee..9280917 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,9 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
 - Multi-line messages (e.g. an HTTP body) written as they are, or, with `TASWLogConfig::Line.Multiline`, each line after
   the first marked with `    | ` (`MultilineMode::Indent`) or the line breaks escaped as `\r` and `\n`
   (`MultilineMode::Escape`), so that every entry is recognizable as one.
+- Rate-limited logging for entries that can repeat often: `ASWLOG_ONCE`, `ASWLOG_EVERY_N` and `ASWLOG_EVERY_INTERVAL`
+  (`ASWLog_Limiter.h`), e.g. `ASWLOG_EVERY_INTERVAL(log, std::chrono::seconds(5), ASWLog::Level::Warn, "Retrying {}",
+  host);`, which counts the skipped entries in a `suppressed` field.
 - A hook to drop or change entries before they are written (`TASWLogConfig::OnBeforeWrite`), e.g. to redact secrets
   or drop noisy entries by content, category or field.
 - Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index edbbab7..1347e3a 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -175,6 +175,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Interface.h</DependentOn>
             <BuildOrder>6</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_Limiter.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_Limiter.h</DependentOn>
+            <BuildOrder>21</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_MemoryLog.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_MemoryLog.h</DependentOn>
             <BuildOrder>17</BuildOrder>
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index 0690883..dc0bad4 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -41,6 +41,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Fields.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_FileLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Formatter.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_Limiter.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_MemoryLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_MultiLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_NullLog.cpp"
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index 9850d1b..358507e 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -190,6 +190,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Interface.h</DependentOn>
             <BuildOrder>4</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_Limiter.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_Limiter.h</DependentOn>
+            <BuildOrder>51</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_MemoryLog.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_MemoryLog.h</DependentOn>
             <BuildOrder>43</BuildOrder>
@@ -266,6 +270,10 @@
             <DependentOn>..\tests\Test_ASWLog_Formatter.h</DependentOn>
             <BuildOrder>29</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_Limiter.cpp">
+            <DependentOn>..\tests\Test_ASWLog_Limiter.h</DependentOn>
+            <BuildOrder>52</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_MemoryLog.cpp">
             <DependentOn>..\tests\Test_ASWLog_MemoryLog.h</DependentOn>
             <BuildOrder>44</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_Limiter.cpp b/tests/tests/Test_ASWLog_Limiter.cpp
new file mode 100644
index 0000000..2498066
--- /dev/null
+++ b/tests/tests/Test_ASWLog_Limiter.cpp
@@ -0,0 +1,421 @@
+/* **************************************************************************
+Test_ASWLog_Limiter.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_Limiter.h"
+//---------------------------------------------------------------------------
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <format>
+#include <optional>
+#include <source_location>
+#include <string>
+#include <thread>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_Limiter.h"
+#include "ASWLog_MemoryLog.h"
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+// A value whose formatting is counted in LimiterFormatCount, to check whether a macro formats its arguments
+struct TLimiterCountedValue
+{
+};
+
+int LimiterFormatCount = 0;
+
+} // namespace
+
+template<>
+struct std::formatter<TLimiterCountedValue>
+{
+    constexpr std::format_parse_context::iterator parse(std::format_parse_context& context)
+    {
+        return context.begin();
+    }
+
+    std::format_context::iterator format(const TLimiterCountedValue& /*value*/, std::format_context& context) const
+    {
+        ++LimiterFormatCount;
+        return std::format_to(context.out(), "counted");
+    }
+};
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+using namespace std::chrono_literals;
+
+// A config with no startup or shutdown lines and only the level and the fields in each line, e.g. "[INFO]: message"
+ASWLog::TASWLogConfig MakeLimiterConfig()
+{
+    ASWLog::TASWLogConfig config;
+    config.InitialMinimumLevel = ASWLog::Level::Info;
+    config.Line.ShowTimestamp = false;
+    config.Line.ShowProcessId = false;
+    config.Line.ShowThreadId = false;
+    config.Shutdown.WriteLine = false;
+    config.Startup.WriteTimeInfo = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    return config;
+}
+
+// Each macro's call site, which keeps its limiter for the whole process
+void LogEveryFourth(ASWLog::IASWLog& log, ASWLog::Level level, int value)
+{
+    ASWLOG_EVERY_N(log, 4, level, "Item {}", value);
+}
+
+void LogOnce(ASWLog::IASWLog& log, ASWLog::Level level)
+{
+    ASWLOG_ONCE(log, level, "Once {}", TLimiterCountedValue{});
+}
+
+void LogRetry(ASWLog::IASWLog& log, int attempt)
+{
+    ASWLOG_EVERY_INTERVAL(log, 20ms, ASWLog::Level::Warn, { { "attempt", attempt } }, "Retrying");
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_Limiter
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_Limiter::TTest_ASWLog_Limiter()
+    : inherited("ASWLog_Limiter_Tests")
+{
+    RegisterTest(&TTest_ASWLog_Limiter::Test_EveryInterval_AllowsOneCallPerInterval, "EveryInterval_AllowsOneCallPerInterval");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_EveryInterval_HandlesTheLongestInterval, "EveryInterval_HandlesTheLongestInterval");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_EveryInterval_ZeroAllowsEveryCall, "EveryInterval_ZeroAllowsEveryCall");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_EveryN_AllowsEveryNthCall, "EveryN_AllowsEveryNthCall");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_Macros_EveryIntervalAddsTheSuppressedField, "Macros_EveryIntervalAddsTheSuppressedField");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_Macros_EveryNCountsOnlyEntriesThatWouldBeWritten, "Macros_EveryNCountsOnlyEntriesThatWouldBeWritten");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_Macros_KeepTheCallersSourceLocation, "Macros_KeepTheCallersSourceLocation");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_Macros_OnceLogsTheFirstEntryThatWouldBeWritten, "Macros_OnceLogsTheFirstEntryThatWouldBeWritten");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_Once_AllowsOnlyTheFirstCall, "Once_AllowsOnlyTheFirstCall");
+    RegisterTest(&TTest_ASWLog_Limiter::Test_Threads_AllowExactlyTheLimitedCalls, "Threads_AllowExactlyTheLimitedCalls");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_Limiter::~TTest_ASWLog_Limiter()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::SetUp_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::SetUp_Test(ITestCase& /*testCase*/)
+{
+    LimiterFormatCount = 0;
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::TearDown_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::TearDown_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_EveryInterval_AllowsOneCallPerInterval()
+{
+    // Arrange
+    auto limiter = ASWLog::TASWLogLimiter::EveryInterval(5s);
+    const std::chrono::steady_clock::time_point start(100s);
+    std::uint64_t refused[7]{};
+
+    // Act: 0 s allowed; 1, 2 and 4.999 s refused; 5 s allowed (the interval runs from there); 9 s refused; 10 s allowed
+    const bool first = limiter.Allow(refused[0], start);
+    const bool second = limiter.Allow(refused[1], start + 1s);
+    const bool third = limiter.Allow(refused[2], start + 2s);
+    const bool justBefore = limiter.Allow(refused[3], start + 4999ms);
+    const bool atInterval = limiter.Allow(refused[4], start + 5s);
+    const bool afterIt = limiter.Allow(refused[5], start + 9s);
+    const bool atNextInterval = limiter.Allow(refused[6], start + 10s);
+
+    // Assert
+    CheckTrue(first, "The first call should be allowed");
+    CheckFalse(second || third || justBefore, "The calls within the interval should be refused");
+    CheckTrue(atInterval, "The first call once the interval has passed should be allowed");
+    CheckFalse(afterIt, "The interval should run from the call allowed last");
+    CheckTrue(atNextInterval, "The first call once the next interval has passed should be allowed");
+    CheckEquals(0, refused[0], "The first call follows no refused ones");
+    CheckEquals(0, refused[1] + refused[2] + refused[3] + refused[5], "A refused call should get a count of 0");
+    CheckEquals(3, refused[4], "The allowed call should get the count of the calls refused since the one before");
+    CheckEquals(1, refused[6], "The count should start again after each allowed call");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_EveryInterval_HandlesTheLongestInterval()
+{
+    // Arrange: the time after the allowed call would overflow the clock's ticks
+    auto limiter = ASWLog::TASWLogLimiter::EveryInterval(std::chrono::steady_clock::duration::max());
+    const std::chrono::steady_clock::time_point start(100s);
+    std::uint64_t refused = 0;
+
+    // Act
+    const bool first = limiter.Allow(refused, start);
+    const bool later = limiter.Allow(refused, start + std::chrono::hours(24 * 365));
+
+    // Assert
+    CheckTrue(first, "The first call should be allowed");
+    CheckFalse(later, "A call within the (longest) interval should be refused, not allowed by a wrapped time");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_EveryInterval_ZeroAllowsEveryCall()
+{
+    // Arrange
+    auto zero = ASWLog::TASWLogLimiter::EveryInterval(0s);
+    auto negative = ASWLog::TASWLogLimiter::EveryInterval(-1s);
+    const std::chrono::steady_clock::time_point now(100s);
+    std::uint64_t refused = 0;
+    int allowed = 0;
+
+    // Act
+    for (int i = 0; i < 3; ++i)
+        allowed += (zero.Allow(refused, now) ? 1 : 0) + (negative.Allow(refused, now) ? 1 : 0);
+
+    // Assert
+    CheckEquals(6, allowed, "An interval of 0 or less should allow every call");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_EveryN_AllowsEveryNthCall()
+{
+    // Arrange
+    auto everyThird = ASWLog::TASWLogLimiter::EveryN(3);
+    auto everyZeroth = ASWLog::TASWLogLimiter::EveryN(0);
+    std::string pattern;
+    std::vector<std::uint64_t> refusedCounts;
+    int zerothAllowed = 0;
+
+    // Act
+    for (int i = 0; i < 8; ++i)
+    {
+        std::uint64_t refused = 0;
+        const bool allowed = everyThird.Allow(refused);
+        pattern += allowed ? 'x' : '.';
+        if (allowed)
+            refusedCounts.push_back(refused);
+
+        zerothAllowed += everyZeroth.Allow() ? 1 : 0;
+    }
+
+    // Assert
+    CheckEquals(std::string("x..x..x."), pattern, "The 1st, 4th and 7th calls should be allowed");
+    AssertEquals(3, refusedCounts.size(), "Three calls should be allowed");
+    CheckEquals(0, refusedCounts[0], "The first follows no refused calls");
+    CheckEquals(2, refusedCounts[1], "Each later one follows n - 1 refused calls");
+    CheckEquals(8, zerothAllowed, "An n of 0 should allow every call");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_Macros_EveryIntervalAddsTheSuppressedField()
+{
+    // The call site's limiter lasts for the process
+    static int runCount = 0;
+    if (runCount++ > 0)
+        Skip("The macro's limiter keeps its state for the process, so this test runs once per process");
+
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeLimiterConfig()), "Initialize should succeed");
+    const auto deadline = std::chrono::steady_clock::now() + 2s;
+    int calls = 0;
+
+    // Act: call until the interval has passed and a second entry is written (a bounded wait on that)
+    while (log.GetLineCount() < 2 && std::chrono::steady_clock::now() < deadline)
+        LogRetry(log, calls++);
+
+    // Assert
+    const auto lines = log.GetLines();
+    AssertEquals(2, lines.size(), "The first call and the first one after the interval should be written");
+    CheckGreaterThan(calls, 2, "Calls within the interval should have been skipped");
+    CheckEquals(std::string("[WARN][attempt=0]: Retrying"), lines[0], "The first entry follows no skipped calls");
+    CheckEquals(std::format("[WARN][suppressed={} attempt={}]: Retrying", calls - 2, calls - 1), lines[1],
+        "The next entry should say how many calls were skipped, with the call's own fields");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_Macros_EveryNCountsOnlyEntriesThatWouldBeWritten()
+{
+    static int runCount = 0;
+    if (runCount++ > 0)
+        Skip("The macro's limiter keeps its state for the process, so this test runs once per process");
+
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeLimiterConfig()), "Initialize should succeed");
+
+    // Act: Debug calls are filtered out (Info is the minimum level), so they don't count
+    for (int i = 1; i <= 10; ++i)
+    {
+        LogEveryFourth(log, ASWLog::Level::Debug, -i);
+        LogEveryFourth(log, ASWLog::Level::Info, i);
+    }
+
+    // Assert
+    const auto lines = log.GetLines();
+    AssertEquals(3, lines.size(), "Every 4th written entry of 10 should be written");
+    CheckEquals(std::string("[INFO]: Item 1"), lines[0], "The first entry should be written");
+    CheckEquals(std::string("[INFO]: Item 5"), lines[1], "Then the 5th");
+    CheckEquals(std::string("[INFO]: Item 9"), lines[2], "Then the 9th");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_Macros_KeepTheCallersSourceLocation()
+{
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    auto config = MakeLimiterConfig();
+    std::optional<std::source_location> location;
+    config.OnLogEntryMinimumLevel = ASWLog::Level::Trace;
+    config.OnLogEntry = [&location](const ASWLog::TASWLogRecord& record, std::string_view /*formattedLine*/) {
+            location = record.Location;
+        };
+    CheckTrue(log.Initialize(config), "Initialize should succeed");
+
+    // Act
+    const auto expectedLine = static_cast<std::uint_least32_t>(__LINE__ + 1);
+    ASWLOG_EVERY_N(log, 1, ASWLog::Level::Info, "located");
+
+    // Assert
+    AssertTrue(location.has_value(), "The entry should be written");
+    CheckEquals(expectedLine, location->line(), "The entry should have the macro's line");
+    CheckContains(std::string(location->function_name()), "Test_Macros_KeepTheCallersSourceLocation", "The entry should have the calling function");
+    CheckEndsWith(std::string(location->file_name()), "Test_ASWLog_Limiter.cpp", "The entry should have the calling file");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_Macros_OnceLogsTheFirstEntryThatWouldBeWritten()
+{
+    static int runCount = 0;
+    if (runCount++ > 0)
+        Skip("The macro's limiter keeps its state for the process, so this test runs once per process");
+
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    CheckTrue(log.Initialize(MakeLimiterConfig()), "Initialize should succeed");
+
+    // Act: filtered calls first (Debug, with Info the minimum level), then the level lets Debug through
+    LogOnce(log, ASWLog::Level::Debug);
+    LogOnce(log, ASWLog::Level::Debug);
+    const auto filteredLineCount = log.GetLineCount();
+    log.SetMinimumLevel(ASWLog::Level::Debug);
+    for (int i = 0; i < 3; ++i)
+        LogOnce(log, ASWLog::Level::Debug);
+
+    // Assert
+    CheckEquals(0, filteredLineCount, "Filtered calls should write nothing");
+    const auto lines = log.GetLines();
+    AssertEquals(1, lines.size(), "Only the first entry that would be written should be written");
+    CheckEquals(std::string("[DEBUG]: Once counted"), lines[0], "It should be the formatted entry");
+    CheckEquals(1, LimiterFormatCount, "Only the written entry's arguments should be formatted");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_Once_AllowsOnlyTheFirstCall()
+{
+    // Arrange
+    auto limiter = ASWLog::TASWLogLimiter::Once();
+    std::uint64_t refused = 99;
+
+    // Act
+    const bool first = limiter.Allow(refused);
+    const auto firstRefused = refused;
+    const bool second = limiter.Allow(refused);
+    const bool third = limiter.Allow();
+
+    // Assert
+    CheckTrue(first, "The first call should be allowed");
+    CheckEquals(0, firstRefused, "The first call follows no refused ones");
+    CheckFalse(second || third, "Later calls should be refused");
+    CheckEquals(0, refused, "A refused call should get a count of 0");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Limiter::Test_Threads_AllowExactlyTheLimitedCalls()
+{
+    // Arrange: threads sharing each kind of limiter (also for ThreadSanitizer), EveryInterval at one fixed time
+    constexpr int ThreadCount = 8;
+    constexpr int CallsPerThread = 1000;
+    auto once = ASWLog::TASWLogLimiter::Once();
+    auto everySeventh = ASWLog::TASWLogLimiter::EveryN(7);
+    auto everyHour = ASWLog::TASWLogLimiter::EveryInterval(1h);
+    const std::chrono::steady_clock::time_point now(100s);
+    std::atomic<int> onceAllowed{ 0 };
+    std::atomic<int> everySeventhAllowed{ 0 };
+    std::atomic<int> everyHourAllowed{ 0 };
+    std::atomic<std::uint64_t> everyHourRefused{ 0 };
+    std::vector<std::thread> threads;
+
+    // Act
+    for (int t = 0; t < ThreadCount; ++t)
+    {
+        threads.emplace_back([&] {
+                std::uint64_t refused = 0;
+                for (int i = 0; i < CallsPerThread; ++i)
+                {
+                    onceAllowed += once.Allow(refused, now) ? 1 : 0;
+                    everySeventhAllowed += everySeventh.Allow(refused, now) ? 1 : 0;
+                    if (everyHour.Allow(refused, now))
+                    {
+                        ++everyHourAllowed;
+                        everyHourRefused += refused;
+                    }
+                }
+            });
+    }
+
+    for (auto& thread : threads)
+        thread.join();
+
+    std::uint64_t nextHourRefused = 0;
+    const bool nextHour = everyHour.Allow(nextHourRefused, now + 1h);
+
+    // Assert: a call refused while another was allowed may be counted with either allowed call, but each just once
+    CheckEquals(1, onceAllowed.load(), "Once should allow exactly one call");
+    CheckEquals((ThreadCount * CallsPerThread + 6) / 7, everySeventhAllowed.load(), "EveryN should allow exactly every 7th call");
+    CheckEquals(1, everyHourAllowed.load(), "EveryInterval should allow exactly one call at one time");
+    CheckTrue(nextHour, "A call an interval later should be allowed");
+    CheckEquals(ThreadCount * CallsPerThread - 1, everyHourRefused.load() + nextHourRefused, "Every refused call should be counted once");
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_Limiter)
diff --git a/tests/tests/Test_ASWLog_Limiter.h b/tests/tests/Test_ASWLog_Limiter.h
new file mode 100644
index 0000000..be141b4
--- /dev/null
+++ b/tests/tests/Test_ASWLog_Limiter.h
@@ -0,0 +1,65 @@
+/* **************************************************************************
+Test_ASWLog_Limiter.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_LimiterH
+#define Test_ASWLog_LimiterH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_Limiter
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_Limiter : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_EveryInterval_AllowsOneCallPerInterval();
+    void Test_EveryInterval_HandlesTheLongestInterval();
+    void Test_EveryInterval_ZeroAllowsEveryCall();
+    void Test_EveryN_AllowsEveryNthCall();
+    void Test_Macros_EveryIntervalAddsTheSuppressedField();
+    void Test_Macros_EveryNCountsOnlyEntriesThatWouldBeWritten();
+    void Test_Macros_KeepTheCallersSourceLocation();
+    void Test_Macros_OnceLogsTheFirstEntryThatWouldBeWritten();
+    void Test_Once_AllowsOnlyTheFirstCall();
+    void Test_Threads_AllowExactlyTheLimitedCalls();
+
+public:
+    TTest_ASWLog_Limiter();
+    ~TTest_ASWLog_Limiter() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_LimiterH
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index 8145d85..3fba304 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -228,6 +228,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Interface.h</DependentOn>
             <BuildOrder>6</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_Limiter.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_Limiter.h</DependentOn>
+            <BuildOrder>62</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_MemoryLog.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_MemoryLog.h</DependentOn>
             <BuildOrder>54</BuildOrder>
@@ -300,6 +304,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_Formatter.h</DependentOn>
             <BuildOrder>37</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_Limiter.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_Limiter.h</DependentOn>
+            <BuildOrder>63</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_MemoryLog.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_MemoryLog.h</DependentOn>
             <BuildOrder>55</BuildOrder>

From 6aef36f4bcc772a38d36a06af20527e3d5f819ba Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 10:43:01 -0700
Subject: [PATCH 19/38] Configure loggers from environment variables

---
 ASWLog/ASWLog_CategoryLog.cpp                 | 177 +++++++
 ASWLog/ASWLog_CategoryLog.h                   |  28 +-
 ASWLog/ASWLog_Config.cpp                      | 270 ++++++++++-
 ASWLog/ASWLog_Config.h                        |  33 ++
 ASWLog/ASWLog_ConsoleLog.cpp                  |  15 +-
 ASWLog/ASWLog_Types.cpp                       |  72 ++-
 ASWLog/ASWLog_Types.h                         |   9 +-
 ASWLog/ASWLog_Utils.cpp                       |  88 ++++
 ASWLog/ASWLog_Utils.h                         |  32 ++
 CHANGELOG.md                                  |  24 +
 tests/cmake/CMakeLists.txt                    |   2 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_Base.cpp              |  70 +--
 tests/tests/Test_ASWLog_CategoryLog.cpp       | 203 ++++++++
 tests/tests/Test_ASWLog_CategoryLog.h         |   5 +
 tests/tests/Test_ASWLog_Config.cpp            | 445 ++++++++++++++++++
 tests/tests/Test_ASWLog_Config.h              |  11 +
 tests/tests/Test_ASWLog_ConsoleLog.cpp        |  86 +---
 tests/tests/Test_ASWLog_Types.cpp             |   3 +-
 tests/tests/Test_ASWLog_Utils.cpp             |  79 ++++
 tests/tests/Test_ASWLog_Utils.h               |   4 +
 tests/tests/UT_Helper_Environment.cpp         | 127 +++++
 tests/tests/UT_Helper_Environment.h           |  60 +++
 tests/tests/UT_Helper_StdErr.cpp              |  96 ++++
 tests/tests/UT_Helper_StdErr.h                |  56 +++
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 26 files changed, 1812 insertions(+), 199 deletions(-)
 create mode 100644 tests/tests/UT_Helper_Environment.cpp
 create mode 100644 tests/tests/UT_Helper_Environment.h
 create mode 100644 tests/tests/UT_Helper_StdErr.cpp
 create mode 100644 tests/tests/UT_Helper_StdErr.h

diff --git a/ASWLog/ASWLog_CategoryLog.cpp b/ASWLog/ASWLog_CategoryLog.cpp
index 24504a2..3271ed9 100644
--- a/ASWLog/ASWLog_CategoryLog.cpp
+++ b/ASWLog/ASWLog_CategoryLog.cpp
@@ -25,8 +25,12 @@ limitations under the License.
 #include "ASWLog_CategoryLog.h"
 //---------------------------------------------------------------------------
 // System includes here
+#include <algorithm>
 #include <format>
+#include <mutex>
+#include <vector>
 //---------------------------------------------------------------------------
+#include "ASWLog_Utils.h"
 #include "ASWLog_Version.h"
 //---------------------------------------------------------------------------
 
@@ -36,10 +40,71 @@ namespace ASWLog
 namespace
 {
 
+// A level TASWCategoryLog::ApplyLevels() gives the categories its name covers
+struct TLevelRule
+{
+    std::string Name; // "*", or a category's name
+    Level MinimumLevel = Level::Info;
+};
+
+// The categories that exist, and the rules TASWCategoryLog::ApplyLevels() set last
+struct TCategoryRegistry
+{
+    std::mutex Mutex;
+    std::vector<TASWCategoryLog*> Categories;
+    std::vector<TLevelRule> Rules;
+};
+
+//---------------------------------------------------------------------------
+
+const TLevelRule* FindLevelRule(const std::vector<TLevelRule>& rules, std::string_view name) noexcept;
+TCategoryRegistry& GetCategoryRegistry();
 std::string MakeCategoryName(std::string_view name, const IASWLog& log);
+bool ParseLevelRules(std::string_view spec, std::vector<TLevelRule>& rules, std::string& error);
 
 //---------------------------------------------------------------------------
 
+/*
+  FindLevelRule
+
+  The rule of 'rules' with the longest name that covers the category 'name' (its own name, the name of a category
+  above it, or "*"), or null if none covers it
+*/
+const TLevelRule* FindLevelRule(const std::vector<TLevelRule>& rules, std::string_view name) noexcept
+{
+    const TLevelRule* found = nullptr;
+    std::size_t foundLength = 0;
+
+    for (const auto& rule : rules)
+    {
+        const bool isAll = rule.Name == "*";
+        const std::size_t length = isAll ? 0 : rule.Name.size();
+        const bool covers = isAll || (name.size() >= length && Detail::EqualsIgnoringCase(name.substr(0, length), rule.Name) &&
+            (name.size() == length || name[length] == '.'));
+
+        if (covers && (found == nullptr || length > foundLength))
+        {
+            found = &rule;
+            foundLength = length;
+        }
+    }
+
+    return found;
+}
+
+/*
+  GetCategoryRegistry
+
+  The process's category registry. Never destroyed, so categories destroyed at exit (e.g. static ones in other files)
+  can still leave it.
+*/
+TCategoryRegistry& GetCategoryRegistry()
+{
+    static auto* const registry = new TCategoryRegistry();
+
+    return *registry;
+}
+
 /*
   MakeCategoryName
 
@@ -57,6 +122,69 @@ std::string MakeCategoryName(std::string_view name, const IASWLog& log)
     return fullName;
 }
 
+/*
+  ParseLevelRules
+
+  Adds the "name=level" items of 'spec' to 'rules' (see TASWCategoryLog::ApplyLevels()), a name given again replacing
+  its earlier level. Returns false at the first invalid item, describing it in 'error'.
+*/
+bool ParseLevelRules(std::string_view spec, std::vector<TLevelRule>& rules, std::string& error)
+{
+    std::size_t start = 0;
+
+    while (start <= spec.size())
+    {
+        const auto comma = spec.find(',', start);
+        const auto end = comma == std::string_view::npos ? spec.size() : comma;
+        const auto item = Detail::TrimSpaces(spec.substr(start, end - start));
+        start = end + 1;
+
+        if (item.empty())
+            continue;
+
+        const auto equals = item.find('=');
+        if (equals == std::string_view::npos)
+        {
+            error = std::format("'{}' has no '=' (expected name=level)", item);
+            return false;
+        }
+
+        const auto name = Detail::TrimSpaces(item.substr(0, equals));
+        const auto levelText = Detail::TrimSpaces(item.substr(equals + 1));
+
+        if (name.empty())
+        {
+            error = std::format("'{}' has no category name", item);
+            return false;
+        }
+
+        if (name != "*" && name.find('*') != std::string_view::npos)
+        {
+            error = std::format("'{}': a name can't hold '*' (a name covers the categories under it; \"*\" covers all)", item);
+            return false;
+        }
+
+        const auto level = Level_FromString(levelText);
+        if (!level)
+        {
+            error = std::format("'{}': '{}' isn't a level (Trace, Debug, Info, Warn, Error, Critical or Off)", item, levelText);
+            return false;
+        }
+
+        const auto existing = std::find_if(rules.begin(), rules.end(), [name](const TLevelRule& rule)
+                {
+                    return Detail::EqualsIgnoringCase(rule.Name, name);
+                });
+
+        if (existing != rules.end())
+            existing->MinimumLevel = *level;
+        else
+            rules.push_back(TLevelRule{ std::string(name), *level });
+    }
+
+    return true;
+}
+
 } // namespace
 
 //---------------------------------------------------------------------------
@@ -70,6 +198,55 @@ TASWCategoryLog::TASWCategoryLog(std::string_view name, IASWLog& log)
     : m_Log(log),
       m_Name(MakeCategoryName(name, log))
 {
+    auto& registry = GetCategoryRegistry();
+    std::lock_guard<std::mutex> lock(registry.Mutex);
+
+    registry.Categories.push_back(this);
+
+    if (const auto* rule = FindLevelRule(registry.Rules, m_Name))
+        m_Level.store(static_cast<std::uint8_t>(rule->MinimumLevel), std::memory_order_relaxed);
+}
+
+//---------------------------------------------------------------------------
+TASWCategoryLog::~TASWCategoryLog()
+{
+    auto& registry = GetCategoryRegistry();
+    std::lock_guard<std::mutex> lock(registry.Mutex);
+
+    std::erase(registry.Categories, this);
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::ApplyLevels(std::string_view spec)
+{
+    std::string error;
+
+    return ApplyLevels(spec, error);
+}
+
+//---------------------------------------------------------------------------
+bool TASWCategoryLog::ApplyLevels(std::string_view spec, std::string& error)
+{
+    error.clear();
+
+    std::vector<TLevelRule> rules;
+    if (!ParseLevelRules(spec, rules, error))
+        return false;
+
+    auto& registry = GetCategoryRegistry();
+    std::lock_guard<std::mutex> lock(registry.Mutex);
+
+    registry.Rules = std::move(rules);
+
+    for (auto* category : registry.Categories)
+    {
+        // Not through SetMinimumLevel(), a virtual call: a category of a derived class may be in its destructor,
+        // waiting for the lock to leave the registry
+        if (const auto* rule = FindLevelRule(registry.Rules, category->m_Name))
+            category->m_Level.store(static_cast<std::uint8_t>(rule->MinimumLevel), std::memory_order_relaxed);
+    }
+
+    return true;
 }
 
 //---------------------------------------------------------------------------
diff --git a/ASWLog/ASWLog_CategoryLog.h b/ASWLog/ASWLog_CategoryLog.h
index 6650e74..f674423 100644
--- a/ASWLog/ASWLog_CategoryLog.h
+++ b/ASWLog/ASWLog_CategoryLog.h
@@ -63,9 +63,12 @@ namespace ASWLog
 // a log the rest of the application uses. SetEnabled(false) silences only this category (and the categories wrapping
 // it); the wrapped logger must be enabled too.
 //
-// Lock-free and thread-safe. The wrapped logger must outlive the category, and must not be a multi-log that holds the
-// category. A logger that keeps an entry beyond the call (e.g. in its backtrace) copies the category's name, so the
-// category may be destroyed meanwhile.
+// The levels of several categories can also be set by name, e.g. from an environment variable, with ApplyLevels() (see
+// TASWLogConfig::ApplyEnvironment()).
+//
+// Lock-free and thread-safe (making or destroying a category takes a process-wide lock, for ApplyLevels()). The wrapped
+// logger must outlive the category, and must not be a multi-log that holds the category. A logger that keeps an entry
+// beyond the call (e.g. in its backtrace) copies the category's name, so the category may be destroyed meanwhile.
 /////////////////////////////////////////////////////////////////////////////
 class TASWCategoryLog : public IASWLog
 {
@@ -86,10 +89,23 @@ class TASWCategoryLog : public IASWLog
     TASWLogRecord WithCategory(const TASWLogRecord& record) const noexcept;
 
 public:
-    // Shows 'name' as is, or, if 'log' is a category, after that category's name and a '.'. Throws std::bad_alloc if
-    // the name can't be copied.
+    // Sets the minimum level of the categories 'spec' covers, process-wide: of those that exist now, and of those made
+    // until the next call. 'spec' is a list of "name=level" items separated by commas, e.g. "*=Info,Net=Debug,
+    // Net.Http=Trace": a name covers the category of that name and those under it (Net covers Net and Net.Http, but
+    // not Network), "*" covers every category, and the longest name that covers a category gives its level. Names and
+    // levels ignore case and the spaces around them; the levels are those of Level_FromString(). The categories it
+    // doesn't cover keep their level, and a later SetMinimumLevel() or ResetMinimumLevel() changes a category's level
+    // as usual. An empty spec covers none. Returns false and changes nothing if an item is invalid (no '=', no name, a
+    // '*' in a name other than "*", or an unknown level), describing it in 'error'. Throws std::bad_alloc if out of
+    // memory.
+    static bool ApplyLevels(std::string_view spec);
+    static bool ApplyLevels(std::string_view spec, std::string& error);
+
+public:
+    // Shows 'name' as is, or, if 'log' is a category, after that category's name and a '.'. Takes its level from the
+    // levels ApplyLevels() set last, if they cover it. Throws std::bad_alloc if out of memory.
     TASWCategoryLog(std::string_view name, IASWLog& log);
-    ~TASWCategoryLog() override = default;
+    ~TASWCategoryLog() override;
 
     TASWCategoryLog(const TASWCategoryLog&) = delete;
     TASWCategoryLog& operator=(const TASWCategoryLog&) = delete;
diff --git a/ASWLog/ASWLog_Config.cpp b/ASWLog/ASWLog_Config.cpp
index bcc92e6..e1f4cef 100644
--- a/ASWLog/ASWLog_Config.cpp
+++ b/ASWLog/ASWLog_Config.cpp
@@ -25,14 +25,278 @@ limitations under the License.
 #include "ASWLog_Config.h"
 //---------------------------------------------------------------------------
 // System includes here
-#include <iomanip>
-#include <iostream>
-#include <sstream>
+#include <algorithm>
+#include <charconv>
+#include <cstdio>
+#include <format>
+#include <optional>
+#include <stdexcept>
+#include <utility>
+//---------------------------------------------------------------------------
+#include "ASWLog_CategoryLog.h"
+#include "ASWLog_Formatter.h"
+#include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
 
 namespace ASWLog
 {
 
+namespace
+{
+
+// The keys ApplyEnvironment() reads, in the order it applies them (PATTERN after FORMAT)
+constexpr std::array<std::string_view, 15> SettingKeys{
+    "LEVEL", "CATEGORIES", "FOLDER", "FILE", "FLUSH", "SYNC_AT_LEVEL", "ASYNC", "BACKTRACE", "TIME_ZONE",
+    "TIME_PRECISION", "MULTILINE", "SHOW_FUNCTION", "SHOW_SOURCE", "FORMAT", "PATTERN"
+};
+
+constexpr std::string_view BoolValues = "1, true, yes or on; 0, false, no or off";
+constexpr std::string_view LevelValues = "Trace, Debug, Info, Warn, Error, Critical or Off";
+
+//---------------------------------------------------------------------------
+
+bool ApplyNamedSetting(TASWLogConfig& config, std::string_view name, std::string_view key, std::string_view value);
+template<typename T>
+std::string Assign(const std::optional<T>& parsed, T& setting, std::string_view expected);
+std::optional<bool> ParseBool(std::string_view text) noexcept;
+std::optional<std::size_t> ParseCount(std::string_view text) noexcept;
+void ReportInvalidSetting(const TASWLogConfig& config, std::string message);
+std::filesystem::path UTF8ToPath(std::string_view text);
+
+//---------------------------------------------------------------------------
+
+/*
+  ApplyNamedSetting
+
+  Sets the setting 'key' of 'config' from 'value' (see TASWLogConfig::ApplySetting()), naming it 'name' in a report
+*/
+bool ApplyNamedSetting(TASWLogConfig& config, std::string_view name, std::string_view key, std::string_view value)
+{
+    const auto is = [key](std::string_view candidate)
+        {
+            return Detail::EqualsIgnoringCase(key, candidate);
+        };
+
+    if (std::none_of(SettingKeys.begin(), SettingKeys.end(), is))
+    {
+        ReportInvalidSetting(config, std::format("'{}' isn't a setting", name));
+        return false;
+    }
+
+    const auto text = Detail::TrimSpaces(value);
+    if (text.empty())
+        return true;
+
+    std::string problem; // Why 'text' isn't a valid value, if it isn't
+
+    if (is("LEVEL"))
+    {
+        problem = Assign(Level_FromString(text), config.InitialMinimumLevel, LevelValues);
+    }
+    else if (is("CATEGORIES"))
+    {
+        TASWCategoryLog::ApplyLevels(text, problem);
+    }
+    else if (is("FOLDER"))
+    {
+        config.File.FolderPath = UTF8ToPath(text);
+    }
+    else if (is("FILE"))
+    {
+        config.File.FilePath = UTF8ToPath(text);
+    }
+    else if (is("FLUSH"))
+    {
+        problem = Assign(FlushMode_FromString(text), config.File.Flush, "EveryWrite, OnNewLine, Manual or Periodic");
+    }
+    else if (is("SYNC_AT_LEVEL"))
+    {
+        problem = Assign(Level_FromString(text), config.File.SyncToDiskAtLevel, LevelValues);
+    }
+    else if (is("ASYNC"))
+    {
+        problem = Assign(ParseBool(text), config.Async.Enabled, BoolValues);
+    }
+    else if (is("BACKTRACE"))
+    {
+        problem = Assign(ParseCount(text), config.Backtrace.Capacity, "a number of entries, 0 = none");
+    }
+    else if (is("TIME_ZONE"))
+    {
+        problem = Assign(TimeZone_FromString(text), config.Line.TimestampZone, "UTC or Local");
+    }
+    else if (is("TIME_PRECISION"))
+    {
+        problem = Assign(TimePrecision_FromString(text), config.Line.TimestampPrecision,
+            "Milliseconds, Microseconds or Nanoseconds (ms, us, ns)");
+    }
+    else if (is("MULTILINE"))
+    {
+        problem = Assign(MultilineMode_FromString(text), config.Line.Multiline, "Preserve, Indent or Escape");
+    }
+    else if (is("SHOW_FUNCTION"))
+    {
+        problem = Assign(ParseBool(text), config.Line.ShowFunctionName, BoolValues);
+    }
+    else if (is("SHOW_SOURCE"))
+    {
+        problem = Assign(ParseBool(text), config.Line.ShowSourceLine, BoolValues);
+    }
+    else if (is("FORMAT"))
+    {
+        if (Detail::EqualsIgnoringCase(text, "TEXT"))
+            config.Line.Formatter.reset();
+        else if (Detail::EqualsIgnoringCase(text, "JSON"))
+            config.Line.Formatter = std::make_shared<const TASWJSONFormatter>();
+        else
+            problem = "expected Text or JSON";
+    }
+    else if (is("PATTERN"))
+    {
+        try
+        {
+            config.Line.Formatter = std::make_shared<const TASWPatternFormatter>(text);
+        }
+        catch (const std::invalid_argument& exception)
+        {
+            problem = exception.what();
+        }
+    }
+
+    if (problem.empty())
+        return true;
+
+    ReportInvalidSetting(config, std::format("{}='{}': {}", name, text, problem));
+
+    return false;
+}
+
+/*
+  Assign
+
+  Sets 'setting' to the parsed value and returns an empty text, or, if the value couldn't be parsed, leaves 'setting'
+  as it is and returns "expected <expected>"
+*/
+template<typename T>
+std::string Assign(const std::optional<T>& parsed, T& setting, std::string_view expected)
+{
+    if (!parsed)
+        return std::format("expected {}", expected);
+
+    setting = *parsed;
+
+    return {};
+}
+
+/*
+  ParseBool
+
+  1, true, yes or on as true; 0, false, no or off as false, ignoring case; otherwise nullopt
+*/
+std::optional<bool> ParseBool(std::string_view text) noexcept
+{
+    for (const std::string_view yes : { "1", "true", "yes", "on" })
+    {
+        if (Detail::EqualsIgnoringCase(text, yes))
+            return true;
+    }
+
+    for (const std::string_view no : { "0", "false", "no", "off" })
+    {
+        if (Detail::EqualsIgnoringCase(text, no))
+            return false;
+    }
+
+    return std::nullopt;
+}
+
+/*
+  ParseCount
+
+  'text' as a number of decimal digits that fits a std::size_t, or nullopt
+*/
+std::optional<std::size_t> ParseCount(std::string_view text) noexcept
+{
+    std::size_t count = 0;
+    const auto result = std::from_chars(text.data(), text.data() + text.size(), count);
+    if (result.ec != std::errc() || result.ptr != text.data() + text.size())
+        return std::nullopt;
+
+    return count;
+}
+
+/*
+  ReportInvalidSetting
+
+  Reports an invalid setting to the config's OnError, or, if it has none, writes it to stderr. Swallows exceptions.
+*/
+void ReportInvalidSetting(const TASWLogConfig& config, std::string message)
+{
+    try
+    {
+        TASWLogError error;
+        error.Kind = ErrorKind::InvalidSetting;
+        error.Message = std::move(message);
+
+        if (config.OnError != nullptr)
+        {
+            config.OnError(error);
+        }
+        else
+        {
+            const auto line = std::format("ASWLog: {}\n", error.ToString());
+            std::fwrite(line.data(), 1, line.size(), stderr);
+            std::fflush(stderr);
+        }
+    }
+    catch (...)
+    {
+    }
+}
+
+/*
+  UTF8ToPath
+
+  The path named by 'text' (UTF-8), on Windows too, where a path made from a std::string reads it in the ANSI code page
+*/
+std::filesystem::path UTF8ToPath(std::string_view text)
+{
+    return std::filesystem::path(std::u8string(text.begin(), text.end()));
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWLogConfig
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+bool TASWLogConfig::ApplyEnvironment(std::string_view prefix)
+{
+    bool isValid = true;
+    std::string name;
+
+    for (const auto key : SettingKeys)
+    {
+        name.assign(prefix);
+        name.append(key);
+
+        const auto value = Detail::ReadEnvironmentVariable(name);
+        if (value && !ApplyNamedSetting(*this, name, key, *value))
+            isValid = false;
+    }
+
+    return isValid;
+}
+
+//---------------------------------------------------------------------------
+bool TASWLogConfig::ApplySetting(std::string_view key, std::string_view value)
+{
+    return ApplyNamedSetting(*this, key, Detail::TrimSpaces(key), value);
+}
+
 //---------------------------------------------------------------------------
 
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 05c0df9..8920a8b 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -385,6 +385,39 @@ struct TASWLogConfig
     // and counts the failures it leaves out in its next report of that kind (TASWLogError::SuppressedCount). Measured
     // on the logger's clock (see TASWLogBase::NowUTC()). 0 = report every failure.
     std::chrono::milliseconds ErrorReportInterval{ std::chrono::minutes(1) };
+
+    // --- Settings from the Environment ---
+    // Sets the settings below from environment variables named with 'prefix', e.g. ASWLOG_LEVEL=Debug, so that a
+    // deployed application can log more, or elsewhere, without being rebuilt. Nothing reads them unless the application
+    // calls this; call it on the config before Initialize(), after setting OnError. Their values replace what the code
+    // set; LEVEL seeds the minimum level at Initialize() only (Reconfigure() keeps the current level). Each logger can
+    // read its own variables, e.g. config.ApplyEnvironment("MYAPP_CONSOLE_"). A variable that isn't set, or is empty,
+    // leaves its setting as it is, and so does an invalid value, which is reported to OnError (or written to stderr if
+    // it's empty) as ErrorKind::InvalidSetting. Variables with the prefix that aren't keys are ignored. Returns false
+    // if a value was invalid. Keys and values (ignoring case and the spaces around a value):
+    //   LEVEL           Trace, Debug, Info, Warn, Error, Critical or Off      InitialMinimumLevel
+    //   CATEGORIES      the category levels, e.g. "*=Info,Net=Debug"; process-wide, so set it under one prefix only
+    //                   (see TASWCategoryLog::ApplyLevels())
+    //   FOLDER          a folder (UTF-8)                                      File.FolderPath
+    //   FILE            a file name or path (UTF-8)                           File.FilePath
+    //   FLUSH           EveryWrite, OnNewLine, Manual or Periodic             File.Flush
+    //   SYNC_AT_LEVEL   a level                                               File.SyncToDiskAtLevel
+    //   ASYNC           1, true, yes or on; 0, false, no or off               Async.Enabled
+    //   BACKTRACE       how many entries to keep, 0 = none                    Backtrace.Capacity
+    //   TIME_ZONE       UTC or Local                                          Line.TimestampZone
+    //   TIME_PRECISION  ms, us or ns (or Milliseconds, Microseconds...)       Line.TimestampPrecision
+    //   MULTILINE       Preserve, Indent or Escape                            Line.Multiline
+    //   SHOW_FUNCTION   as ASYNC                                              Line.ShowFunctionName
+    //   SHOW_SOURCE     as ASYNC                                              Line.ShowSourceLine
+    //   FORMAT          Text (the built-in layout) or JSON                    Line.Formatter
+    //   PATTERN         a TASWPatternFormatter pattern, e.g. "{time} {message}", applied after FORMAT
+    // Throws std::bad_alloc if out of memory.
+    bool ApplyEnvironment(std::string_view prefix = "ASWLOG_");
+    // Sets one of ApplyEnvironment()'s settings, 'key' (without a prefix, ignoring case), from 'value', e.g. from the
+    // application's command line or settings file. An empty value leaves the setting as it is. Reports an unknown key
+    // or an invalid value as ApplyEnvironment() does, and returns false for them. Throws std::bad_alloc if out of
+    // memory.
+    bool ApplySetting(std::string_view key, std::string_view value);
 };
 
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_ConsoleLog.cpp b/ASWLog/ASWLog_ConsoleLog.cpp
index 902dd42..6395d77 100644
--- a/ASWLog/ASWLog_ConsoleLog.cpp
+++ b/ASWLog/ASWLog_ConsoleLog.cpp
@@ -38,6 +38,8 @@ limitations under the License.
 #include <unistd.h>
 #endif
 //---------------------------------------------------------------------------
+#include "ASWLog_Utils.h"
+//---------------------------------------------------------------------------
 
 namespace ASWLog
 {
@@ -48,16 +50,11 @@ namespace
 constexpr std::string_view AnsiReset = "\x1b[0m";
 
 // True if the environment variable 'name' is set to a non-empty value.
-bool IsEnvironmentVariableSet(const char* name) noexcept
+bool IsEnvironmentVariableSet(std::string_view name) noexcept
 {
-#if defined(_WIN32)
-    // With no buffer, returns the size the value needs including its terminating null (1 for an empty value), or 0
-    // if the variable isn't set. Avoids getenv(), which MSVC warns about.
-    return GetEnvironmentVariableA(name, nullptr, 0) > 1;
-#else
-    const char* value = std::getenv(name);
-    return value != nullptr && *value != '\0';
-#endif
+    const auto value = Detail::ReadEnvironmentVariable(name);
+
+    return value.has_value() && !value->empty();
 }
 
 } // namespace
diff --git a/ASWLog/ASWLog_Types.cpp b/ASWLog/ASWLog_Types.cpp
index 4e4e063..f673f1b 100644
--- a/ASWLog/ASWLog_Types.cpp
+++ b/ASWLog/ASWLog_Types.cpp
@@ -25,7 +25,6 @@ limitations under the License.
 #include "ASWLog_Types.h"
 //---------------------------------------------------------------------------
 #include <algorithm>
-#include <cctype>
 #include <format>
 #include <initializer_list>
 #include <iomanip>
@@ -40,32 +39,15 @@ limitations under the License.
 namespace ASWLog
 {
 
-namespace
-{
-
-// Helper to check if two strings match case-insensitively without
-// creating a new, modified string allocation on the heap.
-bool iequals(std::string_view a, std::string_view b) noexcept
-{
-    return std::equal(a.begin(), a.end(), b.begin(), b.end(),
-        [](char char_a, char char_b)
-            {
-                // Cast to unsigned char before passing to tolower to avoid UB with negative values
-                return std::tolower(static_cast<unsigned char>(char_a)) == std::tolower(static_cast<unsigned char>(char_b));
-            });
-}
-
-} // namespace
-
 //---------------------------------------------------------------------------
 
 //---------------------------------------------------------------------------
 std::optional<AsyncOverflowPolicy> AsyncOverflowPolicy_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "BLOCK"))
+    if (Detail::EqualsIgnoringCase(str, "BLOCK"))
         return AsyncOverflowPolicy::Block;
 
-    if (iequals(str, "DROP_NEWEST") || iequals(str, "DROPNEWEST"))
+    if (Detail::EqualsIgnoringCase(str, "DROP_NEWEST") || Detail::EqualsIgnoringCase(str, "DROPNEWEST"))
         return AsyncOverflowPolicy::DropNewest;
 
     return std::nullopt;
@@ -74,13 +56,13 @@ std::optional<AsyncOverflowPolicy> AsyncOverflowPolicy_FromString(std::string_vi
 //---------------------------------------------------------------------------
 std::optional<ColorMode> ColorMode_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "AUTO"))
+    if (Detail::EqualsIgnoringCase(str, "AUTO"))
         return ColorMode::Auto;
 
-    if (iequals(str, "ALWAYS"))
+    if (Detail::EqualsIgnoringCase(str, "ALWAYS"))
         return ColorMode::Always;
 
-    if (iequals(str, "NEVER"))
+    if (Detail::EqualsIgnoringCase(str, "NEVER"))
         return ColorMode::Never;
 
     return std::nullopt; // Return empty optional if the string is not recognized
@@ -89,16 +71,16 @@ std::optional<ColorMode> ColorMode_FromString(std::string_view str) noexcept
 //---------------------------------------------------------------------------
 std::optional<FlushMode> FlushMode_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "EVERY_WRITE") || iequals(str, "EVERYWRITE"))
+    if (Detail::EqualsIgnoringCase(str, "EVERY_WRITE") || Detail::EqualsIgnoringCase(str, "EVERYWRITE"))
         return FlushMode::EveryWrite;
 
-    if (iequals(str, "ON_NEW_LINE") || iequals(str, "ONNEWLINE"))
+    if (Detail::EqualsIgnoringCase(str, "ON_NEW_LINE") || Detail::EqualsIgnoringCase(str, "ONNEWLINE"))
         return FlushMode::OnNewLine;
 
-    if (iequals(str, "MANUAL"))
+    if (Detail::EqualsIgnoringCase(str, "MANUAL"))
         return FlushMode::Manual;
 
-    if (iequals(str, "PERIODIC"))
+    if (Detail::EqualsIgnoringCase(str, "PERIODIC"))
         return FlushMode::Periodic;
 
     return std::nullopt;
@@ -107,25 +89,25 @@ std::optional<FlushMode> FlushMode_FromString(std::string_view str) noexcept
 //---------------------------------------------------------------------------
 std::optional<Level> Level_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "TRACE"))
+    if (Detail::EqualsIgnoringCase(str, "TRACE"))
         return Level::Trace;
 
-    if (iequals(str, "DEBUG"))
+    if (Detail::EqualsIgnoringCase(str, "DEBUG"))
         return Level::Debug;
 
-    if (iequals(str, "INFO"))
+    if (Detail::EqualsIgnoringCase(str, "INFO"))
         return Level::Info;
 
-    if (iequals(str, "WARN") || iequals(str, "WARNING"))
+    if (Detail::EqualsIgnoringCase(str, "WARN") || Detail::EqualsIgnoringCase(str, "WARNING"))
         return Level::Warn;
 
-    if (iequals(str, "ERROR"))
+    if (Detail::EqualsIgnoringCase(str, "ERROR"))
         return Level::Error;
 
-    if (iequals(str, "CRITICAL") || iequals(str, "FATAL"))
+    if (Detail::EqualsIgnoringCase(str, "CRITICAL") || Detail::EqualsIgnoringCase(str, "FATAL"))
         return Level::Critical;
 
-    if (iequals(str, "OFF") || iequals(str, "NONE"))
+    if (Detail::EqualsIgnoringCase(str, "OFF") || Detail::EqualsIgnoringCase(str, "NONE"))
         return Level::Off;
 
     return std::nullopt; // Return empty optional if the string is not recognized
@@ -134,10 +116,10 @@ std::optional<Level> Level_FromString(std::string_view str) noexcept
 //---------------------------------------------------------------------------
 std::optional<LineEnding> LineEnding_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "LF") || iequals(str, "LINUX"))
+    if (Detail::EqualsIgnoringCase(str, "LF") || Detail::EqualsIgnoringCase(str, "LINUX"))
         return LineEnding::LF;
 
-    if (iequals(str, "CRLF") || iequals(str, "WINDOWS"))
+    if (Detail::EqualsIgnoringCase(str, "CRLF") || Detail::EqualsIgnoringCase(str, "WINDOWS"))
         return LineEnding::CRLF;
 
     return std::nullopt; // Return empty optional if the string is not recognized
@@ -146,13 +128,13 @@ std::optional<LineEnding> LineEnding_FromString(std::string_view str) noexcept
 //---------------------------------------------------------------------------
 std::optional<MultilineMode> MultilineMode_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "PRESERVE"))
+    if (Detail::EqualsIgnoringCase(str, "PRESERVE"))
         return MultilineMode::Preserve;
 
-    if (iequals(str, "INDENT"))
+    if (Detail::EqualsIgnoringCase(str, "INDENT"))
         return MultilineMode::Indent;
 
-    if (iequals(str, "ESCAPE"))
+    if (Detail::EqualsIgnoringCase(str, "ESCAPE"))
         return MultilineMode::Escape;
 
     return std::nullopt;
@@ -163,7 +145,7 @@ std::optional<SyslogFacility> SyslogFacility_FromString(std::string_view str) no
 {
     for (const auto facility : { SyslogFacility::User, SyslogFacility::Daemon, SyslogFacility::Local0, SyslogFacility::Local1, SyslogFacility::Local2, SyslogFacility::Local3, SyslogFacility::Local4, SyslogFacility::Local5, SyslogFacility::Local6, SyslogFacility::Local7 })
     {
-        if (iequals(str, SyslogFacility_ToString(facility)))
+        if (Detail::EqualsIgnoringCase(str, SyslogFacility_ToString(facility)))
             return facility;
     }
 
@@ -173,13 +155,13 @@ std::optional<SyslogFacility> SyslogFacility_FromString(std::string_view str) no
 //---------------------------------------------------------------------------
 std::optional<TimePrecision> TimePrecision_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "MILLISECONDS") || iequals(str, "MS"))
+    if (Detail::EqualsIgnoringCase(str, "MILLISECONDS") || Detail::EqualsIgnoringCase(str, "MS"))
         return TimePrecision::Milliseconds;
 
-    if (iequals(str, "MICROSECONDS") || iequals(str, "US"))
+    if (Detail::EqualsIgnoringCase(str, "MICROSECONDS") || Detail::EqualsIgnoringCase(str, "US"))
         return TimePrecision::Microseconds;
 
-    if (iequals(str, "NANOSECONDS") || iequals(str, "NS"))
+    if (Detail::EqualsIgnoringCase(str, "NANOSECONDS") || Detail::EqualsIgnoringCase(str, "NS"))
         return TimePrecision::Nanoseconds;
 
     return std::nullopt;
@@ -188,10 +170,10 @@ std::optional<TimePrecision> TimePrecision_FromString(std::string_view str) noex
 //---------------------------------------------------------------------------
 std::optional<TimeZone> TimeZone_FromString(std::string_view str) noexcept
 {
-    if (iequals(str, "UTC"))
+    if (Detail::EqualsIgnoringCase(str, "UTC"))
         return TimeZone::UTC;
 
-    if (iequals(str, "LOCAL"))
+    if (Detail::EqualsIgnoringCase(str, "LOCAL"))
         return TimeZone::Local;
 
     return std::nullopt;
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index a929257..95ea589 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -158,10 +158,14 @@ enum class ErrorKind
     // An asynchronous logger's queue was full, so entries were dropped (see AsyncOverflowPolicy::DropNewest). The
     // message says how many.
     EntriesDropped,
+
+    // A setting given as text had an invalid value, which was left unused (see TASWLogConfig::ApplyEnvironment()). The
+    // message names the setting and the value.
+    InvalidSetting,
 };
 
 // Number of error kinds, e.g. for a table indexed by kind. Update this when a kind is added or removed.
-constexpr std::size_t ErrorKindCount = 9;
+constexpr std::size_t ErrorKindCount = 10;
 
 [[nodiscard]] constexpr std::string_view ErrorKind_ToString(ErrorKind errorKind) noexcept
 {
@@ -193,6 +197,9 @@ constexpr std::size_t ErrorKindCount = 9;
 
         case ErrorKind::EntriesDropped:
             return "ENTRIES_DROPPED";
+
+        case ErrorKind::InvalidSetting:
+            return "INVALID_SETTING";
     }
 
     return "UNKNOWN";
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index 033c947..28a6bb4 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -30,6 +30,7 @@ limitations under the License.
 #include <charconv>
 #include <chrono>
 #include <climits>
+#include <cstdlib>
 #include <cstring>
 #include <ctime>
 #include <filesystem>
@@ -801,6 +802,20 @@ void CutToFit(std::string& text, std::size_t maxBytes)
         text.append(CutMarker);
 }
 
+//---------------------------------------------------------------------------
+bool EqualsIgnoringCase(std::string_view a, std::string_view b) noexcept
+{
+    const auto toLower = [](char character)
+        {
+            return character >= 'A' && character <= 'Z' ? static_cast<char>(character - 'A' + 'a') : character;
+        };
+
+    return std::equal(a.begin(), a.end(), b.begin(), b.end(), [&](char charA, char charB)
+            {
+                return toLower(charA) == toLower(charB);
+            });
+}
+
 //---------------------------------------------------------------------------
 TJSONPiece NextJSONPiece(std::string_view text, std::size_t& index, char (& escape)[6]) noexcept
 {
@@ -934,6 +949,62 @@ TMultilinePiece NextMultilinePiece(std::string_view text, std::size_t& index, Mu
     return TMultilinePiece{ isNextLineEmpty ? indented.substr(0, indented.size() - 1) : indented, true };
 }
 
+//---------------------------------------------------------------------------
+std::optional<std::string> ReadEnvironmentVariable(std::string_view name) noexcept
+{
+    try
+    {
+#if defined(_WIN32)
+        const auto wideName = UTF8ToWideString(name);
+
+        // The size the value needs, including its terminating null (1 for an empty value), or 0 if it isn't set
+        DWORD size = GetEnvironmentVariableW(wideName.c_str(), nullptr, 0);
+        std::wstring value;
+
+        while (size > 0)
+        {
+            value.resize(size);
+            SetLastError(ERROR_SUCCESS); // An empty value also returns 0, without an error
+            const DWORD length = GetEnvironmentVariableW(wideName.c_str(), value.data(), size);
+            if (length == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND)
+                return std::nullopt; // Removed meanwhile
+
+            if (length < size)
+            {
+                value.resize(length);
+                return WideStringToUTF8(value);
+            }
+
+            size = length; // Another thread made it longer meanwhile: the size it needs now
+        }
+
+        return std::nullopt;
+#else
+        const char* value = std::getenv(std::string(name).c_str());
+        if (value == nullptr)
+            return std::nullopt;
+
+        return std::string(value);
+#endif
+    }
+    catch (...)
+    {
+        return std::nullopt;
+    }
+}
+
+//---------------------------------------------------------------------------
+std::string_view TrimSpaces(std::string_view text) noexcept
+{
+    const auto start = text.find_first_not_of(" \t");
+    if (start == std::string_view::npos)
+        return {};
+
+    const auto end = text.find_last_not_of(" \t");
+
+    return text.substr(start, end - start + 1);
+}
+
 #if defined(_WIN32)
 //---------------------------------------------------------------------------
 std::wstring UTF8ToWideString(std::string_view text)
@@ -951,6 +1022,23 @@ std::wstring UTF8ToWideString(std::string_view text)
 
     return wide;
 }
+
+//---------------------------------------------------------------------------
+std::string WideStringToUTF8(std::wstring_view text)
+{
+    // WideCharToMultiByte takes an int length; a longer text is cut
+    const int size = text.size() > static_cast<std::size_t>(INT_MAX) ? INT_MAX : static_cast<int>(text.size());
+
+    // Without WC_ERR_INVALID_CHARS, unpaired surrogates become U+FFFD
+    const int utf8Size = size > 0 ? WideCharToMultiByte(CP_UTF8, 0, text.data(), size, nullptr, 0, nullptr, nullptr) : 0;
+    if (utf8Size <= 0)
+        return {};
+
+    std::string utf8(static_cast<std::size_t>(utf8Size), '\0');
+    WideCharToMultiByte(CP_UTF8, 0, text.data(), size, utf8.data(), utf8Size, nullptr, nullptr);
+
+    return utf8;
+}
 #endif
 
 } // namespace Detail
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index 93f8799..100da84 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -33,6 +33,7 @@ limitations under the License.
 #include <cstddef>
 #include <cstdint>
 #include <filesystem>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <system_error>
@@ -171,6 +172,13 @@ void ApplyMultilineMode(std::string& line, MultilineMode mode, LineEnding ending
 */
 void CutToFit(std::string& text, std::size_t maxBytes);
 
+/*
+    EqualsIgnoringCase
+
+    True if 'a' and 'b' are the same text, ignoring the case of ASCII letters
+*/
+[[nodiscard]] bool EqualsIgnoringCase(std::string_view a, std::string_view b) noexcept;
+
 /*
     NextJSONPiece
 
@@ -192,6 +200,22 @@ void CutToFit(std::string& text, std::size_t maxBytes);
 [[nodiscard]] TMultilinePiece NextMultilinePiece(std::string_view text, std::size_t& index, MultilineMode mode,
     LineEnding ending) noexcept;
 
+/*
+    ReadEnvironmentVariable
+
+    The value of the environment variable 'name' in UTF-8 (read with the wide Windows API on Windows, which the C
+    runtime's getenv() doesn't use), or nullopt if it isn't set or can't be read. A variable set to an empty value
+    gives an empty string. Never throws.
+*/
+[[nodiscard]] std::optional<std::string> ReadEnvironmentVariable(std::string_view name) noexcept;
+
+/*
+    TrimSpaces
+
+    'text' without the spaces and tabs at its start and end
+*/
+[[nodiscard]] std::string_view TrimSpaces(std::string_view text) noexcept;
+
 #if defined(_WIN32)
 /*
     UTF8ToWideString
@@ -200,6 +224,14 @@ void CutToFit(std::string& text, std::size_t maxBytes);
     std::bad_alloc if the result can't be made.
 */
 [[nodiscard]] std::wstring UTF8ToWideString(std::string_view text);
+
+/*
+    WideStringToUTF8
+
+    'text' (UTF-16, from the Windows API's wide functions) as UTF-8. Each unpaired surrogate becomes U+FFFD. Throws
+    std::bad_alloc if the result can't be made.
+*/
+[[nodiscard]] std::string WideStringToUTF8(std::wstring_view text);
 #endif
 
 } // namespace Detail
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cc59415..c8db953 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -202,6 +202,30 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   macros keep a lock-free `TASWLogLimiter` (`Once()`, `EveryN()`,
   `EveryInterval()`) in a static where they are written; the class can also be
   used on its own.
+- Settings from environment variables, e.g. to turn on full verbosity in a
+  deployed release build without rebuilding it:
+  `config.ApplyEnvironment();` before `Initialize()` reads `ASWLOG_LEVEL`,
+  `ASWLOG_CATEGORIES`, `ASWLOG_FOLDER`, `ASWLOG_FILE`, `ASWLOG_FLUSH`,
+  `ASWLOG_SYNC_AT_LEVEL`, `ASWLOG_ASYNC`, `ASWLOG_BACKTRACE`,
+  `ASWLOG_TIME_ZONE`, `ASWLOG_TIME_PRECISION`, `ASWLOG_MULTILINE`,
+  `ASWLOG_SHOW_FUNCTION`, `ASWLOG_SHOW_SOURCE`, `ASWLOG_FORMAT` (`Text` or
+  `JSON`) and `ASWLOG_PATTERN` (a `TASWPatternFormatter` pattern), and their
+  values replace what the code set (see `TASWLogConfig::ApplyEnvironment()`
+  for the values; case doesn't matter). Nothing reads the environment unless
+  the application calls it, and each logger can have its own prefix, e.g.
+  `ApplyEnvironment("MYAPP_CONSOLE_")`. A variable that isn't set or is
+  empty changes nothing; an invalid value changes nothing either and is
+  reported to `OnError` (or stderr) as the new `ErrorKind::InvalidSetting`.
+  `ApplySetting(key, value)` sets one of the same settings, e.g. from a
+  command line or a settings file. `ASWLOG_CATEGORIES`, e.g.
+  `*=Info,Net=Debug,Net.Http=Trace`, sets category levels through the new
+  `TASWCategoryLog::ApplyLevels()`: a name covers that category and those
+  under it (`Net` covers `Net.Http`), `*` covers all, and the longest name
+  wins; it applies process-wide, to the categories that exist and to those
+  made later, and a spec with an invalid item changes nothing. On Windows,
+  the values are read as UTF-8 (paths included). Breaking only for code that
+  lists every `ErrorKind` (e.g. a `switch`) or relies on `ErrorKindCount`
+  being 9.
 
 ### Changed
 
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index dc0bad4..e0befb3 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -52,7 +52,9 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Version.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_WindowsEventLog.cpp"
     "${ASWLOG_TESTS_DIR}/UT_Helper_DateTime.cpp"
+    "${ASWLOG_TESTS_DIR}/UT_Helper_Environment.cpp"
     "${ASWLOG_TESTS_DIR}/UT_Helper_JSON.cpp"
+    "${ASWLOG_TESTS_DIR}/UT_Helper_StdErr.cpp"
 )
 
 target_include_directories(ASWLogTests PRIVATE
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index 358507e..6fcaf99 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -314,10 +314,18 @@
             <DependentOn>..\tests\UT_Helper_DateTime.h</DependentOn>
             <BuildOrder>35</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\UT_Helper_Environment.cpp">
+            <DependentOn>..\tests\UT_Helper_Environment.h</DependentOn>
+            <BuildOrder>53</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\UT_Helper_JSON.cpp">
             <DependentOn>..\tests\UT_Helper_JSON.h</DependentOn>
             <BuildOrder>38</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\UT_Helper_StdErr.cpp">
+            <DependentOn>..\tests\UT_Helper_StdErr.h</DependentOn>
+            <BuildOrder>54</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\third_party\asw-unit-tests\src\ASWUnitTests_CLI.cpp">
             <DependentOn>..\..\third_party\asw-unit-tests\src\ASWUnitTests_CLI.h</DependentOn>
             <BuildOrder>8</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_Base.cpp b/tests/tests/Test_ASWLog_Base.cpp
index a025cb1..b688ea0 100644
--- a/tests/tests/Test_ASWLog_Base.cpp
+++ b/tests/tests/Test_ASWLog_Base.cpp
@@ -40,19 +40,14 @@ limitations under the License.
 #include <type_traits>
 #include <utility>
 #include <vector>
-
-#if defined(_WIN32)
-#include <io.h>
-#include <share.h>
-#else
-#include <unistd.h>
-#endif
 //---------------------------------------------------------------------------
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
 #include "ASWLog_Base.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
+#include "UT_Helper_StdErr.h"
+//---------------------------------------------------------------------------
 
 namespace
 {
@@ -216,67 +211,6 @@ ASWLog::TASWLogConfig MakeBacktraceConfig(std::size_t capacity, ASWLog::Level lo
     return config;
 }
 
-// While alive, sends what is written to stderr to 'file' instead, by pointing stderr's file descriptor at it. Inactive
-// if stderr has no file descriptor (e.g. in a GUI application without a console).
-class TStdErrRedirect
-{
-private:
-    int m_SavedDescriptor = -1;
-
-public:
-    explicit TStdErrRedirect(const std::filesystem::path& file)
-    {
-        std::fflush(stderr);
-#if defined(_WIN32)
-        std::FILE* target = _wfsopen(file.c_str(), L"wb", _SH_DENYNO);
-        if (target == nullptr)
-            return;
-
-        m_SavedDescriptor = _dup(_fileno(stderr));
-        if (m_SavedDescriptor >= 0 && _dup2(_fileno(target), _fileno(stderr)) != 0)
-        {
-            _close(m_SavedDescriptor);
-            m_SavedDescriptor = -1;
-        }
-#else
-        std::FILE* target = std::fopen(file.c_str(), "wb");
-        if (target == nullptr)
-            return;
-
-        m_SavedDescriptor = dup(fileno(stderr));
-        if (m_SavedDescriptor >= 0 && dup2(fileno(target), fileno(stderr)) < 0)
-        {
-            close(m_SavedDescriptor);
-            m_SavedDescriptor = -1;
-        }
-#endif
-        std::fclose(target);
-    }
-
-    ~TStdErrRedirect()
-    {
-        if (m_SavedDescriptor < 0)
-            return;
-
-        std::fflush(stderr);
-#if defined(_WIN32)
-        _dup2(m_SavedDescriptor, _fileno(stderr));
-        _close(m_SavedDescriptor);
-#else
-        dup2(m_SavedDescriptor, fileno(stderr));
-        close(m_SavedDescriptor);
-#endif
-    }
-
-    TStdErrRedirect(const TStdErrRedirect&) = delete;
-    TStdErrRedirect& operator=(const TStdErrRedirect&) = delete;
-
-    bool IsActive() const noexcept
-    {
-        return m_SavedDescriptor >= 0;
-    }
-};
-
 } // namespace
 
 //---------------------------------------------------------------------------
diff --git a/tests/tests/Test_ASWLog_CategoryLog.cpp b/tests/tests/Test_ASWLog_CategoryLog.cpp
index 5ce4df1..d8a7be3 100644
--- a/tests/tests/Test_ASWLog_CategoryLog.cpp
+++ b/tests/tests/Test_ASWLog_CategoryLog.cpp
@@ -24,6 +24,7 @@ limitations under the License.
 // Module header
 #include "Test_ASWLog_CategoryLog.h"
 //---------------------------------------------------------------------------
+#include <atomic>
 #include <chrono>
 #include <cstdint>
 #include <filesystem>
@@ -44,6 +45,7 @@ limitations under the License.
 #include "ASWLog_CategoryLog.h"
 #include "ASWLog_FileLog.h"
 #include "ASWLog_MultiLog.h"
+#include "ASWLog_NullLog.h"
 //---------------------------------------------------------------------------
 
 namespace
@@ -202,6 +204,19 @@ std::string ReadFileText(const std::filesystem::path& path)
     return std::string((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
 }
 
+// Clears the category levels a test applied (they are process-wide) when it ends
+struct TCategoryLevelsReset
+{
+    TCategoryLevelsReset() = default;
+    TCategoryLevelsReset(const TCategoryLevelsReset&) = delete;
+    TCategoryLevelsReset& operator=(const TCategoryLevelsReset&) = delete;
+
+    ~TCategoryLevelsReset()
+    {
+        ASWLog::TASWCategoryLog::ApplyLevels("");
+    }
+};
+
 // Checks 'condition' until it is true, for at most WaitTimeout. Returns false if it never was.
 bool WaitUntil(const std::function<bool()>& condition)
 {
@@ -229,6 +244,11 @@ bool WaitUntil(const std::function<bool()>& condition)
 TTest_ASWLog_CategoryLog::TTest_ASWLog_CategoryLog()
     : inherited("ASWLog_CategoryLog_Tests")
 {
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_ApplyLevels_AppliesToCategoriesMadeLater, "ApplyLevels_AppliesToCategoriesMadeLater");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_ApplyLevels_GivesTheLongestCoveringNamesLevel, "ApplyLevels_GivesTheLongestCoveringNamesLevel");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_ApplyLevels_IsSafeWhileCategoriesComeAndGo, "ApplyLevels_IsSafeWhileCategoriesComeAndGo");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_ApplyLevels_LeavesUncoveredCategories, "ApplyLevels_LeavesUncoveredCategories");
+    RegisterTest(&TTest_ASWLog_CategoryLog::Test_ApplyLevels_RejectsAnInvalidSpec, "ApplyLevels_RejectsAnInvalidSpec");
     RegisterTest(&TTest_ASWLog_CategoryLog::Test_Async_KeepsItsOwnCopyOfTheName, "Async_KeepsItsOwnCopyOfTheName");
     RegisterTest(&TTest_ASWLog_CategoryLog::Test_Backtrace_KeepsEntriesBelowTheCategoryLevel, "Backtrace_KeepsEntriesBelowTheCategoryLevel");
     RegisterTest(&TTest_ASWLog_CategoryLog::Test_Backtrace_KeepsItsOwnCopyOfTheName, "Backtrace_KeepsItsOwnCopyOfTheName");
@@ -276,6 +296,189 @@ void TTest_ASWLog_CategoryLog::TearDown_Test(ITestCase& testCase)
 
 // /////// Begin tests after this line ///////////////////////
 
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_ApplyLevels_AppliesToCategoriesMadeLater()
+{
+    // Arrange
+    TCategoryLevelsReset resetLevels;
+    TRecordingLogger logger;
+
+    // Act
+    const bool isValid = ASWLog::TASWCategoryLog::ApplyLevels("Later=Debug");
+    ASWLog::TASWCategoryLog laterLog("Later", logger);
+    ASWLog::TASWCategoryLog httpLog("Http", laterLog);
+    ASWLog::TASWCategoryLog otherLog("Other", logger);
+
+    // Assert
+    CheckTrue(isValid, "The spec should be valid");
+    CheckEquals(ASWLog::Level::Debug, laterLog.GetMinimumLevel(), "A category made after ApplyLevels() should get its level");
+    CheckTrue(laterLog.HasOwnMinimumLevel(), "The spec's level should be the category's own");
+    CheckTrue(httpLog.HasOwnMinimumLevel(), "A category under a covered one should get the level too");
+    CheckEquals(ASWLog::Level::Debug, httpLog.GetMinimumLevel(), "Later.Http should get Later's level");
+    CheckFalse(otherLog.HasOwnMinimumLevel(), "A category the spec doesn't cover should get no level");
+
+    // Act: an empty spec covers no category made later
+    ASWLog::TASWCategoryLog::ApplyLevels("");
+    ASWLog::TASWCategoryLog afterClearLog("Later", logger);
+
+    // Assert
+    CheckFalse(afterClearLog.HasOwnMinimumLevel(), "After an empty spec, a new category should get no level");
+    CheckEquals(ASWLog::Level::Debug, laterLog.GetMinimumLevel(), "An empty spec should leave the levels already set");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_ApplyLevels_GivesTheLongestCoveringNamesLevel()
+{
+    // Arrange
+    TCategoryLevelsReset resetLevels;
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog dbLog("Db", logger);
+    ASWLog::TASWCategoryLog netLog("Net", logger);
+    ASWLog::TASWCategoryLog dnsLog("Dns", netLog);
+    ASWLog::TASWCategoryLog httpLog("Http", netLog);
+    ASWLog::TASWCategoryLog proxyLog("Proxy", httpLog);
+    ASWLog::TASWCategoryLog networkLog("Network", logger);
+
+    // Act: broader names first, any case, spaces, an empty item, and Net given twice (the last wins)
+    const bool isValid = ASWLog::TASWCategoryLog::ApplyLevels(" * = Warn , net=Debug, NET.HTTP = trace,, Net=Info, ");
+
+    // Assert
+    CheckTrue(isValid, "The spec should be valid");
+    CheckEquals(ASWLog::Level::Warn, dbLog.GetMinimumLevel(), "* should cover Db");
+    CheckEquals(ASWLog::Level::Info, netLog.GetMinimumLevel(), "Net should get its last level");
+    CheckEquals(ASWLog::Level::Info, dnsLog.GetMinimumLevel(), "Net should cover Net.Dns");
+    CheckEquals(ASWLog::Level::Trace, httpLog.GetMinimumLevel(), "Net.Http should win over Net for Net.Http");
+    CheckEquals(ASWLog::Level::Trace, proxyLog.GetMinimumLevel(), "Net.Http should cover Net.Http.Proxy");
+    CheckEquals(ASWLog::Level::Warn, networkLog.GetMinimumLevel(), "Net should not cover Network, only * should");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_ApplyLevels_IsSafeWhileCategoriesComeAndGo()
+{
+    // Arrange
+    constexpr int ThreadCount = 4;
+    constexpr int CategoriesPerThread = 2000;
+
+    TCategoryLevelsReset resetLevels;
+    ASWLog::TASWNullLog logger; // Thread-safe
+    std::atomic<bool> isDone{ false };
+    std::atomic<int> withoutLevelCount{ 0 };
+    ASWLog::TASWCategoryLog::ApplyLevels("Churn=Warn");
+
+    // Act: threads make, use and destroy categories while the levels change
+    std::vector<std::thread> threads;
+    for (int thread = 0; thread < ThreadCount; ++thread)
+    {
+        threads.emplace_back([&logger, &withoutLevelCount]
+            {
+                for (int index = 0; index < CategoriesPerThread; ++index)
+                {
+                    ASWLog::TASWCategoryLog churnLog("Churn", logger);
+                    const auto level = churnLog.GetMinimumLevel();
+                    if (!churnLog.HasOwnMinimumLevel() || (level != ASWLog::Level::Warn && level != ASWLog::Level::Debug))
+                        ++withoutLevelCount;
+
+                    churnLog.LogDebug("churn");
+                }
+            });
+    }
+
+    const auto applyLevels = [&isDone]
+        {
+            for (int round = 0; !isDone.load(); ++round)
+                ASWLog::TASWCategoryLog::ApplyLevels(round % 2 == 0 ? "Churn=Warn" : "Churn=Debug");
+        };
+    std::thread applier(applyLevels);
+
+    for (auto& thread : threads)
+        thread.join();
+
+    isDone.store(true);
+    applier.join();
+
+    // Assert
+    CheckEquals(0, withoutLevelCount.load(), "Every category made after the first spec should get a level");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_ApplyLevels_LeavesUncoveredCategories()
+{
+    // Arrange
+    TCategoryLevelsReset resetLevels;
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog coveredLog("Covered", logger);
+    ASWLog::TASWCategoryLog freeLog("Free", logger);
+    ASWLog::TASWCategoryLog codedLog("Coded", logger);
+    codedLog.SetMinimumLevel(ASWLog::Level::Error);
+
+    // Act
+    ASWLog::TASWCategoryLog::ApplyLevels("Covered=Debug");
+    logger.SetMinimumLevel(ASWLog::Level::Warn);
+
+    // Assert
+    CheckEquals(ASWLog::Level::Debug, coveredLog.GetMinimumLevel(), "The covered category should get the spec's level");
+    CheckFalse(freeLog.HasOwnMinimumLevel(), "An uncovered category should get no level");
+    CheckEquals(ASWLog::Level::Warn, freeLog.GetMinimumLevel(), "An uncovered category should still follow the wrapped logger");
+    CheckEquals(ASWLog::Level::Error, codedLog.GetMinimumLevel(), "An uncovered category should keep the level the code set");
+
+    // Act: a spec that no longer covers it leaves its level; the code can still change it
+    ASWLog::TASWCategoryLog::ApplyLevels("Other=Info");
+    const auto levelAfterOtherSpec = coveredLog.GetMinimumLevel();
+    coveredLog.SetMinimumLevel(ASWLog::Level::Critical);
+    const auto levelAfterSet = coveredLog.GetMinimumLevel();
+    coveredLog.ResetMinimumLevel();
+
+    // Assert
+    CheckEquals(ASWLog::Level::Debug, levelAfterOtherSpec, "A spec that doesn't cover the category should leave its level");
+    CheckEquals(ASWLog::Level::Critical, levelAfterSet, "SetMinimumLevel() after ApplyLevels() should win");
+    CheckFalse(coveredLog.HasOwnMinimumLevel(), "ResetMinimumLevel() should make the category follow again");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_CategoryLog::Test_ApplyLevels_RejectsAnInvalidSpec()
+{
+    // Arrange
+    struct TInvalidSpec
+    {
+        std::string_view Spec;
+        std::string_view Error;
+    };
+
+    const TInvalidSpec invalidSpecs[]{
+        { "Spec=Trace,Net", "'Net' has no '=' (expected name=level)" },
+        { "Spec=Trace, =Info", "'=Info' has no category name" },
+        { "Spec=Trace,Net.*=Info", "'Net.*=Info': a name can't hold '*' (a name covers the categories under it; \"*\" covers all)" },
+        { "Spec=Trace,Net=Loud", "'Net=Loud': 'Loud' isn't a level (Trace, Debug, Info, Warn, Error, Critical or Off)" },
+        { "Spec=Trace,Net=", "'Net=': '' isn't a level (Trace, Debug, Info, Warn, Error, Critical or Off)" },
+    };
+
+    TCategoryLevelsReset resetLevels;
+    TRecordingLogger logger;
+    ASWLog::TASWCategoryLog specLog("Spec", logger);
+    ASWLog::TASWCategoryLog::ApplyLevels("Spec=Debug");
+
+    for (const auto& invalidSpec : invalidSpecs)
+    {
+        // Act
+        std::string error = "previous";
+        const bool isValid = ASWLog::TASWCategoryLog::ApplyLevels(invalidSpec.Spec, error);
+        const bool isValidWithoutError = ASWLog::TASWCategoryLog::ApplyLevels(invalidSpec.Spec);
+        ASWLog::TASWCategoryLog laterLog("Spec", logger);
+
+        // Assert
+        const auto spec = std::string(invalidSpec.Spec);
+        CheckFalse(isValid, "The spec should be invalid: " + spec);
+        CheckFalse(isValidWithoutError, "The spec should be invalid without an error text too: " + spec);
+        CheckEquals(std::string(invalidSpec.Error), error, "The error should describe the bad item: " + spec);
+        CheckEquals(ASWLog::Level::Debug, specLog.GetMinimumLevel(), "An invalid spec should change no level: " + spec);
+        CheckEquals(ASWLog::Level::Debug, laterLog.GetMinimumLevel(), "An invalid spec should keep the levels for new categories: " + spec);
+    }
+
+    // Act: a valid spec clears the error
+    std::string error = "previous";
+    const bool isValid = ASWLog::TASWCategoryLog::ApplyLevels("Spec=Info", error);
+
+    // Assert
+    CheckTrue(isValid, "The spec should be valid");
+    CheckEmpty(error, "A valid spec should leave the error empty");
+    CheckEquals(ASWLog::Level::Info, specLog.GetMinimumLevel(), "A valid spec should set the level");
+}
 //---------------------------------------------------------------------------
 void TTest_ASWLog_CategoryLog::Test_Async_KeepsItsOwnCopyOfTheName()
 {
diff --git a/tests/tests/Test_ASWLog_CategoryLog.h b/tests/tests/Test_ASWLog_CategoryLog.h
index a2e5c37..d908ce9 100644
--- a/tests/tests/Test_ASWLog_CategoryLog.h
+++ b/tests/tests/Test_ASWLog_CategoryLog.h
@@ -38,6 +38,11 @@ class TTest_ASWLog_CategoryLog : public TTestGroupBase
     typedef TTestGroupBase inherited;
 
 private: // Test methods
+    void Test_ApplyLevels_AppliesToCategoriesMadeLater();
+    void Test_ApplyLevels_GivesTheLongestCoveringNamesLevel();
+    void Test_ApplyLevels_IsSafeWhileCategoriesComeAndGo();
+    void Test_ApplyLevels_LeavesUncoveredCategories();
+    void Test_ApplyLevels_RejectsAnInvalidSpec();
     void Test_Async_KeepsItsOwnCopyOfTheName();
     void Test_Backtrace_KeepsEntriesBelowTheCategoryLevel();
     void Test_Backtrace_KeepsItsOwnCopyOfTheName();
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index a128816..7acea5a 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -27,19 +27,71 @@ limitations under the License.
 #include <chrono>
 #include <cstdint>
 #include <filesystem>
+#include <fstream>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
 //---------------------------------------------------------------------------
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
+#include "ASWLog_CategoryLog.h"
 #include "ASWLog_Config.h"
+#include "ASWLog_Formatter.h"
+#include "ASWLog_MemoryLog.h"
+#include "ASWLog_NullLog.h"
+#include "ASWLog_Utils.h"
+//---------------------------------------------------------------------------
+#include "UT_Helper_Environment.h"
+#include "UT_Helper_StdErr.h"
 //---------------------------------------------------------------------------
 
 namespace ASWUnitTests
 {
 
+namespace
+{
+
+// The tests' own prefix, so that a developer's ASWLOG_* variables can't change their results
+constexpr std::string_view TestPrefix = "ASWLOGTEST_CONFIG_";
+
+// Clears the category levels a test applied (they are process-wide) when it ends
+struct TCategoryLevelsReset
+{
+    TCategoryLevelsReset() = default;
+    TCategoryLevelsReset(const TCategoryLevelsReset&) = delete;
+    TCategoryLevelsReset& operator=(const TCategoryLevelsReset&) = delete;
+
+    ~TCategoryLevelsReset()
+    {
+        ASWLog::TASWCategoryLog::ApplyLevels("");
+    }
+};
+
+// The test variable named 'key'
+std::string TestVariable(std::string_view key)
+{
+    return std::string(TestPrefix) + std::string(key);
+}
+
+} // namespace
+
 //---------------------------------------------------------------------------
 TTest_ASWLog_Config::TTest_ASWLog_Config()
     : inherited("ASWLog_Config_Tests")
 {
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_AppliesPatternAfterFormat, "ApplyEnvironment_AppliesPatternAfterFormat");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_AppliesTheCategoryLevels, "ApplyEnvironment_AppliesTheCategoryLevels");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_IgnoresUnsetAndEmptyVariables, "ApplyEnvironment_IgnoresUnsetAndEmptyVariables");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_ReadsTheDefaultPrefix, "ApplyEnvironment_ReadsTheDefaultPrefix");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_ReadsUTF8Values, "ApplyEnvironment_ReadsUTF8Values");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_ReportsInvalidValues, "ApplyEnvironment_ReportsInvalidValues");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_SeedsTheLevelAtInitialize, "ApplyEnvironment_SeedsTheLevelAtInitialize");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplyEnvironment_SetsEachKey, "ApplyEnvironment_SetsEachKey");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplySetting_ReportsAnUnknownKey, "ApplySetting_ReportsAnUnknownKey");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplySetting_SetsOneSetting, "ApplySetting_SetsOneSetting");
+    RegisterTest(&TTest_ASWLog_Config::Test_ApplySetting_WritesToStdErrWithoutHandler, "ApplySetting_WritesToStdErrWithoutHandler");
     RegisterTest(&TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues, "Defaults_MatchDocumentedValues");
     RegisterTest(&TTest_ASWLog_Config::Test_ResolveFolder_CustomFolder, "ResolveFolder_CustomFolder");
     RegisterTest(&TTest_ASWLog_Config::Test_ResolvePath_AbsolutePath, "ResolvePath_AbsolutePath");
@@ -69,6 +121,399 @@ void TTest_ASWLog_Config::TearDown_Test(ITestCase& /*testCase*/)
 
 // /////// Begin tests after this line ///////////////////////
 
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_AppliesPatternAfterFormat()
+{
+    // Arrange
+    TScopedEnvironmentVariable format(TestVariable("FORMAT"), "JSON");
+    TScopedEnvironmentVariable pattern(TestVariable("PATTERN"), "{level} {message}");
+
+    ASWLog::TASWLogConfig config;
+
+    // Act
+    const bool isValid = config.ApplyEnvironment(TestPrefix);
+
+    // Assert
+    CheckTrue(isValid, "Both values should be valid");
+    const auto* patternFormatter = dynamic_cast<const ASWLog::TASWPatternFormatter*>(config.Line.Formatter.get());
+    CheckNotNull(patternFormatter, "PATTERN should win over FORMAT");
+    if (patternFormatter != nullptr)
+        CheckEquals(std::string("{level} {message}"), std::string(patternFormatter->GetPattern()), "The pattern should be the variable's");
+
+    // Act: FORMAT=Text alone goes back to the built-in layout
+    {
+        TScopedEnvironmentVariable noPattern(TestVariable("PATTERN"), std::nullopt);
+        TScopedEnvironmentVariable textFormat(TestVariable("FORMAT"), "text");
+        CheckTrue(config.ApplyEnvironment(TestPrefix), "FORMAT=text should be valid");
+    }
+
+    // Assert
+    CheckNull(config.Line.Formatter, "FORMAT=Text should clear the formatter (the built-in layout)");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_AppliesTheCategoryLevels()
+{
+    // Arrange
+    TCategoryLevelsReset resetLevels;
+    ASWLog::TASWNullLog wrapped;
+    ASWLog::TASWCategoryLog netLog("ConfigTestNet", wrapped);
+    TScopedEnvironmentVariable categories(TestVariable("CATEGORIES"), "ConfigTestNet=Debug");
+
+    std::vector<ASWLog::TASWLogError> errors;
+    ASWLog::TASWLogConfig config;
+    config.OnError = [&errors](const ASWLog::TASWLogError& error)
+        {
+            errors.push_back(error);
+        };
+
+    // Act
+    const bool isValid = config.ApplyEnvironment(TestPrefix);
+
+    // Assert
+    CheckTrue(isValid, "The spec should be valid");
+    CheckEquals(ASWLog::Level::Debug, netLog.GetMinimumLevel(), "CATEGORIES should set the category's level");
+
+    // Act: an invalid spec
+    const bool isInvalidValid = config.ApplySetting("CATEGORIES", "ConfigTestNet=Trace,Db=Loud");
+
+    // Assert
+    CheckFalse(isInvalidValid, "A spec with an unknown level should be invalid");
+    CheckEquals(ASWLog::Level::Debug, netLog.GetMinimumLevel(), "An invalid spec should change no category's level");
+    CheckEquals(1, errors.size(), "The invalid spec should be reported once");
+    if (errors.size() == 1)
+    {
+        CheckEquals(ASWLog::ErrorKind::InvalidSetting, errors[0].Kind, "The report should be InvalidSetting");
+        CheckEquals(std::string("CATEGORIES='ConfigTestNet=Trace,Db=Loud': 'Db=Loud': 'Loud' isn't a level (Trace, Debug, Info, Warn, "
+            "Error, Critical or Off)"), errors[0].Message, "The report should name the setting, the value and the bad item");
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_IgnoresUnsetAndEmptyVariables()
+{
+    // Arrange: LEVEL empty, FLUSH only spaces, the rest unset
+    TScopedEnvironmentVariable level(TestVariable("LEVEL"), "");
+    TScopedEnvironmentVariable flush(TestVariable("FLUSH"), "  \t ");
+
+    int errorCount = 0;
+    ASWLog::TASWLogConfig config;
+    config.OnError = [&errorCount](const ASWLog::TASWLogError&)
+        {
+            ++errorCount;
+        };
+    config.InitialMinimumLevel = ASWLog::Level::Warn;
+    const auto formatter = std::make_shared<const ASWLog::TASWJSONFormatter>();
+    config.Line.Formatter = formatter;
+
+    // Act
+    const bool isValid = config.ApplyEnvironment(TestPrefix);
+
+    // Assert
+    CheckTrue(isValid, "Unset and empty variables should not count as invalid");
+    CheckEquals(0, errorCount, "Unset and empty variables should not be reported");
+    CheckEquals(ASWLog::Level::Warn, config.InitialMinimumLevel, "An empty LEVEL should leave the level");
+    CheckEquals(ASWLog::FlushMode::EveryWrite, config.File.Flush, "A FLUSH of spaces should leave the flush mode");
+    CheckTrue(config.File.FolderPath == std::filesystem::path("logs"), "An unset FOLDER should leave the folder");
+    CheckFalse(config.Async.Enabled, "An unset ASYNC should leave Async.Enabled");
+    CheckEquals(0, config.Backtrace.Capacity, "An unset BACKTRACE should leave the capacity");
+    CheckSame(formatter.get(), config.Line.Formatter.get(), "Unset FORMAT and PATTERN should leave the formatter");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_ReadsTheDefaultPrefix()
+{
+    // Arrange: a developer's own ASWLOG_CATEGORIES must not change the process's category levels
+    TScopedEnvironmentVariable categories("ASWLOG_CATEGORIES", std::nullopt);
+    TScopedEnvironmentVariable precision("ASWLOG_TIME_PRECISION", "ns");
+
+    ASWLog::TASWLogConfig config;
+    config.OnError = [](const ASWLog::TASWLogError&)
+        {
+        }; // A developer's other ASWLOG_* variables may be invalid
+    ASWLog::TASWLogConfig otherConfig;
+
+    // Act
+    config.ApplyEnvironment();
+    otherConfig.ApplyEnvironment(TestPrefix);
+
+    // Assert
+    CheckEquals(ASWLog::TimePrecision::Nanoseconds, config.Line.TimestampPrecision, "The default prefix should be ASWLOG_");
+    CheckEquals(ASWLog::TimePrecision::Milliseconds, otherConfig.Line.TimestampPrecision,
+        "Another prefix should not read the ASWLOG_ variables");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_ReadsUTF8Values()
+{
+    // Arrange: a lambda and a CJK character, in UTF-8
+    TScopedEnvironmentVariable folder(TestVariable("FOLDER"), "logs\xCE\xBB");
+    TScopedEnvironmentVariable file(TestVariable("FILE"), "\xE6\x97\xA5.txt");
+
+    ASWLog::TASWLogConfig config;
+
+    // Act
+    const bool isValid = config.ApplyEnvironment(TestPrefix);
+
+    // Assert
+    CheckTrue(isValid, "The paths should be valid");
+    CheckEquals(std::string("logs\xCE\xBB"), ASWLog::PathToUTF8String(config.File.FolderPath), "FOLDER should be read as UTF-8");
+    CheckEquals(std::string("\xE6\x97\xA5.txt"), ASWLog::PathToUTF8String(config.File.FilePath), "FILE should be read as UTF-8");
+#if defined(_WIN32)
+    CheckTrue(config.File.FolderPath.wstring() == L"logs\x03BB", "FOLDER should name the lambda, not ANSI code page characters");
+#endif
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_ReportsInvalidValues()
+{
+    // Arrange: every key but FOLDER invalid
+    TScopedEnvironmentVariable level(TestVariable("LEVEL"), "Verbose");
+    TScopedEnvironmentVariable categories(TestVariable("CATEGORIES"), "Net");
+    TScopedEnvironmentVariable folder(TestVariable("FOLDER"), "diagnostics");
+    TScopedEnvironmentVariable flush(TestVariable("FLUSH"), "Sometimes");
+    TScopedEnvironmentVariable syncAtLevel(TestVariable("SYNC_AT_LEVEL"), "Loud");
+    TScopedEnvironmentVariable async(TestVariable("ASYNC"), "maybe");
+    TScopedEnvironmentVariable backtrace(TestVariable("BACKTRACE"), "-5");
+    TScopedEnvironmentVariable timeZone(TestVariable("TIME_ZONE"), "Mars");
+    TScopedEnvironmentVariable timePrecision(TestVariable("TIME_PRECISION"), "ps");
+    TScopedEnvironmentVariable multiline(TestVariable("MULTILINE"), "Fold");
+    TScopedEnvironmentVariable showFunction(TestVariable("SHOW_FUNCTION"), "2");
+    TScopedEnvironmentVariable showSource(TestVariable("SHOW_SOURCE"), "yesno");
+    TScopedEnvironmentVariable format(TestVariable("FORMAT"), "XML");
+    TScopedEnvironmentVariable pattern(TestVariable("PATTERN"), "{nope}");
+
+    std::vector<ASWLog::TASWLogError> errors;
+    ASWLog::TASWLogConfig config;
+    config.OnError = [&errors](const ASWLog::TASWLogError& error)
+        {
+            errors.push_back(error);
+        };
+    config.InitialMinimumLevel = ASWLog::Level::Warn;
+    config.Backtrace.Capacity = 7;
+    config.Line.ShowFunctionName = true;
+    const auto formatter = std::make_shared<const ASWLog::TASWJSONFormatter>();
+    config.Line.Formatter = formatter;
+
+    // Act
+    const bool isValid = config.ApplyEnvironment(TestPrefix);
+
+    // Assert: the invalid values changed nothing, the valid one was applied
+    CheckFalse(isValid, "Invalid values should make ApplyEnvironment() return false");
+    CheckEquals(ASWLog::Level::Warn, config.InitialMinimumLevel, "An invalid LEVEL should leave the level");
+    CheckEquals(ASWLog::FlushMode::EveryWrite, config.File.Flush, "An invalid FLUSH should leave the flush mode");
+    CheckEquals(ASWLog::Level::Off, config.File.SyncToDiskAtLevel, "An invalid SYNC_AT_LEVEL should leave the level");
+    CheckFalse(config.Async.Enabled, "An invalid ASYNC should leave Async.Enabled");
+    CheckEquals(7, config.Backtrace.Capacity, "An invalid BACKTRACE should leave the capacity");
+    CheckEquals(ASWLog::TimeZone::UTC, config.Line.TimestampZone, "An invalid TIME_ZONE should leave the zone");
+    CheckEquals(ASWLog::TimePrecision::Milliseconds, config.Line.TimestampPrecision, "An invalid TIME_PRECISION should leave the precision");
+    CheckEquals(ASWLog::MultilineMode::Preserve, config.Line.Multiline, "An invalid MULTILINE should leave the mode");
+    CheckTrue(config.Line.ShowFunctionName, "An invalid SHOW_FUNCTION should leave the setting");
+    CheckFalse(config.Line.ShowSourceLine, "An invalid SHOW_SOURCE should leave the setting");
+    CheckSame(formatter.get(), config.Line.Formatter.get(), "An invalid FORMAT and PATTERN should leave the formatter");
+    CheckTrue(config.File.FolderPath == std::filesystem::path("diagnostics"), "A valid value should be applied anyway");
+
+    // Assert: one report per invalid value, in the order of the keys
+    const std::vector<std::string> expectedStarts{
+        "ASWLOGTEST_CONFIG_LEVEL='Verbose': expected Trace, Debug, Info, Warn, Error, Critical or Off",
+        "ASWLOGTEST_CONFIG_CATEGORIES='Net': 'Net' has no '='", "ASWLOGTEST_CONFIG_FLUSH='Sometimes': expected",
+        "ASWLOGTEST_CONFIG_SYNC_AT_LEVEL='Loud': expected", "ASWLOGTEST_CONFIG_ASYNC='maybe': expected",
+        "ASWLOGTEST_CONFIG_BACKTRACE='-5': expected", "ASWLOGTEST_CONFIG_TIME_ZONE='Mars': expected",
+        "ASWLOGTEST_CONFIG_TIME_PRECISION='ps': expected", "ASWLOGTEST_CONFIG_MULTILINE='Fold': expected",
+        "ASWLOGTEST_CONFIG_SHOW_FUNCTION='2': expected", "ASWLOGTEST_CONFIG_SHOW_SOURCE='yesno': expected",
+        "ASWLOGTEST_CONFIG_FORMAT='XML': expected Text or JSON", "ASWLOGTEST_CONFIG_PATTERN='{nope}': "
+    };
+
+    CheckEquals(expectedStarts.size(), errors.size(), "Each invalid value should be reported once");
+    for (std::size_t index = 0; index < errors.size() && index < expectedStarts.size(); ++index)
+    {
+        CheckEquals(ASWLog::ErrorKind::InvalidSetting, errors[index].Kind, "Each report should be InvalidSetting");
+        CheckStartsWith(errors[index].Message, expectedStarts[index], "Each report should name the variable and its value");
+    }
+
+    if (errors.size() == expectedStarts.size())
+        CheckContains(errors.back().Message, "nope", "The PATTERN report should give the pattern's problem");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_SeedsTheLevelAtInitialize()
+{
+    // Arrange
+    TScopedEnvironmentVariable level(TestVariable("LEVEL"), "Debug");
+
+    ASWLog::TASWLogConfig config;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteTimeInfo = false;
+    config.Shutdown.WriteLine = false;
+    ASWLog::TASWMemoryLog log;
+
+    // Act
+    config.ApplyEnvironment(TestPrefix);
+    log.Initialize(config);
+    log.LogDebug("debug entry");
+    log.LogTrace("trace entry");
+    const auto lines = log.GetLines();
+
+    // Assert
+    CheckEquals(ASWLog::Level::Debug, log.GetMinimumLevel(), "The logger should start at the variable's level");
+    CheckEquals(1, lines.size(), "Only the Debug entry should be written");
+    if (lines.size() == 1)
+        CheckContains(lines[0], "debug entry", "The Debug entry should be written");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplyEnvironment_SetsEachKey()
+{
+    // Arrange: mixed case and spaces around the values
+    TScopedEnvironmentVariable level(TestVariable("LEVEL"), " debug ");
+    TScopedEnvironmentVariable folder(TestVariable("FOLDER"), "diag/logs");
+    TScopedEnvironmentVariable file(TestVariable("FILE"), "app-diag.txt");
+    TScopedEnvironmentVariable flush(TestVariable("FLUSH"), "Periodic");
+    TScopedEnvironmentVariable syncAtLevel(TestVariable("SYNC_AT_LEVEL"), "warn");
+    TScopedEnvironmentVariable async(TestVariable("ASYNC"), "on");
+    TScopedEnvironmentVariable backtrace(TestVariable("BACKTRACE"), "250");
+    TScopedEnvironmentVariable timeZone(TestVariable("TIME_ZONE"), "local");
+    TScopedEnvironmentVariable timePrecision(TestVariable("TIME_PRECISION"), "us");
+    TScopedEnvironmentVariable multiline(TestVariable("MULTILINE"), "Escape");
+    TScopedEnvironmentVariable showFunction(TestVariable("SHOW_FUNCTION"), "YES");
+    TScopedEnvironmentVariable showSource(TestVariable("SHOW_SOURCE"), "true");
+    TScopedEnvironmentVariable format(TestVariable("FORMAT"), "json");
+
+    int errorCount = 0;
+    ASWLog::TASWLogConfig config;
+    config.OnError = [&errorCount](const ASWLog::TASWLogError&)
+        {
+            ++errorCount;
+        };
+
+    // Act
+    const bool isValid = config.ApplyEnvironment(TestPrefix);
+
+    // Assert
+    CheckTrue(isValid, "Every value should be valid");
+    CheckEquals(0, errorCount, "Nothing should be reported");
+    CheckEquals(ASWLog::Level::Debug, config.InitialMinimumLevel, "LEVEL should set InitialMinimumLevel");
+    CheckTrue(config.File.FolderPath == std::filesystem::path("diag/logs"), "FOLDER should set File.FolderPath");
+    CheckTrue(config.File.FilePath == std::filesystem::path("app-diag.txt"), "FILE should set File.FilePath");
+    CheckEquals(ASWLog::FlushMode::Periodic, config.File.Flush, "FLUSH should set File.Flush");
+    CheckEquals(ASWLog::Level::Warn, config.File.SyncToDiskAtLevel, "SYNC_AT_LEVEL should set File.SyncToDiskAtLevel");
+    CheckTrue(config.Async.Enabled, "ASYNC should set Async.Enabled");
+    CheckEquals(250, config.Backtrace.Capacity, "BACKTRACE should set Backtrace.Capacity");
+    CheckEquals(ASWLog::TimeZone::Local, config.Line.TimestampZone, "TIME_ZONE should set Line.TimestampZone");
+    CheckEquals(ASWLog::TimePrecision::Microseconds, config.Line.TimestampPrecision, "TIME_PRECISION should set Line.TimestampPrecision");
+    CheckEquals(ASWLog::MultilineMode::Escape, config.Line.Multiline, "MULTILINE should set Line.Multiline");
+    CheckTrue(config.Line.ShowFunctionName, "SHOW_FUNCTION should set Line.ShowFunctionName");
+    CheckTrue(config.Line.ShowSourceLine, "SHOW_SOURCE should set Line.ShowSourceLine");
+    CheckNotNull(dynamic_cast<const ASWLog::TASWJSONFormatter*>(config.Line.Formatter.get()), "FORMAT=json should set a JSON formatter");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplySetting_ReportsAnUnknownKey()
+{
+    // Arrange
+    std::vector<ASWLog::TASWLogError> errors;
+    ASWLog::TASWLogConfig config;
+    config.OnError = [&errors](const ASWLog::TASWLogError& error)
+        {
+            errors.push_back(error);
+        };
+
+    // Act
+    const bool isTypoValid = config.ApplySetting("LEVL", "Debug");
+    const bool isPrefixedValid = config.ApplySetting("ASWLOG_LEVEL", "Debug");
+    const bool isEmptyValid = config.ApplySetting("LEVL", "");
+
+    // Assert
+    CheckFalse(isTypoValid, "An unknown key should be invalid");
+    CheckFalse(isPrefixedValid, "A key with a prefix should be unknown");
+    CheckFalse(isEmptyValid, "An unknown key should be invalid with an empty value too");
+    CheckEquals(ASWLog::Level::Info, config.InitialMinimumLevel, "An unknown key should change nothing");
+    CheckEquals(3, errors.size(), "Each unknown key should be reported");
+    if (errors.size() == 3)
+    {
+        CheckEquals(ASWLog::ErrorKind::InvalidSetting, errors[0].Kind, "The report should be InvalidSetting");
+        CheckEquals(std::string("'LEVL' isn't a setting"), errors[0].Message, "The report should name the key");
+        CheckEquals(std::string("'ASWLOG_LEVEL' isn't a setting"), errors[1].Message, "The report should name the key as given");
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplySetting_SetsOneSetting()
+{
+    // Arrange
+    std::vector<ASWLog::TASWLogError> errors;
+    ASWLog::TASWLogConfig config;
+    config.OnError = [&errors](const ASWLog::TASWLogError& error)
+        {
+            errors.push_back(error);
+        };
+
+    // Act & Assert: the key ignores case and spaces; an empty value changes nothing
+    CheckTrue(config.ApplySetting(" level ", "Trace"), "A key should ignore case and spaces");
+    CheckEquals(ASWLog::Level::Trace, config.InitialMinimumLevel, "LEVEL should be set");
+    CheckTrue(config.ApplySetting("Level", "  "), "An empty value should be valid");
+    CheckEquals(ASWLog::Level::Trace, config.InitialMinimumLevel, "An empty value should change nothing");
+
+    // Act & Assert: each false value, each true value
+    for (const std::string_view value : { "0", "False", "NO", "off" })
+    {
+        config.Line.ShowSourceLine = true;
+        CheckTrue(config.ApplySetting("SHOW_SOURCE", value), "A false value should be valid: " + std::string(value));
+        CheckFalse(config.Line.ShowSourceLine, "A false value should clear the setting: " + std::string(value));
+    }
+
+    for (const std::string_view value : { "1", "TRUE", "Yes", "ON" })
+    {
+        config.Line.ShowSourceLine = false;
+        CheckTrue(config.ApplySetting("SHOW_SOURCE", value), "A true value should be valid: " + std::string(value));
+        CheckTrue(config.Line.ShowSourceLine, "A true value should set the setting: " + std::string(value));
+    }
+
+    // Act & Assert: BACKTRACE takes decimal digits only, up to the largest std::size_t
+    CheckTrue(config.ApplySetting("BACKTRACE", "0"), "0 should be a valid BACKTRACE");
+    CheckEquals(0, config.Backtrace.Capacity, "BACKTRACE=0 should turn the backtrace off");
+    config.Backtrace.Capacity = 9;
+    for (const std::string_view value : { "+3", "-1", "12x", "1.5", "0x10", "99999999999999999999999" })
+    {
+        CheckFalse(config.ApplySetting("BACKTRACE", value), "An invalid BACKTRACE should be reported: " + std::string(value));
+        CheckEquals(9, config.Backtrace.Capacity, "An invalid BACKTRACE should change nothing: " + std::string(value));
+    }
+
+    CheckEquals(6, errors.size(), "Only the invalid BACKTRACE values should be reported");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Config::Test_ApplySetting_WritesToStdErrWithoutHandler()
+{
+    // Arrange
+    const auto stdErrFile = std::filesystem::temp_directory_path() / "aswlog_config_stderr.txt";
+    ASWLog::TASWLogConfig config; // No OnError
+
+    // Act
+    bool isRedirected = false;
+    bool isValid = true;
+    {
+        TStdErrRedirect redirect(stdErrFile);
+        isRedirected = redirect.IsActive();
+        if (isRedirected)
+            isValid = config.ApplySetting("LEVEL", "Verbose");
+    }
+
+    if (!isRedirected)
+    {
+        std::error_code removeError;
+        std::filesystem::remove(stdErrFile, removeError);
+        Skip("stderr has no file descriptor to redirect (e.g. a GUI application)");
+    }
+
+    std::string written;
+    {
+        std::ifstream stream(stdErrFile, std::ios::binary);
+        written.assign(std::istreambuf_iterator<char>(stream), std::istreambuf_iterator<char>());
+    }
+    std::error_code removeError;
+    std::filesystem::remove(stdErrFile, removeError);
+    std::erase(written, '\r'); // In case stderr is in text mode on Windows
+
+    // Assert
+    CheckFalse(isValid, "The value should be invalid");
+    CheckEquals(std::string("ASWLog: INVALID_SETTING: LEVEL='Verbose': expected Trace, Debug, Info, Warn, Error, Critical or Off\n"),
+        written, "Without OnError, an invalid value should be written to stderr as one line");
+}
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
 {
diff --git a/tests/tests/Test_ASWLog_Config.h b/tests/tests/Test_ASWLog_Config.h
index 67bdd0b..c86da4f 100644
--- a/tests/tests/Test_ASWLog_Config.h
+++ b/tests/tests/Test_ASWLog_Config.h
@@ -36,6 +36,17 @@ class TTest_ASWLog_Config : public TTestGroupBase
     typedef TTestGroupBase inherited;
 
 private: // Test methods
+    void Test_ApplyEnvironment_AppliesPatternAfterFormat();
+    void Test_ApplyEnvironment_AppliesTheCategoryLevels();
+    void Test_ApplyEnvironment_IgnoresUnsetAndEmptyVariables();
+    void Test_ApplyEnvironment_ReadsTheDefaultPrefix();
+    void Test_ApplyEnvironment_ReadsUTF8Values();
+    void Test_ApplyEnvironment_ReportsInvalidValues();
+    void Test_ApplyEnvironment_SeedsTheLevelAtInitialize();
+    void Test_ApplyEnvironment_SetsEachKey();
+    void Test_ApplySetting_ReportsAnUnknownKey();
+    void Test_ApplySetting_SetsOneSetting();
+    void Test_ApplySetting_WritesToStdErrWithoutHandler();
     void Test_Defaults_MatchDocumentedValues();
     void Test_ResolveFolder_CustomFolder();
     void Test_ResolvePath_AbsolutePath();
diff --git a/tests/tests/Test_ASWLog_ConsoleLog.cpp b/tests/tests/Test_ASWLog_ConsoleLog.cpp
index 2ab52ae..d158eda 100644
--- a/tests/tests/Test_ASWLog_ConsoleLog.cpp
+++ b/tests/tests/Test_ASWLog_ConsoleLog.cpp
@@ -26,7 +26,6 @@ limitations under the License.
 //---------------------------------------------------------------------------
 #include <chrono>
 #include <cstdint>
-#include <cstdlib>
 #include <iostream>
 #include <streambuf>
 #include <optional>
@@ -35,18 +34,14 @@ limitations under the License.
 #include <thread>
 #include <utility>
 #include <vector>
-
-#if defined(_WIN32)
-#include <windows.h>
-#undef min
-#undef max
-#endif
 //---------------------------------------------------------------------------
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
 #include "ASWLog_ConsoleLog.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
+#include "UT_Helper_Environment.h"
+//---------------------------------------------------------------------------
 
 namespace ASWUnitTests
 {
@@ -155,64 +150,6 @@ class TFlushCounter
     }
 };
 
-// RAII helper: sets an environment variable (or removes it, given std::nullopt), restoring its previous value on
-// destruction.
-class TScopedEnvironmentVariable
-{
-private:
-    std::string m_Name;
-    std::optional<std::string> m_PreviousValue;
-
-    static std::optional<std::string> Get(const std::string& name)
-    {
-#if defined(_WIN32)
-        // The Windows API rather than the C runtime, since that's what TASWConsoleLog reads (and MinGW's runtime has
-        // no _dupenv_s)
-        const DWORD size = GetEnvironmentVariableA(name.c_str(), nullptr, 0);
-        if (size == 0)
-            return std::nullopt;
-
-        std::string value(size, '\0');
-        value.resize(GetEnvironmentVariableA(name.c_str(), value.data(), size));
-        return value;
-#else
-        const char* value = std::getenv(name.c_str());
-        if (value == nullptr)
-            return std::nullopt;
-
-        return std::string(value);
-#endif
-    }
-
-    static void Set(const std::string& name, const std::optional<std::string>& value)
-    {
-#if defined(_WIN32)
-        SetEnvironmentVariableA(name.c_str(), value ? value->c_str() : nullptr); // nullptr removes the variable
-#else
-        if (value)
-            setenv(name.c_str(), value->c_str(), 1);
-        else
-            unsetenv(name.c_str());
-#endif
-    }
-
-public:
-    TScopedEnvironmentVariable(std::string name, std::optional<std::string> value)
-        : m_Name(std::move(name)),
-          m_PreviousValue(Get(m_Name))
-    {
-        Set(m_Name, value);
-    }
-
-    ~TScopedEnvironmentVariable()
-    {
-        Set(m_Name, m_PreviousValue);
-    }
-
-    TScopedEnvironmentVariable(const TScopedEnvironmentVariable&) = delete;
-    TScopedEnvironmentVariable& operator=(const TScopedEnvironmentVariable&) = delete;
-};
-
 // RAII helper: redirects a standard stream's buffer to an internal buffer for
 // the lifetime of the object, restoring the original buffer on destruction.
 class TStreamCapture
@@ -406,11 +343,28 @@ void TTest_ASWLog_ConsoleLog::Test_ColorModeAuto_HonorsNoColor()
         alwaysContents = outCapture.Str();
     }
 
+    // Act: NO_COLOR set to an empty value doesn't count (see https://no-color.org)
+    std::string emptyContents;
+    bool emptyInitialized = false;
+    {
+        TScopedEnvironmentVariable emptyNoColor("NO_COLOR", "");
+        TColorDetectConsoleLog emptyLogger;
+        emptyLogger.StdOutSupportsColor = true;
+        emptyLogger.StdErrSupportsColor = true;
+
+        TStreamCapture outCapture(std::cout);
+        emptyInitialized = emptyLogger.Initialize(config);
+        emptyLogger.LogInfo("empty_message");
+        emptyLogger.Close();
+        emptyContents = outCapture.Str();
+    }
+
     // Assert
-    CheckTrue(autoInitialized && alwaysInitialized, "Initialize should succeed");
+    CheckTrue(autoInitialized && alwaysInitialized && emptyInitialized, "Initialize should succeed");
     CheckNotContains(autoContents, "\x1b[", "Auto should not color any stream when NO_COLOR is set");
     CheckContains(autoContents, "auto_message", "The uncolored message should still be written");
     CheckContains(alwaysContents, "\x1b[", "Always should color even when NO_COLOR is set");
+    CheckContains(emptyContents, "\x1b[", "Auto should still color when NO_COLOR is set but empty");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_ConsoleLog::Test_ColorModeNever_SuppressesAnsiCodes()
diff --git a/tests/tests/Test_ASWLog_Types.cpp b/tests/tests/Test_ASWLog_Types.cpp
index ced9c88..d3950fd 100644
--- a/tests/tests/Test_ASWLog_Types.cpp
+++ b/tests/tests/Test_ASWLog_Types.cpp
@@ -186,7 +186,8 @@ void TTest_ASWLog_Types::Test_ErrorKind_ToString()
     CheckEquals(std::string("DELETE_FAILED"), std::string(ASWLog::ErrorKind_ToString(ASWLog::ErrorKind::DeleteFailed)), "DeleteFailed should stringify as DELETE_FAILED");
     CheckEquals(std::string("EXCEPTION"), std::string(ASWLog::ErrorKind_ToString(ASWLog::ErrorKind::Exception)), "Exception should stringify as EXCEPTION");
     CheckEquals(std::string("ENTRIES_DROPPED"), std::string(ASWLog::ErrorKind_ToString(ASWLog::ErrorKind::EntriesDropped)), "EntriesDropped should stringify as ENTRIES_DROPPED");
-    CheckEquals(static_cast<std::size_t>(ASWLog::ErrorKind::EntriesDropped) + 1, ASWLog::ErrorKindCount, "ErrorKindCount should count every kind (EntriesDropped is the last)");
+    CheckEquals(std::string("INVALID_SETTING"), std::string(ASWLog::ErrorKind_ToString(ASWLog::ErrorKind::InvalidSetting)), "InvalidSetting should stringify as INVALID_SETTING");
+    CheckEquals(static_cast<std::size_t>(ASWLog::ErrorKind::InvalidSetting) + 1, ASWLog::ErrorKindCount, "ErrorKindCount should count every kind (InvalidSetting is the last)");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_FlushMode_FromString()
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index 4db7397..ddbafae 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -48,6 +48,7 @@ limitations under the License.
 #include "ASWUnitTests_Registry.h"
 //---------------------------------------------------------------------------
 #include "UT_Helper_DateTime.h"
+#include "UT_Helper_Environment.h"
 //---------------------------------------------------------------------------
 
 namespace ASWUnitTests
@@ -107,6 +108,7 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_ApplyMultilineMode_FindsLineBreaksAnywhereInALongText, "ApplyMultilineMode_FindsLineBreaksAnywhereInALongText");
     RegisterTest(&TTest_ASWLog_Utils::Test_ApplyMultilineMode_IndentMarksEachLineAfterTheFirst, "ApplyMultilineMode_IndentMarksEachLineAfterTheFirst");
     RegisterTest(&TTest_ASWLog_Utils::Test_ApplyMultilineMode_LeavesOtherLinesAsTheyAre, "ApplyMultilineMode_LeavesOtherLinesAsTheyAre");
+    RegisterTest(&TTest_ASWLog_Utils::Test_EqualsIgnoringCase_IgnoresOnlyASCIICase, "EqualsIgnoringCase_IgnoresOnlyASCIICase");
     RegisterTest(&TTest_ASWLog_Utils::Test_GenerateLogFileName_ContainsExpectedFields, "GenerateLogFileName_ContainsExpectedFields");
     RegisterTest(&TTest_ASWLog_Utils::Test_GenerateLogFileName_PrefixAndPostfixAreOptional, "GenerateLogFileName_PrefixAndPostfixAreOptional");
     RegisterTest(&TTest_ASWLog_Utils::Test_GetCurrentOSProcessId_MatchesOS, "GetCurrentOSProcessId_MatchesOS");
@@ -121,6 +123,7 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_JSON_AppendString_KeepsValidUTF8, "JSON_AppendString_KeepsValidUTF8");
     RegisterTest(&TTest_ASWLog_Utils::Test_JSON_AppendString_ReplacesInvalidUTF8, "JSON_AppendString_ReplacesInvalidUTF8");
     RegisterTest(&TTest_ASWLog_Utils::Test_MatchesWildcard_Patterns, "MatchesWildcard_Patterns");
+    RegisterTest(&TTest_ASWLog_Utils::Test_ReadEnvironmentVariable_ReadsUTF8Values, "ReadEnvironmentVariable_ReadsUTF8Values");
     RegisterTest(&TTest_ASWLog_Utils::Test_RenameWithoutReplacing_KeepsExistingTarget, "RenameWithoutReplacing_KeepsExistingTarget");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime, "Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_ToDateString, "Time_ToDateString");
@@ -130,7 +133,9 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_CalendarEdges, "Time_WriteISO8601_CalendarEdges");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_LocalTimeWithEachPrecision, "Time_WriteISO8601_LocalTimeWithEachPrecision");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision, "Time_WriteISO8601_UTCWithEachPrecision");
+    RegisterTest(&TTest_ASWLog_Utils::Test_TrimSpaces_RemovesOuterSpacesAndTabs, "TrimSpaces_RemovesOuterSpacesAndTabs");
     RegisterTest(&TTest_ASWLog_Utils::Test_UTF8ToWideString_ConvertsToUTF16, "UTF8ToWideString_ConvertsToUTF16");
+    RegisterTest(&TTest_ASWLog_Utils::Test_WideStringToUTF8_ConvertsFromUTF16, "WideStringToUTF8_ConvertsFromUTF16");
 }
 //---------------------------------------------------------------------------
 TTest_ASWLog_Utils::~TTest_ASWLog_Utils()
@@ -265,6 +270,20 @@ void TTest_ASWLog_Utils::Test_ApplyMultilineMode_LeavesOtherLinesAsTheyAre()
     CheckEquals(std::string(), ApplyMode("", ASWLog::MultilineMode::Indent), "An empty line should stay empty");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_EqualsIgnoringCase_IgnoresOnlyASCIICase()
+{
+    // Arrange / Act / Assert
+    CheckTrue(ASWLog::Detail::EqualsIgnoringCase("", ""), "Two empty texts should be equal");
+    CheckTrue(ASWLog::Detail::EqualsIgnoringCase("Net.Http_2", "NET.HTTP_2"), "Letters should match in either case");
+    CheckTrue(ASWLog::Detail::EqualsIgnoringCase("az", "AZ"), "The first and last letters should match too");
+    CheckFalse(ASWLog::Detail::EqualsIgnoringCase("Net", "Nets"), "Texts of different lengths should differ");
+    CheckFalse(ASWLog::Detail::EqualsIgnoringCase("Nets", "Net"), "Texts of different lengths should differ either way");
+    CheckFalse(ASWLog::Detail::EqualsIgnoringCase("abc", "abd"), "Different letters should differ");
+    CheckFalse(ASWLog::Detail::EqualsIgnoringCase("@", "`"), "Characters next to the letters should not be folded");
+    CheckFalse(ASWLog::Detail::EqualsIgnoringCase("[", "{"), "Characters next to the letters should not be folded");
+    CheckFalse(ASWLog::Detail::EqualsIgnoringCase("\xC3\x84", "\xC3\xA4"), "Non-ASCII letters should keep their case");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_GenerateLogFileName_ContainsExpectedFields()
 {
     // Arrange
@@ -601,6 +620,33 @@ void TTest_ASWLog_Utils::Test_MatchesWildcard_Patterns()
     CheckTrue(ASWLog::MatchesWildcard("no_extension", "*"), "A lone '*' should match any name, with or without a dot");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_ReadEnvironmentVariable_ReadsUTF8Values()
+{
+    // Arrange: a name with a lambda in it, a value with a lambda and a CJK character, and a value longer than any
+    // first guess at its size
+    const std::string longValue(5000, 'x');
+    TScopedEnvironmentVariable unset("ASWLOGTEST_UTILS_UNSET", std::nullopt);
+    TScopedEnvironmentVariable empty("ASWLOGTEST_UTILS_EMPTY", "");
+    TScopedEnvironmentVariable plain("ASWLOGTEST_UTILS_PLAIN", "plain value");
+    TScopedEnvironmentVariable utf8("ASWLOGTEST_UTILS_\xCE\xBB", "a\xCE\xBB\xE6\x97\xA5");
+    TScopedEnvironmentVariable longVariable("ASWLOGTEST_UTILS_LONG", longValue);
+
+    // Act
+    const auto unsetValue = ASWLog::Detail::ReadEnvironmentVariable("ASWLOGTEST_UTILS_UNSET");
+    const auto emptyValue = ASWLog::Detail::ReadEnvironmentVariable("ASWLOGTEST_UTILS_EMPTY");
+    const auto plainValue = ASWLog::Detail::ReadEnvironmentVariable("ASWLOGTEST_UTILS_PLAIN");
+    const auto utf8Value = ASWLog::Detail::ReadEnvironmentVariable("ASWLOGTEST_UTILS_\xCE\xBB");
+    const auto longReadValue = ASWLog::Detail::ReadEnvironmentVariable("ASWLOGTEST_UTILS_LONG");
+
+    // Assert
+    CheckFalse(unsetValue.has_value(), "An unset variable should give nullopt");
+    CheckTrue(emptyValue.has_value(), "A variable set to an empty value should be set");
+    CheckEquals(std::string(), emptyValue.value_or("unset"), "A variable set to an empty value should give an empty text");
+    CheckEquals(std::string("plain value"), plainValue.value_or("unset"), "A variable should give its value");
+    CheckEquals(std::string("a\xCE\xBB\xE6\x97\xA5"), utf8Value.value_or("unset"), "A non-ASCII name and value should be UTF-8");
+    CheckEquals(longValue, longReadValue.value_or("unset"), "A long value should be read whole");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_RenameWithoutReplacing_KeepsExistingTarget()
 {
     // Arrange
@@ -819,6 +865,16 @@ void TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision()
     }
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_TrimSpaces_RemovesOuterSpacesAndTabs()
+{
+    // Arrange / Act / Assert
+    CheckEquals(std::string(), std::string(ASWLog::Detail::TrimSpaces("")), "An empty text should stay empty");
+    CheckEquals(std::string(), std::string(ASWLog::Detail::TrimSpaces(" \t \t")), "Only spaces and tabs should become empty");
+    CheckEquals(std::string("a b"), std::string(ASWLog::Detail::TrimSpaces("\t a b \t")), "Outer spaces and tabs should go, inner ones stay");
+    CheckEquals(std::string("x"), std::string(ASWLog::Detail::TrimSpaces("x")), "A single character should stay");
+    CheckEquals(std::string("\nx\n"), std::string(ASWLog::Detail::TrimSpaces(" \nx\n ")), "Line breaks should stay");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_UTF8ToWideString_ConvertsToUTF16()
 {
 #if defined(_WIN32)
@@ -842,6 +898,29 @@ void TTest_ASWLog_Utils::Test_UTF8ToWideString_ConvertsToUTF16()
 #endif
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_WideStringToUTF8_ConvertsFromUTF16()
+{
+#if defined(_WIN32)
+    // Arrange: ASCII, a 2-byte and a 4-byte character (a surrogate pair in UTF-16), and an unpaired surrogate
+    struct TCase
+    {
+        std::wstring Text;
+        std::string Expected;
+    };
+
+    const std::vector<TCase> cases{
+        { L"", "" }, { L"plain text\n", "plain text\n" }, { L"a\x03BB" L"b", "a\xCE\xBB" "b" },
+        { L"\xD83D\xDE00", "\xF0\x9F\x98\x80" }, { L"x\xD800y", "x\xEF\xBF\xBDy" }
+    };
+
+    // Act & Assert
+    for (const auto& item : cases)
+        CheckEquals(item.Expected, ASWLog::Detail::WideStringToUTF8(item.Text), "UTF-16 should become UTF-8: " + ToHex(item.Expected));
+#else
+    Skip("WideStringToUTF8() exists only on Windows");
+#endif
+}
+//---------------------------------------------------------------------------
 
 } // namespace ASWUnitTests
 
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index 1a9a560..2a15eca 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -40,6 +40,7 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_ApplyMultilineMode_FindsLineBreaksAnywhereInALongText();
     void Test_ApplyMultilineMode_IndentMarksEachLineAfterTheFirst();
     void Test_ApplyMultilineMode_LeavesOtherLinesAsTheyAre();
+    void Test_EqualsIgnoringCase_IgnoresOnlyASCIICase();
     void Test_GenerateLogFileName_ContainsExpectedFields();
     void Test_GenerateLogFileName_PrefixAndPostfixAreOptional();
     void Test_GetCurrentOSProcessId_MatchesOS();
@@ -54,6 +55,7 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_JSON_AppendString_KeepsValidUTF8();
     void Test_JSON_AppendString_ReplacesInvalidUTF8();
     void Test_MatchesWildcard_Patterns();
+    void Test_ReadEnvironmentVariable_ReadsUTF8Values();
     void Test_RenameWithoutReplacing_KeepsExistingTarget();
     void Test_Time_GetUTCOffsetMinutes_FollowsDaylightSavingTime();
     void Test_Time_ToDateString();
@@ -63,7 +65,9 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_Time_WriteISO8601_CalendarEdges();
     void Test_Time_WriteISO8601_LocalTimeWithEachPrecision();
     void Test_Time_WriteISO8601_UTCWithEachPrecision();
+    void Test_TrimSpaces_RemovesOuterSpacesAndTabs();
     void Test_UTF8ToWideString_ConvertsToUTF16();
+    void Test_WideStringToUTF8_ConvertsFromUTF16();
 
 public:
     TTest_ASWLog_Utils();
diff --git a/tests/tests/UT_Helper_Environment.cpp b/tests/tests/UT_Helper_Environment.cpp
new file mode 100644
index 0000000..b86bffa
--- /dev/null
+++ b/tests/tests/UT_Helper_Environment.cpp
@@ -0,0 +1,127 @@
+/* **************************************************************************
+UT_Helper_Environment.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "UT_Helper_Environment.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstdlib>
+#include <utility>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+#if defined(_WIN32)
+namespace
+{
+
+std::string ToUTF8(const std::wstring& text);
+std::wstring ToWide(const std::string& text);
+
+//---------------------------------------------------------------------------
+
+// 'text' (UTF-16) as UTF-8
+std::string ToUTF8(const std::wstring& text)
+{
+    const int size = WideCharToMultiByte(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), nullptr, 0, nullptr, nullptr);
+    std::string utf8(static_cast<std::size_t>(size), '\0');
+    WideCharToMultiByte(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), utf8.data(), size, nullptr, nullptr);
+
+    return utf8;
+}
+
+// 'text' (UTF-8) as UTF-16, converted here rather than with the library's helper the tests check
+std::wstring ToWide(const std::string& text)
+{
+    const int size = MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), nullptr, 0);
+    std::wstring wide(static_cast<std::size_t>(size), L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), wide.data(), size);
+
+    return wide;
+}
+
+} // namespace
+#endif
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TScopedEnvironmentVariable
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TScopedEnvironmentVariable::TScopedEnvironmentVariable(std::string name, std::optional<std::string> value)
+    : m_Name(std::move(name)),
+      m_PreviousValue(Get(m_Name))
+{
+    Set(m_Name, value);
+}
+//---------------------------------------------------------------------------
+TScopedEnvironmentVariable::~TScopedEnvironmentVariable()
+{
+    Set(m_Name, m_PreviousValue);
+}
+//---------------------------------------------------------------------------
+std::optional<std::string> TScopedEnvironmentVariable::Get(const std::string& name)
+{
+#if defined(_WIN32)
+    // The Windows API rather than the C runtime, since that's what the logger reads (and MinGW's runtime has no
+    // _dupenv_s)
+    const auto wideName = ToWide(name);
+    const DWORD size = GetEnvironmentVariableW(wideName.c_str(), nullptr, 0);
+    if (size == 0)
+        return std::nullopt;
+
+    std::wstring value(size, L'\0');
+    value.resize(GetEnvironmentVariableW(wideName.c_str(), value.data(), size));
+
+    return ToUTF8(value);
+#else
+    const char* value = std::getenv(name.c_str());
+    if (value == nullptr)
+        return std::nullopt;
+
+    return std::string(value);
+#endif
+}
+//---------------------------------------------------------------------------
+void TScopedEnvironmentVariable::Set(const std::string& name, const std::optional<std::string>& value)
+{
+#if defined(_WIN32)
+    // nullptr removes the variable
+    SetEnvironmentVariableW(ToWide(name).c_str(), value ? ToWide(*value).c_str() : nullptr);
+#else
+    if (value)
+        setenv(name.c_str(), value->c_str(), 1);
+    else
+        unsetenv(name.c_str());
+#endif
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
diff --git a/tests/tests/UT_Helper_Environment.h b/tests/tests/UT_Helper_Environment.h
new file mode 100644
index 0000000..8a315ca
--- /dev/null
+++ b/tests/tests/UT_Helper_Environment.h
@@ -0,0 +1,60 @@
+/* **************************************************************************
+UT_Helper_Environment.h
+Author: Anthony S. West - ASW Software
+
+Environment variable helpers shared by the unit tests.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#ifndef UT_Helper_EnvironmentH
+#define UT_Helper_EnvironmentH
+//---------------------------------------------------------------------------
+#include <optional>
+#include <string>
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TScopedEnvironmentVariable
+//
+// While alive, sets an environment variable (or removes it, given std::nullopt), then restores its previous value.
+// Names and values are UTF-8 (set with the wide Windows API on Windows, which is what the logger reads there).
+///////////////////////////////////////////////////////////////////////////
+class TScopedEnvironmentVariable
+{
+private:
+    std::string m_Name;
+    std::optional<std::string> m_PreviousValue;
+
+private:
+    static std::optional<std::string> Get(const std::string& name);
+    static void Set(const std::string& name, const std::optional<std::string>& value);
+
+public:
+    TScopedEnvironmentVariable(std::string name, std::optional<std::string> value);
+    ~TScopedEnvironmentVariable();
+
+    TScopedEnvironmentVariable(const TScopedEnvironmentVariable&) = delete;
+    TScopedEnvironmentVariable& operator=(const TScopedEnvironmentVariable&) = delete;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef UT_Helper_EnvironmentH
diff --git a/tests/tests/UT_Helper_StdErr.cpp b/tests/tests/UT_Helper_StdErr.cpp
new file mode 100644
index 0000000..a83b0b0
--- /dev/null
+++ b/tests/tests/UT_Helper_StdErr.cpp
@@ -0,0 +1,96 @@
+/* **************************************************************************
+UT_Helper_StdErr.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "UT_Helper_StdErr.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstdio>
+
+#if defined(_WIN32)
+#include <io.h>
+#include <share.h>
+#else
+#include <unistd.h>
+#endif
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TStdErrRedirect
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TStdErrRedirect::TStdErrRedirect(const std::filesystem::path& file)
+{
+    std::fflush(stderr);
+#if defined(_WIN32)
+    std::FILE* target = _wfsopen(file.c_str(), L"wb", _SH_DENYNO);
+    if (target == nullptr)
+        return;
+
+    m_SavedDescriptor = _dup(_fileno(stderr));
+    if (m_SavedDescriptor >= 0 && _dup2(_fileno(target), _fileno(stderr)) != 0)
+    {
+        _close(m_SavedDescriptor);
+        m_SavedDescriptor = -1;
+    }
+#else
+    std::FILE* target = std::fopen(file.c_str(), "wb");
+    if (target == nullptr)
+        return;
+
+    m_SavedDescriptor = dup(fileno(stderr));
+    if (m_SavedDescriptor >= 0 && dup2(fileno(target), fileno(stderr)) < 0)
+    {
+        close(m_SavedDescriptor);
+        m_SavedDescriptor = -1;
+    }
+#endif
+    std::fclose(target);
+}
+//---------------------------------------------------------------------------
+TStdErrRedirect::~TStdErrRedirect()
+{
+    if (m_SavedDescriptor < 0)
+        return;
+
+    std::fflush(stderr);
+#if defined(_WIN32)
+    _dup2(m_SavedDescriptor, _fileno(stderr));
+    _close(m_SavedDescriptor);
+#else
+    dup2(m_SavedDescriptor, fileno(stderr));
+    close(m_SavedDescriptor);
+#endif
+}
+//---------------------------------------------------------------------------
+bool TStdErrRedirect::IsActive() const noexcept
+{
+    return m_SavedDescriptor >= 0;
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
diff --git a/tests/tests/UT_Helper_StdErr.h b/tests/tests/UT_Helper_StdErr.h
new file mode 100644
index 0000000..0fe5b94
--- /dev/null
+++ b/tests/tests/UT_Helper_StdErr.h
@@ -0,0 +1,56 @@
+/* **************************************************************************
+UT_Helper_StdErr.h
+Author: Anthony S. West - ASW Software
+
+stderr helpers shared by the unit tests.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#ifndef UT_Helper_StdErrH
+#define UT_Helper_StdErrH
+//---------------------------------------------------------------------------
+#include <filesystem>
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TStdErrRedirect
+//
+// While alive, sends what is written to stderr to 'file' instead, by pointing stderr's file descriptor at it. Inactive
+// if stderr has no file descriptor (e.g. in a GUI application without a console).
+///////////////////////////////////////////////////////////////////////////
+class TStdErrRedirect
+{
+private:
+    int m_SavedDescriptor = -1;
+
+public:
+    explicit TStdErrRedirect(const std::filesystem::path& file);
+    ~TStdErrRedirect();
+
+    TStdErrRedirect(const TStdErrRedirect&) = delete;
+    TStdErrRedirect& operator=(const TStdErrRedirect&) = delete;
+
+    bool IsActive() const noexcept;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef UT_Helper_StdErrH
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index 3fba304..eb4767b 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -348,10 +348,18 @@
             <DependentOn>..\..\..\tests\UT_Helper_DateTime.h</DependentOn>
             <BuildOrder>44</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\UT_Helper_Environment.cpp">
+            <DependentOn>..\..\..\tests\UT_Helper_Environment.h</DependentOn>
+            <BuildOrder>64</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\UT_Helper_JSON.cpp">
             <DependentOn>..\..\..\tests\UT_Helper_JSON.h</DependentOn>
             <BuildOrder>49</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\UT_Helper_StdErr.cpp">
+            <DependentOn>..\..\..\tests\UT_Helper_StdErr.h</DependentOn>
+            <BuildOrder>65</BuildOrder>
+        </CppCompile>
         <CppCompile Include="ASWLogTests_VCL_GUI.cpp">
             <BuildOrder>0</BuildOrder>
         </CppCompile>

From 5865b2eac436fe1ef850348a19d7f00065d4d7eb Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 12:13:59 -0700
Subject: [PATCH 20/38] Add wide-string logging overloads

---
 ASWLog/ASWLog_DebuggerLog.cpp                 |   3 +-
 ASWLog/ASWLog_Interface.cpp                   |  37 +
 ASWLog/ASWLog_Interface.h                     | 339 +++++++-
 ASWLog/ASWLog_Unicode.cpp                     | 317 ++++++++
 ASWLog/ASWLog_Unicode.h                       | 219 +++++
 ASWLog/ASWLog_Utils.cpp                       |  42 +-
 ASWLog/ASWLog_Utils.h                         |  18 -
 ASWLog/ASWLog_WindowsEventLog.cpp             |   7 +-
 CHANGELOG.md                                  |  18 +
 CMakeLists.txt                                |   2 +
 Deploy.bat                                    |   4 +
 example/rad370/ASWLogExample.cbproj           |   4 +
 tests/cmake/CMakeLists.txt                    |   3 +-
 tests/compile_checks/Check_FormatString.cpp   |  14 +
 tests/rad370/ASWLogTests.cbproj               |   8 +
 tests/tests/Test_ASWLog_Unicode.cpp           | 752 ++++++++++++++++++
 tests/tests/Test_ASWLog_Unicode.h             |  67 ++
 tests/tests/Test_ASWLog_Utils.cpp             |  48 --
 tests/tests/Test_ASWLog_Utils.h               |   2 -
 .../vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj |   8 +
 20 files changed, 1800 insertions(+), 112 deletions(-)
 create mode 100644 ASWLog/ASWLog_Unicode.cpp
 create mode 100644 ASWLog/ASWLog_Unicode.h
 create mode 100644 tests/tests/Test_ASWLog_Unicode.cpp
 create mode 100644 tests/tests/Test_ASWLog_Unicode.h

diff --git a/ASWLog/ASWLog_DebuggerLog.cpp b/ASWLog/ASWLog_DebuggerLog.cpp
index 3c7fa26..2190822 100644
--- a/ASWLog/ASWLog_DebuggerLog.cpp
+++ b/ASWLog/ASWLog_DebuggerLog.cpp
@@ -33,6 +33,7 @@ limitations under the License.
 #endif
 //---------------------------------------------------------------------------
 #include "ASWLog_CrashHandler.h"
+#include "ASWLog_Unicode.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
 
@@ -143,7 +144,7 @@ void TASWDebuggerLog::WriteCrashLineDirect(std::string_view line) noexcept
 void TASWDebuggerLog::WriteLineUnlocked(Level /*level*/, std::string_view line, bool /*endsLine*/)
 {
 #if defined(_WIN32)
-    OutputDebugStringW(Detail::UTF8ToWideString(line).c_str());
+    OutputDebugStringW(UTF8ToWide(line).c_str());
 #else
     static_cast<void>(line);
 #endif
diff --git a/ASWLog/ASWLog_Interface.cpp b/ASWLog/ASWLog_Interface.cpp
index 8d640ab..f36e96c 100644
--- a/ASWLog/ASWLog_Interface.cpp
+++ b/ASWLog/ASWLog_Interface.cpp
@@ -25,6 +25,7 @@ limitations under the License.
 #include "ASWLog_Interface.h"
 //---------------------------------------------------------------------------
 // System includes here
+#include <span>
 //---------------------------------------------------------------------------
 
 namespace ASWLog
@@ -32,4 +33,40 @@ namespace ASWLog
 
 //---------------------------------------------------------------------------
 
+/////////////////////////////////////////////////////////////////////////////
+// IASWLog
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+void IASWLog::WriteWide(Level level, TASWWideText message, const std::initializer_list<TASWLogField>* fields,
+    std::source_location loc, bool raw, bool forced) noexcept
+{
+    TASWLogRecord record = MakeRecord(level, {}, loc, raw, forced);
+    if (!ShouldLog(record))
+        return;
+
+    std::string utf8;
+    try
+    {
+        utf8 = message.ToUTF8();
+    }
+    catch (...)
+    {
+        return; // Out of memory: the entry is dropped, as Write() drops one it can't write
+    }
+
+    record.Message = utf8;
+
+    std::span<const TASWLogField> ownFields;
+    if (fields != nullptr)
+    {
+        ownFields = std::span<const TASWLogField>(fields->begin(), fields->size());
+        record.Fields = &ownFields;
+    }
+
+    Write(record);
+}
+
+//---------------------------------------------------------------------------
+
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_Interface.h b/ASWLog/ASWLog_Interface.h
index 5dc5439..e3cc936 100644
--- a/ASWLog/ASWLog_Interface.h
+++ b/ASWLog/ASWLog_Interface.h
@@ -40,6 +40,7 @@ limitations under the License.
 //---------------------------------------------------------------------------
 #include "ASWLog_Config.h"
 #include "ASWLog_Types.h"
+#include "ASWLog_Unicode.h"
 //---------------------------------------------------------------------------
 
 namespace ASWLog
@@ -55,16 +56,27 @@ struct TASWRuntimeFormat
     std::string_view Format;
 };
 
+// A wide format string known only at run time, made by RuntimeFormat()
+struct TASWWideRuntimeFormat
+{
+    std::wstring_view Format;
+};
+
 // Passes a format string that isn't a compile-time constant (e.g. one read from a file) to a *Fmt method, which checks
 // any other format string against its arguments at compile time. This one is checked when the entry is formatted
 // instead: a mismatch logs "[ASWLog format error: <reason>] <format string>" (see TASWFormatString::FormatMessage()),
 // which isn't reported to TASWLogConfig::OnError, since the entry is still written. Like C++26's std::runtime_format,
-// it holds a view of 'format', so the string must outlive the *Fmt call.
+// it holds a view of 'format', so the string must outlive the *Fmt call. Also for a wide format string.
 [[nodiscard]] constexpr TASWRuntimeFormat RuntimeFormat(std::string_view format) noexcept
 {
     return TASWRuntimeFormat{ format };
 }
 
+[[nodiscard]] constexpr TASWWideRuntimeFormat RuntimeFormat(std::wstring_view format) noexcept
+{
+    return TASWWideRuntimeFormat{ format };
+}
+
 
 /////////////////////////////////////////////////////////////////////////////
 // TASWFormatString
@@ -133,6 +145,70 @@ struct TASWFormatString
 };
 
 
+/////////////////////////////////////////////////////////////////////////////
+// TASWWideFormatString
+//
+// A wide (wchar_t) format string plus the source location of the call that passed it, taken by the *Fmt methods like
+// TASWFormatString: checked against the arguments at compile time, like std::wformat_string's, and formatted with
+// std::format's wide functions, then converted to UTF-8. Its arguments must be formattable as wide text: numbers, wide
+// strings, ASWLog::Wide() for char16_t text, and ASWLog::UTF8() for UTF-8 text (narrow strings aren't accepted). A
+// format string known only at run time must be wrapped in RuntimeFormat().
+/////////////////////////////////////////////////////////////////////////////
+template<typename ... Args>
+struct TASWWideFormatString
+{
+    std::wstring_view Format;
+    std::source_location Location;
+
+    template<typename T>
+    requires std::convertible_to<const T&, std::wstring_view>
+    consteval TASWWideFormatString(const T& format, std::source_location location = std::source_location::current()) noexcept
+        : Format(format),
+          Location(location)
+    {
+        // std::wformat_string's constructor fails to compile if the format string doesn't match Args
+        [[maybe_unused]] const std::wformat_string<Args...> checkedFormat(Format);
+    }
+
+    TASWWideFormatString(TASWWideRuntimeFormat format, std::source_location location = std::source_location::current()) noexcept
+        : Format(format.Format),
+          Location(location)
+    {
+    }
+
+    // Formats the message from 'args', as UTF-8. Never throws: if formatting fails, returns "[ASWLog format error:
+    // <reason>] <format string>" instead (see TASWFormatString::FormatMessage()).
+    [[nodiscard]] std::string FormatMessage(Args&... args) const noexcept
+    {
+        try
+        {
+            return WideToUTF8(std::vformat(Format, std::make_wformat_args(args ...)));
+        }
+        catch (const std::exception& error)
+        {
+            return DescribeFormatError(error.what());
+        }
+        catch (...)
+        {
+            return DescribeFormatError("unknown exception");
+        }
+    }
+
+private:
+    [[nodiscard]] std::string DescribeFormatError(std::string_view reason) const noexcept
+    {
+        try
+        {
+            return std::string("[ASWLog format error: ").append(reason).append("] ").append(WideToUTF8(Format));
+        }
+        catch (...)
+        {
+            return {}; // Out of memory: log an empty entry rather than throw
+        }
+    }
+};
+
+
 /////////////////////////////////////////////////////////////////////////////
 // IASWLog
 //
@@ -160,6 +236,11 @@ class IASWLog
         return record;
     }
 
+    // Writes an entry whose message is wide text, converted to UTF-8 only if the logger would use the entry. 'fields'
+    // may be null.
+    void WriteWide(Level level, TASWWideText message, const std::initializer_list<TASWLogField>* fields,
+        std::source_location loc, bool raw, bool forced) noexcept;
+
     // Writes an entry with fields: the record points to the list, which lives during the call
     void WriteWithFields(Level level, std::string_view message, std::initializer_list<TASWLogField> fields,
         std::source_location loc, bool raw, bool forced) noexcept
@@ -357,6 +438,120 @@ class IASWLog
         WriteWithFields(Level::Critical, msg, fields, loc, false, false);
     }
 
+    // --- Non-virtual Inline Logging Methods With Wide Text ---
+    // As above, for a message of wide text: wchar_t (e.g. L"Opened", a std::wstring, or C++Builder's
+    // UnicodeString::c_str()) or char16_t (e.g. u"Opened"; see TASWWideText). The message is converted to UTF-8 only if
+    // the entry would be used (see ShouldLog()), so a filtered call converts nothing. Field keys and texts stay UTF-8.
+    inline void Log(Level level, TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, nullptr, loc, false, false);
+    }
+
+    inline void LogRaw(Level level, TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, nullptr, loc, true, false);
+    }
+
+    inline void LogForce(Level level, TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, nullptr, loc, false, true);
+    }
+
+    inline void LogForceRaw(Level level, TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, nullptr, loc, true, true);
+    }
+
+    inline void LogTrace(TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Trace, msg, nullptr, loc, false, false);
+    }
+
+    inline void LogDebug(TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Debug, msg, nullptr, loc, false, false);
+    }
+
+    inline void LogInfo(TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Info, msg, nullptr, loc, false, false);
+    }
+
+    inline void LogWarn(TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Warn, msg, nullptr, loc, false, false);
+    }
+
+    inline void LogError(TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Error, msg, nullptr, loc, false, false);
+    }
+
+    inline void LogCritical(TASWWideText msg, std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Critical, msg, nullptr, loc, false, false);
+    }
+
+    inline void Log(Level level, TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, &fields, loc, false, false);
+    }
+
+    inline void LogRaw(Level level, TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, &fields, loc, true, false);
+    }
+
+    inline void LogForce(Level level, TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, &fields, loc, false, true);
+    }
+
+    inline void LogForceRaw(Level level, TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(level, msg, &fields, loc, true, true);
+    }
+
+    inline void LogTrace(TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Trace, msg, &fields, loc, false, false);
+    }
+
+    inline void LogDebug(TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Debug, msg, &fields, loc, false, false);
+    }
+
+    inline void LogInfo(TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Info, msg, &fields, loc, false, false);
+    }
+
+    inline void LogWarn(TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Warn, msg, &fields, loc, false, false);
+    }
+
+    inline void LogError(TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Error, msg, &fields, loc, false, false);
+    }
+
+    inline void LogCritical(TASWWideText msg, std::initializer_list<TASWLogField> fields,
+        std::source_location loc = std::source_location::current()) noexcept
+    {
+        WriteWide(Level::Critical, msg, &fields, loc, false, false);
+    }
+
     // --- Non-virtual Inline Template Format Methods ---
     // Each passes on the caller's source location, captured by TASWFormatString. The format string is checked against
     // the arguments at compile time. Use RuntimeFormat() to wrap run time format strings. A formatting error at run
@@ -503,6 +698,148 @@ class IASWLog
     {
         LogFmt(Level::Critical, fields, fmt, std::forward<Args>(args) ...);
     }
+
+    // --- Non-virtual Inline Template Format Methods With a Wide Format String ---
+    // As above, with a wchar_t format string, e.g. LogInfoFmt(L"Opened {} ({} bytes)", fileName, size), whose
+    // arguments are formatted as wide text (see TASWWideFormatString) and the message converted to UTF-8. Only when the
+    // entry would be written, as above.
+    template<typename ... Args>
+    inline void LogFmt(Level level, TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (ShouldLog(level))
+            Log(level, fmt.FormatMessage(args ...), fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogRawFmt(Level level, TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (ShouldLog(level))
+            LogRaw(level, fmt.FormatMessage(args ...), fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogForceFmt(Level level, TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (level != Level::Off && IsEnabled())
+            LogForce(level, fmt.FormatMessage(args ...), fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogForceRawFmt(Level level, TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (level != Level::Off && IsEnabled())
+            LogForceRaw(level, fmt.FormatMessage(args ...), fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogTraceFmt(TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        LogFmt(Level::Trace, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogDebugFmt(TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        LogFmt(Level::Debug, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogInfoFmt(TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        LogFmt(Level::Info, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogWarnFmt(TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        LogFmt(Level::Warn, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogErrorFmt(TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        LogFmt(Level::Error, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogCriticalFmt(TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        LogFmt(Level::Critical, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogFmt(Level level, std::initializer_list<TASWLogField> fields, TASWWideFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        if (ShouldLog(level))
+            Log(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogRawFmt(Level level, std::initializer_list<TASWLogField> fields,
+        TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (ShouldLog(level))
+            LogRaw(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogForceFmt(Level level, std::initializer_list<TASWLogField> fields,
+        TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (level != Level::Off && IsEnabled())
+            LogForce(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogForceRawFmt(Level level, std::initializer_list<TASWLogField> fields,
+        TASWWideFormatString<std::type_identity_t<Args>...> fmt, Args&&... args) noexcept
+    {
+        if (level != Level::Off && IsEnabled())
+            LogForceRaw(level, fmt.FormatMessage(args ...), fields, fmt.Location);
+    }
+
+    template<typename ... Args>
+    inline void LogTraceFmt(std::initializer_list<TASWLogField> fields, TASWWideFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Trace, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogDebugFmt(std::initializer_list<TASWLogField> fields, TASWWideFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Debug, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogInfoFmt(std::initializer_list<TASWLogField> fields, TASWWideFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Info, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogWarnFmt(std::initializer_list<TASWLogField> fields, TASWWideFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Warn, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogErrorFmt(std::initializer_list<TASWLogField> fields, TASWWideFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Error, fields, fmt, std::forward<Args>(args) ...);
+    }
+
+    template<typename ... Args>
+    inline void LogCriticalFmt(std::initializer_list<TASWLogField> fields, TASWWideFormatString<std::type_identity_t<Args>...> fmt,
+        Args&&... args) noexcept
+    {
+        LogFmt(Level::Critical, fields, fmt, std::forward<Args>(args) ...);
+    }
 };
 
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_Unicode.cpp b/ASWLog/ASWLog_Unicode.cpp
new file mode 100644
index 0000000..451048a
--- /dev/null
+++ b/ASWLog/ASWLog_Unicode.cpp
@@ -0,0 +1,317 @@
+/* **************************************************************************
+ASWLog_Unicode.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "ASWLog_Unicode.h"
+//---------------------------------------------------------------------------
+// System includes here
+#include <cstddef>
+#include <cstdint>
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+namespace
+{
+
+constexpr char32_t ReplacementCharacter = 0xFFFD;
+
+//---------------------------------------------------------------------------
+
+void AppendUTF8(std::string& output, char32_t character);
+template<typename TChar>
+void AppendUTF16(std::basic_string<TChar>& output, char32_t character);
+template<typename TChar>
+char32_t DecodeUTF16(std::basic_string_view<TChar> text, std::size_t& index) noexcept;
+char32_t DecodeUTF8(std::string_view text, std::size_t& index) noexcept;
+template<typename TChar>
+std::basic_string<TChar> ToUTF16(std::string_view text);
+template<typename TChar>
+std::string ToUTF8(std::basic_string_view<TChar> text);
+
+//---------------------------------------------------------------------------
+
+/*
+  AppendUTF8
+
+  Appends 'character' (a Unicode scalar value) to 'output' as UTF-8
+*/
+void AppendUTF8(std::string& output, char32_t character)
+{
+    if (character < 0x80)
+    {
+        output += static_cast<char>(character);
+    }
+    else if (character < 0x800)
+    {
+        output += static_cast<char>(0xC0 | (character >> 6));
+        output += static_cast<char>(0x80 | (character & 0x3F));
+    }
+    else if (character < 0x10000)
+    {
+        output += static_cast<char>(0xE0 | (character >> 12));
+        output += static_cast<char>(0x80 | ((character >> 6) & 0x3F));
+        output += static_cast<char>(0x80 | (character & 0x3F));
+    }
+    else
+    {
+        output += static_cast<char>(0xF0 | (character >> 18));
+        output += static_cast<char>(0x80 | ((character >> 12) & 0x3F));
+        output += static_cast<char>(0x80 | ((character >> 6) & 0x3F));
+        output += static_cast<char>(0x80 | (character & 0x3F));
+    }
+}
+
+/*
+  AppendUTF16
+
+  Appends 'character' (a Unicode scalar value) to 'output' as UTF-16: one code unit, or a surrogate pair above U+FFFF
+*/
+template<typename TChar>
+void AppendUTF16(std::basic_string<TChar>& output, char32_t character)
+{
+    if (character < 0x10000)
+    {
+        output += static_cast<TChar>(character);
+        return;
+    }
+
+    character -= 0x10000;
+    output += static_cast<TChar>(0xD800 + (character >> 10));
+    output += static_cast<TChar>(0xDC00 + (character & 0x3FF));
+}
+
+/*
+  DecodeUTF16
+
+  The character at 'index' in 'text' (UTF-16 code units of type TChar: char16_t, or wchar_t where it has 16 bits),
+  moving 'index' past it: a code unit, or a surrogate pair; U+FFFD for an unpaired surrogate, which is skipped
+*/
+template<typename TChar>
+char32_t DecodeUTF16(std::basic_string_view<TChar> text, std::size_t& index) noexcept
+{
+    const char32_t unit = static_cast<std::uint16_t>(text[index++]);
+    if (unit < 0xD800 || unit > 0xDFFF)
+        return unit;
+
+    if (unit <= 0xDBFF && index < text.size())
+    {
+        const char32_t next = static_cast<std::uint16_t>(text[index]);
+        if (next >= 0xDC00 && next <= 0xDFFF)
+        {
+            ++index;
+            return 0x10000 + ((unit - 0xD800) << 10) + (next - 0xDC00);
+        }
+    }
+
+    return ReplacementCharacter;
+}
+
+/*
+  DecodeUTF8
+
+  The character at 'index' in 'text' (UTF-8), moving 'index' past it. An invalid sequence is U+FFFD (see the Unicode
+  standard's table of well-formed byte sequences): its longest start that could begin a valid sequence, at least one
+  byte, is skipped, so the byte that broke it starts the next character.
+*/
+char32_t DecodeUTF8(std::string_view text, std::size_t& index) noexcept
+{
+    const auto lead = static_cast<unsigned char>(text[index++]);
+    if (lead < 0x80)
+        return lead;
+
+    std::size_t length = 0;
+    char32_t character = 0;
+    unsigned char low = 0x80; // The range of the second byte, which some lead bytes narrow
+    unsigned char high = 0xBF;
+
+    if (lead >= 0xC2 && lead <= 0xDF)
+    {
+        length = 2;
+        character = lead & 0x1F;
+    }
+    else if (lead >= 0xE0 && lead <= 0xEF)
+    {
+        length = 3;
+        character = lead & 0x0F;
+        low = lead == 0xE0 ? 0xA0 : 0x80; // No overlong forms
+        high = lead == 0xED ? 0x9F : 0xBF; // No surrogates
+    }
+    else if (lead >= 0xF0 && lead <= 0xF4)
+    {
+        length = 4;
+        character = lead & 0x07;
+        low = lead == 0xF0 ? 0x90 : 0x80; // No overlong forms
+        high = lead == 0xF4 ? 0x8F : 0xBF; // Nothing above U+10FFFF
+    }
+    else
+    {
+        return ReplacementCharacter;
+    }
+
+    for (std::size_t count = 1; count < length; ++count)
+    {
+        if (index >= text.size())
+            return ReplacementCharacter;
+
+        const auto byte = static_cast<unsigned char>(text[index]);
+        if (byte < low || byte > high)
+            return ReplacementCharacter;
+
+        character = (character << 6) | (byte & 0x3F);
+        low = 0x80;
+        high = 0xBF;
+        ++index;
+    }
+
+    return character;
+}
+
+/*
+  ToUTF16
+
+  'text' (UTF-8) as UTF-16 code units of type TChar (char16_t, or wchar_t where it has 16 bits)
+*/
+template<typename TChar>
+std::basic_string<TChar> ToUTF16(std::string_view text)
+{
+    std::basic_string<TChar> output;
+    output.reserve(text.size());
+
+    for (std::size_t index = 0; index < text.size();)
+        AppendUTF16(output, DecodeUTF8(text, index));
+
+    return output;
+}
+
+/*
+  ToUTF8
+
+  'text' (UTF-16 code units of type TChar) as UTF-8
+*/
+template<typename TChar>
+std::string ToUTF8(std::basic_string_view<TChar> text)
+{
+    std::string output;
+    output.reserve(text.size());
+
+    for (std::size_t index = 0; index < text.size();)
+        AppendUTF8(output, DecodeUTF16(text, index));
+
+    return output;
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+std::u16string UTF8ToUTF16(std::string_view text)
+{
+    return ToUTF16<char16_t>(text);
+}
+
+//---------------------------------------------------------------------------
+std::wstring UTF8ToWide(std::string_view text)
+{
+    if constexpr (sizeof(wchar_t) == sizeof(char16_t))
+    {
+        return ToUTF16<wchar_t>(text);
+    }
+    else
+    {
+        std::wstring output;
+        output.reserve(text.size());
+
+        for (std::size_t index = 0; index < text.size();)
+            output += static_cast<wchar_t>(DecodeUTF8(text, index));
+
+        return output;
+    }
+}
+
+//---------------------------------------------------------------------------
+std::string WideToUTF8(std::wstring_view text)
+{
+    if constexpr (sizeof(wchar_t) == sizeof(char16_t))
+    {
+        return ToUTF8(text);
+    }
+    else
+    {
+        std::string output;
+        output.reserve(text.size());
+
+        for (const wchar_t unit : text)
+        {
+            const auto character = static_cast<char32_t>(unit);
+            const bool isCharacter = character <= 0x10FFFF && (character < 0xD800 || character > 0xDFFF);
+            AppendUTF8(output, isCharacter ? character : ReplacementCharacter);
+        }
+
+        return output;
+    }
+}
+
+//---------------------------------------------------------------------------
+std::string WideToUTF8(std::u16string_view text)
+{
+    return ToUTF8(text);
+}
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWWideText
+/////////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+std::wstring TASWWideText::ToWide() const
+{
+    if (m_UTF16.empty())
+        return std::wstring(m_Wide);
+
+    if constexpr (sizeof(wchar_t) == sizeof(char16_t))
+    {
+        return std::wstring(m_UTF16.begin(), m_UTF16.end());
+    }
+    else
+    {
+        std::wstring output;
+        output.reserve(m_UTF16.size());
+
+        for (std::size_t index = 0; index < m_UTF16.size();)
+            output += static_cast<wchar_t>(DecodeUTF16(m_UTF16, index));
+
+        return output;
+    }
+}
+
+//---------------------------------------------------------------------------
+std::string TASWWideText::ToUTF8() const
+{
+    return m_UTF16.empty() ? WideToUTF8(m_Wide) : WideToUTF8(m_UTF16);
+}
+
+//---------------------------------------------------------------------------
+
+} // namespace ASWLog
diff --git a/ASWLog/ASWLog_Unicode.h b/ASWLog/ASWLog_Unicode.h
new file mode 100644
index 0000000..e64cb93
--- /dev/null
+++ b/ASWLog/ASWLog_Unicode.h
@@ -0,0 +1,219 @@
+/* **************************************************************************
+ASWLog_Unicode.h
+Author: Anthony S. West - ASW Software
+
+A logging library.
+
+Source for logging wide (UTF-16 and UTF-32) text: conversions to and from UTF-8, and the text wrappers the logging
+methods and the *Fmt arguments take.
+
+Requires C++ 20 or higher.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef ASWLog_UnicodeH
+#define ASWLog_UnicodeH
+//---------------------------------------------------------------------------
+#include <format>
+#include <string>
+#include <string_view>
+//---------------------------------------------------------------------------
+
+namespace ASWLog
+{
+
+//---------------------------------------------------------------------------
+
+/*
+    UTF8ToUTF16
+
+    'text' (UTF-8) as UTF-16. Each invalid UTF-8 sequence becomes U+FFFD. Throws std::bad_alloc if out of memory.
+*/
+[[nodiscard]] std::u16string UTF8ToUTF16(std::string_view text);
+
+/*
+    UTF8ToWide
+
+    'text' (UTF-8) as a wide string: UTF-16 where wchar_t has 16 bits (Windows, e.g. for the Windows API or a VCL
+    control), UTF-32 where it has 32 (Linux). Each invalid UTF-8 sequence becomes U+FFFD. Throws std::bad_alloc if out
+    of memory.
+*/
+[[nodiscard]] std::wstring UTF8ToWide(std::string_view text);
+
+/*
+    WideToUTF8
+
+    'text' as UTF-8: a wide string (UTF-16 where wchar_t has 16 bits, UTF-32 where it has 32), or UTF-16. Each
+    unpaired surrogate, or value that isn't a character (above U+10FFFF), becomes U+FFFD. Throws std::bad_alloc if out
+    of memory.
+*/
+[[nodiscard]] std::string WideToUTF8(std::wstring_view text);
+[[nodiscard]] std::string WideToUTF8(std::u16string_view text);
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWUTF8Text
+//
+// A view of UTF-8 text, made by UTF8(), that a *Fmt call with a wide format string formats as wide text (converted
+// only if the entry is formatted), e.g. log.LogInfoFmt(L"{} from {}", name, ASWLog::UTF8(host)). A narrow *Fmt call
+// formats it as it is.
+/////////////////////////////////////////////////////////////////////////////
+class TASWUTF8Text
+{
+private:
+    std::string_view m_Text;
+
+public:
+    constexpr explicit TASWUTF8Text(std::string_view text) noexcept
+        : m_Text(text)
+    {
+    }
+
+    [[nodiscard]] constexpr std::string_view GetText() const noexcept
+    {
+        return m_Text;
+    }
+};
+
+// Wraps UTF-8 text for a *Fmt call with a wide format string (see TASWUTF8Text). Holds a view of 'text', so the text
+// must outlive the call.
+[[nodiscard]] constexpr TASWUTF8Text UTF8(std::string_view text) noexcept
+{
+    return TASWUTF8Text(text);
+}
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+// TASWWideText
+//
+// A view of wide text: wchar_t (UTF-16 on Windows, UTF-32 on Linux) or char16_t (UTF-16). The logging methods take it
+// as a message, e.g. log.LogInfo(L"Opened") or, with C++Builder, log.LogInfo(caption.c_str()), and convert it to UTF-8
+// only if the entry is written. Wide() makes one for a *Fmt argument, which is converted only if the entry is
+// formatted. Made implicitly from a null-terminated string (null counts as empty), a string view or a string; it holds
+// a view, so the text must outlive the call.
+/////////////////////////////////////////////////////////////////////////////
+class TASWWideText
+{
+private:
+    // At most one of them holds the text
+    std::wstring_view m_Wide;
+    std::u16string_view m_UTF16;
+
+public:
+    constexpr TASWWideText(const wchar_t* text) noexcept
+        : m_Wide(text != nullptr ? std::wstring_view(text) : std::wstring_view())
+    {
+    }
+
+    constexpr TASWWideText(const char16_t* text) noexcept
+        : m_UTF16(text != nullptr ? std::u16string_view(text) : std::u16string_view())
+    {
+    }
+
+    constexpr TASWWideText(std::wstring_view text) noexcept
+        : m_Wide(text)
+    {
+    }
+
+    constexpr TASWWideText(std::u16string_view text) noexcept
+        : m_UTF16(text)
+    {
+    }
+
+    // A string converts to a view through a conversion of its own, and an implicit conversion can't chain two
+    TASWWideText(const std::wstring& text) noexcept
+        : m_Wide(text)
+    {
+    }
+
+    TASWWideText(const std::u16string& text) noexcept
+        : m_UTF16(text)
+    {
+    }
+
+    // The text as a wide string (converted from UTF-16 if it is char16_t text where wchar_t has 32 bits). Throws
+    // std::bad_alloc if out of memory.
+    [[nodiscard]] std::wstring ToWide() const;
+    // The text as UTF-8 (see WideToUTF8()). Throws std::bad_alloc if out of memory.
+    [[nodiscard]] std::string ToUTF8() const;
+};
+
+// Wraps wide text for a *Fmt call with a narrow format string, e.g. log.LogInfoFmt("Opened {}", ASWLog::Wide(name)):
+// converted to UTF-8 only if the entry is formatted (see TASWWideText)
+[[nodiscard]] constexpr TASWWideText Wide(TASWWideText text) noexcept
+{
+    return text;
+}
+
+} // namespace ASWLog
+
+//---------------------------------------------------------------------------
+
+// The formatters of the text wrappers, each the string view formatter of its character type, so a width or precision
+// applies too, e.g. "{:>20}" (counted in code units, e.g. UTF-8 bytes, not characters)
+template<>
+struct std::formatter<ASWLog::TASWUTF8Text, char> : std::formatter<std::string_view, char>
+{
+    template<typename TContext>
+    auto format(const ASWLog::TASWUTF8Text& text, TContext& context) const
+    {
+        return std::formatter<std::string_view, char>::format(text.GetText(), context);
+    }
+};
+
+template<>
+struct std::formatter<ASWLog::TASWUTF8Text, wchar_t> : std::formatter<std::wstring_view, wchar_t>
+{
+    template<typename TContext>
+    auto format(const ASWLog::TASWUTF8Text& text, TContext& context) const
+    {
+        const std::wstring wide = ASWLog::UTF8ToWide(text.GetText());
+
+        return std::formatter<std::wstring_view, wchar_t>::format(wide, context);
+    }
+};
+
+template<>
+struct std::formatter<ASWLog::TASWWideText, char> : std::formatter<std::string_view, char>
+{
+    template<typename TContext>
+    auto format(const ASWLog::TASWWideText& text, TContext& context) const
+    {
+        const std::string utf8 = text.ToUTF8();
+
+        return std::formatter<std::string_view, char>::format(utf8, context);
+    }
+};
+
+template<>
+struct std::formatter<ASWLog::TASWWideText, wchar_t> : std::formatter<std::wstring_view, wchar_t>
+{
+    template<typename TContext>
+    auto format(const ASWLog::TASWWideText& text, TContext& context) const
+    {
+        const std::wstring wide = text.ToWide();
+
+        return std::formatter<std::wstring_view, wchar_t>::format(wide, context);
+    }
+};
+
+//---------------------------------------------------------------------------
+#endif // ASWLog_UnicodeH
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index 28a6bb4..ca1688b 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -49,6 +49,8 @@ limitations under the License.
 #include <unistd.h>
 #endif
 //---------------------------------------------------------------------------
+#include "ASWLog_Unicode.h"
+//---------------------------------------------------------------------------
 
 namespace ASWLog
 {
@@ -955,7 +957,7 @@ std::optional<std::string> ReadEnvironmentVariable(std::string_view name) noexce
     try
     {
 #if defined(_WIN32)
-        const auto wideName = UTF8ToWideString(name);
+        const auto wideName = UTF8ToWide(name);
 
         // The size the value needs, including its terminating null (1 for an empty value), or 0 if it isn't set
         DWORD size = GetEnvironmentVariableW(wideName.c_str(), nullptr, 0);
@@ -972,7 +974,7 @@ std::optional<std::string> ReadEnvironmentVariable(std::string_view name) noexce
             if (length < size)
             {
                 value.resize(length);
-                return WideStringToUTF8(value);
+                return WideToUTF8(value);
             }
 
             size = length; // Another thread made it longer meanwhile: the size it needs now
@@ -1005,42 +1007,6 @@ std::string_view TrimSpaces(std::string_view text) noexcept
     return text.substr(start, end - start + 1);
 }
 
-#if defined(_WIN32)
-//---------------------------------------------------------------------------
-std::wstring UTF8ToWideString(std::string_view text)
-{
-    // MultiByteToWideChar takes an int length; a longer text is cut (no log line is that long)
-    const int size = text.size() > static_cast<std::size_t>(INT_MAX) ? INT_MAX : static_cast<int>(text.size());
-
-    // Without MB_ERR_INVALID_CHARS, invalid sequences become U+FFFD
-    const int wideSize = size > 0 ? MultiByteToWideChar(CP_UTF8, 0, text.data(), size, nullptr, 0) : 0;
-    if (wideSize <= 0)
-        return {};
-
-    std::wstring wide(static_cast<std::size_t>(wideSize), L'\0');
-    MultiByteToWideChar(CP_UTF8, 0, text.data(), size, wide.data(), wideSize);
-
-    return wide;
-}
-
-//---------------------------------------------------------------------------
-std::string WideStringToUTF8(std::wstring_view text)
-{
-    // WideCharToMultiByte takes an int length; a longer text is cut
-    const int size = text.size() > static_cast<std::size_t>(INT_MAX) ? INT_MAX : static_cast<int>(text.size());
-
-    // Without WC_ERR_INVALID_CHARS, unpaired surrogates become U+FFFD
-    const int utf8Size = size > 0 ? WideCharToMultiByte(CP_UTF8, 0, text.data(), size, nullptr, 0, nullptr, nullptr) : 0;
-    if (utf8Size <= 0)
-        return {};
-
-    std::string utf8(static_cast<std::size_t>(utf8Size), '\0');
-    WideCharToMultiByte(CP_UTF8, 0, text.data(), size, utf8.data(), utf8Size, nullptr, nullptr);
-
-    return utf8;
-}
-#endif
-
 } // namespace Detail
 
 //---------------------------------------------------------------------------
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index 100da84..99d1bf5 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -216,24 +216,6 @@ void CutToFit(std::string& text, std::size_t maxBytes);
 */
 [[nodiscard]] std::string_view TrimSpaces(std::string_view text) noexcept;
 
-#if defined(_WIN32)
-/*
-    UTF8ToWideString
-
-    'text' (UTF-8) as UTF-16, for the Windows API's wide functions. Each invalid UTF-8 sequence becomes U+FFFD. Throws
-    std::bad_alloc if the result can't be made.
-*/
-[[nodiscard]] std::wstring UTF8ToWideString(std::string_view text);
-
-/*
-    WideStringToUTF8
-
-    'text' (UTF-16, from the Windows API's wide functions) as UTF-8. Each unpaired surrogate becomes U+FFFD. Throws
-    std::bad_alloc if the result can't be made.
-*/
-[[nodiscard]] std::string WideStringToUTF8(std::wstring_view text);
-#endif
-
 } // namespace Detail
 
 namespace JSON
diff --git a/ASWLog/ASWLog_WindowsEventLog.cpp b/ASWLog/ASWLog_WindowsEventLog.cpp
index 3960315..17fb1ac 100644
--- a/ASWLog/ASWLog_WindowsEventLog.cpp
+++ b/ASWLog/ASWLog_WindowsEventLog.cpp
@@ -33,6 +33,7 @@ limitations under the License.
 #include <windows.h>
 #endif
 //---------------------------------------------------------------------------
+#include "ASWLog_Unicode.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
 
@@ -106,7 +107,7 @@ bool ToSourceKey(std::string_view source, std::wstring& key)
     if (name.empty() || name.find('\\') != std::string::npos)
         return false;
 
-    key = std::wstring(ApplicationLogKey) + Detail::UTF8ToWideString(name);
+    key = std::wstring(ApplicationLogKey) + UTF8ToWide(name);
 
     return true;
 }
@@ -183,7 +184,7 @@ bool TASWWindowsEventLog::OpenEventSourceFromConfigUnlocked()
 bool TASWWindowsEventLog::OpenEventSourceUnlocked(const std::string& source)
 {
 #if defined(_WIN32)
-    const HANDLE eventSource = RegisterEventSourceW(nullptr, Detail::UTF8ToWideString(source).c_str());
+    const HANDLE eventSource = RegisterEventSourceW(nullptr, UTF8ToWide(source).c_str());
 
     if (eventSource == nullptr)
     {
@@ -269,7 +270,7 @@ void TASWWindowsEventLog::ReportEventUnlocked(EventType type, std::uint16_t even
     if (m_EventSource == nullptr)
         return;
 
-    const std::wstring text = Detail::UTF8ToWideString(message);
+    const std::wstring text = UTF8ToWide(message);
     const wchar_t* strings[] = { text.c_str() };
 
     if (!ReportEventW(static_cast<HANDLE>(m_EventSource), static_cast<WORD>(type), 0, eventId, nullptr, 1, 0, strings, nullptr))
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8db953..d914505 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -226,6 +226,24 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   the values are read as UTF-8 (paths included). Breaking only for code that
   lists every `ErrorKind` (e.g. a `switch`) or relies on `ErrorKindCount`
   being 9.
+- Wide-string logging (new `ASWLog_Unicode.h`; add `ASWLog_Unicode.cpp` to
+  projects that list the ASWLog sources). Every logging method also takes a
+  message of wide text, `wchar_t` (e.g. `L"Opened"`, a `std::wstring`, or
+  C++Builder's `UnicodeString::c_str()`) or `char16_t` (e.g. `u"Opened"`),
+  converted to UTF-8 only if the entry is used, so a filtered call converts
+  nothing; field keys and texts stay UTF-8. Every `*Fmt` method also takes a
+  `wchar_t` format string, checked at compile time like a narrow one, e.g.
+  `log.LogInfoFmt(L"Opened {} ({} bytes)", fileName, size);` (wrap a
+  run-time one in `RuntimeFormat()`); its arguments are formatted as wide
+  text, so pass UTF-8 text as `ASWLog::UTF8(text)` (a narrow `std::string`
+  doesn't compile there). In a narrow `*Fmt` call, `ASWLog::Wide(text)`
+  formats wide text, converted only if the entry is formatted, e.g.
+  `log.LogInfoFmt("Opened {}", ASWLog::Wide(fileName));`. `WideToUTF8()`
+  (from `std::wstring_view` or `std::u16string_view`), `UTF8ToWide()` and
+  `UTF8ToUTF16()` convert on any platform (`wchar_t` text is UTF-16 on
+  Windows and UTF-32 on Linux); invalid input becomes U+FFFD. `std::format`
+  has no `char16_t` format strings, so `char16_t` text goes in as a message
+  or through `Wide()`.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6a49ac8..3443741 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -52,6 +52,8 @@ add_library(ASWLog STATIC
     ASWLog/ASWLog_TextLogBase.h
     ASWLog/ASWLog_Types.cpp
     ASWLog/ASWLog_Types.h
+    ASWLog/ASWLog_Unicode.cpp
+    ASWLog/ASWLog_Unicode.h
     ASWLog/ASWLog_Utils.cpp
     ASWLog/ASWLog_Utils.h
     ASWLog/ASWLog_Version.cpp
diff --git a/Deploy.bat b/Deploy.bat
index 3aa5480..9edb618 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -132,6 +132,10 @@ call :CopyFile "ASWLog\ASWLog_Types.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Types.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Types.h" "%TARGET_DIR%\ASWLog\ASWLog_Types.h"
 if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_Unicode.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Unicode.cpp"
+if errorlevel 1 exit /b 1
+call :CopyFile "ASWLog\ASWLog_Unicode.h" "%TARGET_DIR%\ASWLog\ASWLog_Unicode.h"
+if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Utils.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Utils.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Utils.h" "%TARGET_DIR%\ASWLog\ASWLog_Utils.h"
diff --git a/example/rad370/ASWLogExample.cbproj b/example/rad370/ASWLogExample.cbproj
index 1347e3a..db89dc1 100644
--- a/example/rad370/ASWLogExample.cbproj
+++ b/example/rad370/ASWLogExample.cbproj
@@ -203,6 +203,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Types.h</DependentOn>
             <BuildOrder>8</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_Unicode.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_Unicode.h</DependentOn>
+            <BuildOrder>22</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_Utils.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_Utils.h</DependentOn>
             <BuildOrder>9</BuildOrder>
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
index e0befb3..69ca1e4 100644
--- a/tests/cmake/CMakeLists.txt
+++ b/tests/cmake/CMakeLists.txt
@@ -48,6 +48,7 @@ add_executable(ASWLogTests
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_SyslogLog.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_TextLogBase.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Types.cpp"
+    "${ASWLOG_TESTS_DIR}/Test_ASWLog_Unicode.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Utils.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_Version.cpp"
     "${ASWLOG_TESTS_DIR}/Test_ASWLog_WindowsEventLog.cpp"
@@ -110,7 +111,7 @@ function(aswlog_check_format_string checkCase expectCompiles)
 endfunction()
 
 aswlog_check_format_string(0 TRUE)
-foreach(checkCase 1 2 3)
+foreach(checkCase 1 2 3 4 5 6)
     aswlog_check_format_string(${checkCase} FALSE)
 endforeach()
 message(STATUS "Format string compile-time checks: passed")
diff --git a/tests/compile_checks/Check_FormatString.cpp b/tests/compile_checks/Check_FormatString.cpp
index d856f6f..1eca521 100644
--- a/tests/compile_checks/Check_FormatString.cpp
+++ b/tests/compile_checks/Check_FormatString.cpp
@@ -40,6 +40,13 @@ void LogFormattedEntries(ASWLog::IASWLog& logger)
     logger.LogInfoFmt("{} {}", 1, "text");
     logger.LogFmt(ASWLog::Level::Warn, "{:d}", 2);
     logger.LogErrorFmt(ASWLog::RuntimeFormat(runtimeFormat), 3, 4);
+
+    // The same with wide format strings, and wide and UTF-8 text as arguments
+    const std::wstring wideRuntimeFormat = L"{} {}";
+    logger.LogInfoFmt(L"{} {} {}", 1, L"text", ASWLog::UTF8("utf8"));
+    logger.LogFmt(ASWLog::Level::Warn, L"{:d}", 2);
+    logger.LogErrorFmt(ASWLog::RuntimeFormat(wideRuntimeFormat), 3, 4);
+    logger.LogInfoFmt("{} {}", ASWLog::Wide(L"wide"), ASWLog::Wide(u"utf16"));
 #elif ASWLOG_CHECK_CASE == 1
     logger.LogInfoFmt("{} {}", 1); // Too few arguments
 #elif ASWLOG_CHECK_CASE == 2
@@ -47,6 +54,13 @@ void LogFormattedEntries(ASWLog::IASWLog& logger)
 #elif ASWLOG_CHECK_CASE == 3
     const std::string runtimeFormat = "{} {}";
     logger.LogErrorFmt(runtimeFormat, 3, 4); // A runtime format string without RuntimeFormat()
+#elif ASWLOG_CHECK_CASE == 4
+    logger.LogInfoFmt(L"{} {}", 1); // Too few arguments for a wide format string
+#elif ASWLOG_CHECK_CASE == 5
+    logger.LogInfoFmt(L"{}", std::string("text")); // Narrow text in a wide format string (use ASWLog::UTF8())
+#elif ASWLOG_CHECK_CASE == 6
+    const std::wstring runtimeFormat = L"{} {}";
+    logger.LogErrorFmt(runtimeFormat, 3, 4); // A wide runtime format string without RuntimeFormat()
 #else
 #error Unknown ASWLOG_CHECK_CASE
 #endif
diff --git a/tests/rad370/ASWLogTests.cbproj b/tests/rad370/ASWLogTests.cbproj
index 6fcaf99..8f84e31 100644
--- a/tests/rad370/ASWLogTests.cbproj
+++ b/tests/rad370/ASWLogTests.cbproj
@@ -218,6 +218,10 @@
             <DependentOn>..\..\ASWLog\ASWLog_Types.h</DependentOn>
             <BuildOrder>6</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\ASWLog\ASWLog_Unicode.cpp">
+            <DependentOn>..\..\ASWLog\ASWLog_Unicode.h</DependentOn>
+            <BuildOrder>55</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\ASWLog\ASWLog_Utils.cpp">
             <DependentOn>..\..\ASWLog\ASWLog_Utils.h</DependentOn>
             <BuildOrder>7</BuildOrder>
@@ -298,6 +302,10 @@
             <DependentOn>..\tests\Test_ASWLog_Types.h</DependentOn>
             <BuildOrder>24</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\tests\Test_ASWLog_Unicode.cpp">
+            <DependentOn>..\tests\Test_ASWLog_Unicode.h</DependentOn>
+            <BuildOrder>56</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\tests\Test_ASWLog_Utils.cpp">
             <DependentOn>..\tests\Test_ASWLog_Utils.h</DependentOn>
             <BuildOrder>25</BuildOrder>
diff --git a/tests/tests/Test_ASWLog_Unicode.cpp b/tests/tests/Test_ASWLog_Unicode.cpp
new file mode 100644
index 0000000..b8c3b39
--- /dev/null
+++ b/tests/tests/Test_ASWLog_Unicode.cpp
@@ -0,0 +1,752 @@
+/* **************************************************************************
+Test_ASWLog_Unicode.cpp
+Author: Anthony S. West - ASW Software
+
+See header for info.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+//---------------------------------------------------------------------------
+// Module header
+#include "Test_ASWLog_Unicode.h"
+//---------------------------------------------------------------------------
+#include <cstddef>
+#include <cstdint>
+#include <format>
+#include <initializer_list>
+#include <memory>
+#include <source_location>
+#include <string>
+#include <string_view>
+#include <vector>
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_Registry.h"
+//---------------------------------------------------------------------------
+#include "ASWLog_Interface.h"
+#include "ASWLog_MemoryLog.h"
+#include "ASWLog_Unicode.h"
+#include "ASWLog_Version.h"
+//---------------------------------------------------------------------------
+
+namespace
+{
+
+// A value whose wide formatting is counted in WideFormatCount, to check when the wide *Fmt methods format
+struct TWideCountedValue
+{
+};
+
+int WideFormatCount = 0;
+
+} // namespace
+
+template<>
+struct std::formatter<TWideCountedValue, wchar_t>
+{
+    constexpr std::wformat_parse_context::iterator parse(std::wformat_parse_context& context)
+    {
+        return context.begin();
+    }
+
+    std::wformat_context::iterator format(const TWideCountedValue& /*value*/, std::wformat_context& context) const
+    {
+        ++WideFormatCount;
+        return std::format_to(context.out(), L"counted");
+    }
+};
+
+namespace ASWUnitTests
+{
+
+namespace
+{
+
+// An entry as TCountingLog received it
+struct TReceivedEntry
+{
+    ASWLog::Level LogLevel = ASWLog::Level::Info;
+    std::string Message;
+    bool Raw = false;
+    bool Forced = false;
+    std::size_t FieldCount = 0;
+    std::uint_least32_t Line = 0;
+};
+
+// A minimal logger that counts the Write() calls (the entries a logging method passed on, used or not) and keeps a
+// copy of each entry it would use, filtering like TASWLogBase: enabled, not Level::Off, and the minimum level unless
+// forced
+class TCountingLog final : public ASWLog::IASWLog
+{
+private:
+    bool IsUsed(const ASWLog::TASWLogRecord& record) const noexcept
+    {
+        return Enabled && record.LogLevel != ASWLog::Level::Off && (record.Forced || record.LogLevel >= MinimumLevel);
+    }
+
+public:
+    ASWLog::Level MinimumLevel = ASWLog::Level::Info;
+    bool Enabled = true;
+    int WriteCount = 0;
+    std::vector<TReceivedEntry> Entries;
+
+    std::string_view GetVersionStr() const noexcept override
+    {
+        return ASWLog::Version;
+    }
+
+    std::string GetFullVersionStr() const override
+    {
+        return "TCountingLog";
+    }
+
+    std::shared_ptr<const ASWLog::TASWLogConfig> GetConfig() const noexcept override
+    {
+        return nullptr;
+    }
+
+    bool Initialize(const ASWLog::TASWLogConfig& /*config*/) noexcept override
+    {
+        return true;
+    }
+
+    bool Reconfigure(const ASWLog::TASWLogConfig& /*config*/) noexcept override
+    {
+        return true;
+    }
+
+    bool Open() noexcept override
+    {
+        return true;
+    }
+
+    bool Close() noexcept override
+    {
+        return true;
+    }
+
+    bool Flush() noexcept override
+    {
+        return true;
+    }
+
+    bool IsOpen() const noexcept override
+    {
+        return true;
+    }
+
+    void DumpBacktrace() noexcept override
+    {
+    }
+
+    bool IsEnabled() const noexcept override
+    {
+        return Enabled;
+    }
+
+    void SetEnabled(bool enabled) noexcept override
+    {
+        Enabled = enabled;
+    }
+
+    ASWLog::Level GetMinimumLevel() const noexcept override
+    {
+        return MinimumLevel;
+    }
+
+    void SetMinimumLevel(ASWLog::Level level) noexcept override
+    {
+        MinimumLevel = level;
+    }
+
+    bool ShouldLog(ASWLog::Level level) const noexcept override
+    {
+        ASWLog::TASWLogRecord record;
+        record.LogLevel = level;
+
+        return IsUsed(record);
+    }
+
+    bool ShouldLog(const ASWLog::TASWLogRecord& record) const noexcept override
+    {
+        return IsUsed(record);
+    }
+
+    void Write(const ASWLog::TASWLogRecord& record) noexcept override
+    {
+        ++WriteCount;
+        if (!IsUsed(record))
+            return;
+
+        TReceivedEntry entry;
+        entry.LogLevel = record.LogLevel;
+        entry.Message = std::string(record.Message);
+        entry.Raw = record.Raw;
+        entry.Forced = record.Forced;
+        entry.FieldCount = record.GetOwnFields().size();
+        entry.Line = record.Location.line();
+        Entries.push_back(entry);
+    }
+};
+
+// What a TReceivedEntry should hold
+struct TExpectedEntry
+{
+    ASWLog::Level LogLevel;
+    std::string Message;
+    bool Raw;
+    bool Forced;
+    std::size_t FieldCount;
+};
+
+// A code point and its UTF-8 bytes
+struct TCodePoint
+{
+    char32_t Value;
+    std::string UTF8;
+};
+
+// How the entries 'log' received differ from 'expected', in order: empty if they don't, else the first difference
+std::string DescribeEntryMismatch(const TCountingLog& log, const std::vector<TExpectedEntry>& expected)
+{
+    if (log.Entries.size() != expected.size())
+        return std::format("{} entries instead of {}", log.Entries.size(), expected.size());
+
+    for (std::size_t index = 0; index < expected.size(); ++index)
+    {
+        const auto& entry = log.Entries[index];
+        const auto& item = expected[index];
+        if (entry.LogLevel != item.LogLevel || entry.Message != item.Message || entry.Raw != item.Raw ||
+            entry.Forced != item.Forced || entry.FieldCount != item.FieldCount)
+        {
+            return std::format("entry {}: {} '{}' raw={} forced={} fields={} instead of {} '{}' raw={} forced={} fields={}", index,
+                ASWLog::Level_ToString(entry.LogLevel), entry.Message, entry.Raw, entry.Forced, entry.FieldCount,
+                ASWLog::Level_ToString(item.LogLevel), item.Message, item.Raw, item.Forced, item.FieldCount);
+        }
+    }
+
+    return {};
+}
+
+// A config with no startup or shutdown lines and only the level in each line, e.g. "[INFO]: message"
+ASWLog::TASWLogConfig MakeQuietConfig()
+{
+    ASWLog::TASWLogConfig config;
+    config.Line.ShowTimestamp = false;
+    config.Line.ShowProcessId = false;
+    config.Line.ShowThreadId = false;
+    config.Shutdown.WriteLine = false;
+    config.Startup.WriteApplicationInfo = false;
+    config.Startup.WriteDriveInfo = false;
+    config.Startup.WriteMemoryUsage = false;
+    config.Startup.WriteOSInfo = false;
+    config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteTimeInfo = false;
+    return config;
+}
+
+// The bytes of 'text' in hex, e.g. "E2 82", for a check's message
+std::string ToHex(std::string_view text)
+{
+    std::string hex;
+    for (const char character : text)
+        hex += std::format("{}{:02X}", hex.empty() ? "" : " ", static_cast<unsigned char>(character));
+
+    return hex;
+}
+
+// 'value' (a Unicode scalar value) as UTF-16, written out here rather than with the code the tests check
+std::u16string ToUTF16(char32_t value)
+{
+    if (value < 0x10000)
+        return std::u16string(1, static_cast<char16_t>(value));
+
+    const char32_t offset = value - 0x10000;
+
+    return std::u16string{ static_cast<char16_t>(0xD800 + (offset >> 10)), static_cast<char16_t>(0xDC00 + (offset & 0x3FF)) };
+}
+
+// 'value' as a wide string: UTF-16 where wchar_t has 16 bits, else the value itself
+std::wstring ToWideString(char32_t value)
+{
+    if constexpr (sizeof(wchar_t) == sizeof(char16_t))
+    {
+        const auto utf16 = ToUTF16(value);
+
+        return std::wstring(utf16.begin(), utf16.end());
+    }
+    else
+    {
+        return std::wstring(1, static_cast<wchar_t>(value));
+    }
+}
+
+} // namespace
+
+//---------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_Unicode
+///////////////////////////////////////////////////////////////////////////
+
+//---------------------------------------------------------------------------
+TTest_ASWLog_Unicode::TTest_ASWLog_Unicode()
+    : inherited("ASWLog_Unicode_Tests")
+{
+    RegisterTest(&TTest_ASWLog_Unicode::Test_Formatters_ConvertTheWrappedText, "Formatters_ConvertTheWrappedText");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_LogFmt_NarrowFormatTakesWideArguments, "LogFmt_NarrowFormatTakesWideArguments");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_LogFmt_WideFormatSkipsFilteredEntries, "LogFmt_WideFormatSkipsFilteredEntries");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_LogFmt_WideFormatWritesUTF8, "LogFmt_WideFormatWritesUTF8");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_LogWide_ConvertsOnlyEntriesThatAreUsed, "LogWide_ConvertsOnlyEntriesThatAreUsed");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_LogWide_EachMethodWritesUTF8, "LogWide_EachMethodWritesUTF8");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_LogWide_WritesThroughARealLogger, "LogWide_WritesThroughARealLogger");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_RoundTrip_KeepsEveryCharacter, "RoundTrip_KeepsEveryCharacter");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_UTF8ToUTF16_ReplacesInvalidSequences, "UTF8ToUTF16_ReplacesInvalidSequences");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_UTF8ToWide_FollowsTheWidthOfWchar, "UTF8ToWide_FollowsTheWidthOfWchar");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_WideText_TakesEachKindOfText, "WideText_TakesEachKindOfText");
+    RegisterTest(&TTest_ASWLog_Unicode::Test_WideToUTF8_ReplacesWhatIsNotACharacter, "WideToUTF8_ReplacesWhatIsNotACharacter");
+}
+//---------------------------------------------------------------------------
+TTest_ASWLog_Unicode::~TTest_ASWLog_Unicode()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::SetUp_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::SetUp_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::TearDown_Group()
+{
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::TearDown_Test(ITestCase& /*testCase*/)
+{
+}
+//---------------------------------------------------------------------------
+
+// /////// Begin tests after this line ///////////////////////
+
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_Formatters_ConvertTheWrappedText()
+{
+    // Arrange
+    const std::wstring wideEmoji = ToWideString(0x1F600);
+
+    // Act
+    const auto narrowWide = std::format("[{}]", ASWLog::Wide(L"a\x03BB"));
+    const auto narrowUTF16 = std::format("[{:>5}]", ASWLog::Wide(u"ab"));
+    const auto narrowUTF8 = std::format("[{:<4}]", ASWLog::UTF8("ab"));
+    const auto wideUTF8 = std::format(L"[{}]", ASWLog::UTF8("a\xCE\xBB"));
+    const auto wideUTF8Padded = std::format(L"[{:<4}]", ASWLog::UTF8("ab"));
+    const auto wideUTF16 = std::format(L"[{}]", ASWLog::Wide(u"\xD83D\xDE00"));
+    const auto wideWide = std::format(L"[{}]", ASWLog::Wide(L"x"));
+
+    // Assert
+    CheckEquals(std::string("[a\xCE\xBB]"), narrowWide, "Wide() should format wchar_t text as UTF-8");
+    CheckEquals(std::string("[   ab]"), narrowUTF16, "Wide() should format char16_t text, with a width");
+    CheckEquals(std::string("[ab  ]"), narrowUTF8, "UTF8() should format as it is in a narrow format");
+    CheckTrue(wideUTF8 == L"[a\x03BB]", "UTF8() should format UTF-8 as wide text in a wide format");
+    CheckTrue(wideUTF8Padded == L"[ab  ]", "UTF8() should take a width in a wide format");
+    CheckTrue(wideUTF16 == L"[" + wideEmoji + L"]", "Wide() should format char16_t text in a wide format");
+    CheckTrue(wideWide == L"[x]", "Wide() should format wchar_t text as it is in a wide format");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_LogFmt_NarrowFormatTakesWideArguments()
+{
+    // Arrange
+    TCountingLog log;
+
+    // Act
+    log.LogInfoFmt("{} and {}", ASWLog::Wide(L"\x03BB"), ASWLog::Wide(u"\xD83D\xDE00"));
+    log.LogWarnFmt("[{:>3}]", ASWLog::Wide(std::wstring(L"a")));
+
+    // Assert
+    CheckEmpty(DescribeEntryMismatch(log, {
+            { ASWLog::Level::Info, "\xCE\xBB and \xF0\x9F\x98\x80", false, false, 0 },
+            { ASWLog::Level::Warn, "[  a]", false, false, 0 },
+        }), "Each call should pass on one entry with its level, flags, fields and UTF-8 message");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_LogFmt_WideFormatSkipsFilteredEntries()
+{
+    // Arrange
+    TCountingLog log;
+    log.MinimumLevel = ASWLog::Level::Warn;
+    WideFormatCount = 0;
+
+    // Act
+    log.LogInfoFmt(L"{}", TWideCountedValue{});
+    log.LogFmt(ASWLog::Level::Debug, L"{}", TWideCountedValue{});
+    log.LogRawFmt(ASWLog::Level::Info, L"{}", TWideCountedValue{});
+    log.LogDebugFmt({ { "key", 1 } }, L"{}", TWideCountedValue{});
+    log.LogForceFmt(ASWLog::Level::Off, L"{}", TWideCountedValue{});
+    const int filteredCount = WideFormatCount;
+
+    log.LogWarnFmt(L"{}", TWideCountedValue{});
+    log.LogForceFmt(ASWLog::Level::Debug, L"{}", TWideCountedValue{});
+    log.LogForceRawFmt(ASWLog::Level::Trace, { { "key", 1 } }, L"{}", TWideCountedValue{});
+    const int writtenCount = WideFormatCount;
+
+    log.Enabled = false;
+    log.LogForceFmt(ASWLog::Level::Error, L"{}", TWideCountedValue{});
+    const int disabledCount = WideFormatCount;
+
+    // Assert
+    CheckEquals(0, filteredCount, "An entry that wouldn't be written should not be formatted");
+    CheckEquals(3, writtenCount, "An entry that is written should be formatted once");
+    CheckEquals(3, disabledCount, "A forced entry should not be formatted while the logger is disabled");
+    CheckEquals(3, log.Entries.size(), "Only the used entries should be kept");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_LogFmt_WideFormatWritesUTF8()
+{
+    // Arrange
+    const std::wstring runtimeFormat = L"{} {}";
+    TCountingLog log;
+    log.MinimumLevel = ASWLog::Level::Trace;
+
+    // Act: each method, arguments of each kind
+    const auto line = std::source_location::current().line();
+    log.LogFmt(ASWLog::Level::Warn, L"fmt {} {}", 1, L"\x03BB");
+    log.LogRawFmt(ASWLog::Level::Info, L"raw {}", ASWLog::UTF8("\xE6\x97\xA5"));
+    log.LogForceFmt(ASWLog::Level::Debug, L"force {}", ASWLog::Wide(u"\x03BB"));
+    log.LogForceRawFmt(ASWLog::Level::Trace, L"forceraw {:.1f}", 2.25);
+    log.LogTraceFmt(L"trace {}", 1);
+    log.LogDebugFmt(L"debug {}", 2);
+    log.LogInfoFmt(L"info {}", 3);
+    log.LogWarnFmt(L"warn {}", 4);
+    log.LogErrorFmt(L"error {}", 5);
+    log.LogCriticalFmt(L"critical {}", 6);
+
+    log.LogFmt(ASWLog::Level::Warn, { { "k", 1 } }, L"fmt {}", 1);
+    log.LogRawFmt(ASWLog::Level::Info, { { "k", 1 } }, L"raw {}", 2);
+    log.LogForceFmt(ASWLog::Level::Debug, { { "k", 1 } }, L"force {}", 3);
+    log.LogForceRawFmt(ASWLog::Level::Trace, { { "k", 1 } }, L"forceraw {}", 4);
+    log.LogTraceFmt({ { "k", 1 } }, L"trace {}", 5);
+    log.LogDebugFmt({ { "k", 1 } }, L"debug {}", 6);
+    log.LogInfoFmt({ { "k", 1 } }, L"info {}", 7);
+    log.LogWarnFmt({ { "k", 1 }, { "j", 2 } }, L"warn {}", 8);
+    log.LogErrorFmt({ { "k", 1 } }, L"error {}", 9);
+    log.LogCriticalFmt({ { "k", 1 } }, L"critical {}", 10);
+
+    log.LogInfoFmt(ASWLog::RuntimeFormat(runtimeFormat), 1, L"\x03BB");
+
+    // Assert
+    CheckEmpty(DescribeEntryMismatch(log, {
+            { ASWLog::Level::Warn, "fmt 1 \xCE\xBB", false, false, 0 },
+            { ASWLog::Level::Info, "raw \xE6\x97\xA5", true, false, 0 },
+            { ASWLog::Level::Debug, "force \xCE\xBB", false, true, 0 },
+            { ASWLog::Level::Trace, "forceraw 2.2", true, true, 0 },
+            { ASWLog::Level::Trace, "trace 1", false, false, 0 },
+            { ASWLog::Level::Debug, "debug 2", false, false, 0 },
+            { ASWLog::Level::Info, "info 3", false, false, 0 },
+            { ASWLog::Level::Warn, "warn 4", false, false, 0 },
+            { ASWLog::Level::Error, "error 5", false, false, 0 },
+            { ASWLog::Level::Critical, "critical 6", false, false, 0 },
+            { ASWLog::Level::Warn, "fmt 1", false, false, 1 },
+            { ASWLog::Level::Info, "raw 2", true, false, 1 },
+            { ASWLog::Level::Debug, "force 3", false, true, 1 },
+            { ASWLog::Level::Trace, "forceraw 4", true, true, 1 },
+            { ASWLog::Level::Trace, "trace 5", false, false, 1 },
+            { ASWLog::Level::Debug, "debug 6", false, false, 1 },
+            { ASWLog::Level::Info, "info 7", false, false, 1 },
+            { ASWLog::Level::Warn, "warn 8", false, false, 2 },
+            { ASWLog::Level::Error, "error 9", false, false, 1 },
+            { ASWLog::Level::Critical, "critical 10", false, false, 1 },
+            { ASWLog::Level::Info, "1 \xCE\xBB", false, false, 0 },
+        }), "Each call should pass on one entry with its level, flags, fields and UTF-8 message");
+
+    if (!log.Entries.empty())
+        CheckEquals(line + 1, log.Entries[0].Line, "The entry should have the caller's source line");
+
+    // Act: a runtime format string with too few arguments
+    log.LogInfoFmt(ASWLog::RuntimeFormat(runtimeFormat), 1);
+
+    // Assert
+    CheckEquals(22, log.Entries.size(), "The mismatched entry should still be written");
+    if (log.Entries.size() == 22)
+    {
+        CheckStartsWith(log.Entries[21].Message, std::string("[ASWLog format error: "), "A mismatched runtime format should be described");
+        CheckEndsWith(log.Entries[21].Message, std::string("] {} {}"), "The description should end with the format string");
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_LogWide_ConvertsOnlyEntriesThatAreUsed()
+{
+    // Arrange
+    TCountingLog log;
+    log.MinimumLevel = ASWLog::Level::Warn;
+
+    // Act: entries that wouldn't be used, then entries that would
+    log.LogInfo(L"info");
+    log.LogDebug(u"debug", { { "key", 1 } });
+    log.Log(ASWLog::Level::Info, L"info");
+    log.LogRaw(ASWLog::Level::Trace, u"trace");
+    log.LogForce(ASWLog::Level::Off, L"off");
+    const int filteredWriteCount = log.WriteCount;
+
+    log.LogWarn(L"warn");
+    log.LogForce(ASWLog::Level::Debug, u"forced");
+    const int usedWriteCount = log.WriteCount;
+
+    log.Enabled = false;
+    log.LogForceRaw(ASWLog::Level::Error, L"disabled");
+    const int disabledWriteCount = log.WriteCount;
+
+    // Assert
+    CheckEquals(0, filteredWriteCount, "An entry that wouldn't be used should not be passed on (nor converted)");
+    CheckEquals(2, usedWriteCount, "An entry that would be used should be passed on");
+    CheckEquals(2, disabledWriteCount, "A forced entry should not be passed on while the logger is disabled");
+    CheckEquals(2, log.Entries.size(), "The used entries should be kept");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_LogWide_EachMethodWritesUTF8()
+{
+    // Arrange
+    TCountingLog log;
+    log.MinimumLevel = ASWLog::Level::Trace;
+
+    // Act: each method, with wchar_t and char16_t text of each kind
+    const auto line = std::source_location::current().line();
+    log.Log(ASWLog::Level::Warn, L"log \x03BB");
+    log.LogRaw(ASWLog::Level::Info, u"raw \x03BB");
+    log.LogForce(ASWLog::Level::Debug, std::wstring(L"force"));
+    log.LogForceRaw(ASWLog::Level::Trace, std::u16string(u"forceraw"));
+    log.LogTrace(L"trace");
+    log.LogDebug(u"debug");
+    log.LogInfo(std::wstring_view(L"info"));
+    log.LogWarn(std::u16string_view(u"warn"));
+    log.LogError(std::wstring(L"error ") + ToWideString(0x1F600)); // A surrogate pair only where wchar_t has 16 bits
+    log.LogCritical(u"critical \xD83D\xDE00");
+
+    const auto fieldsLine = std::source_location::current().line();
+    log.Log(ASWLog::Level::Warn, L"log", { { "k", 1 } });
+    log.LogRaw(ASWLog::Level::Info, u"raw", { { "k", 1 } });
+    log.LogForce(ASWLog::Level::Debug, L"force", { { "k", 1 } });
+    log.LogForceRaw(ASWLog::Level::Trace, u"forceraw", { { "k", 1 } });
+    log.LogTrace(L"trace", { { "k", 1 } });
+    log.LogDebug(u"debug", { { "k", 1 } });
+    log.LogInfo(L"info", { { "k", 1 }, { "j", 2 } });
+    log.LogWarn(u"warn", { { "k", 1 } });
+    log.LogError(L"error", { { "k", 1 } });
+    log.LogCritical(u"critical", { { "k", 1 } });
+
+    // Assert
+    CheckEmpty(DescribeEntryMismatch(log, {
+            { ASWLog::Level::Warn, "log \xCE\xBB", false, false, 0 },
+            { ASWLog::Level::Info, "raw \xCE\xBB", true, false, 0 },
+            { ASWLog::Level::Debug, "force", false, true, 0 },
+            { ASWLog::Level::Trace, "forceraw", true, true, 0 },
+            { ASWLog::Level::Trace, "trace", false, false, 0 },
+            { ASWLog::Level::Debug, "debug", false, false, 0 },
+            { ASWLog::Level::Info, "info", false, false, 0 },
+            { ASWLog::Level::Warn, "warn", false, false, 0 },
+            { ASWLog::Level::Error, "error \xF0\x9F\x98\x80", false, false, 0 },
+            { ASWLog::Level::Critical, "critical \xF0\x9F\x98\x80", false, false, 0 },
+            { ASWLog::Level::Warn, "log", false, false, 1 },
+            { ASWLog::Level::Info, "raw", true, false, 1 },
+            { ASWLog::Level::Debug, "force", false, true, 1 },
+            { ASWLog::Level::Trace, "forceraw", true, true, 1 },
+            { ASWLog::Level::Trace, "trace", false, false, 1 },
+            { ASWLog::Level::Debug, "debug", false, false, 1 },
+            { ASWLog::Level::Info, "info", false, false, 2 },
+            { ASWLog::Level::Warn, "warn", false, false, 1 },
+            { ASWLog::Level::Error, "error", false, false, 1 },
+            { ASWLog::Level::Critical, "critical", false, false, 1 },
+        }), "Each call should pass on one entry with its level, flags, fields and UTF-8 message");
+
+    if (log.Entries.size() == 20)
+    {
+        CheckEquals(line + 1, log.Entries[0].Line, "An entry should have the caller's source line");
+        CheckEquals(fieldsLine + 1, log.Entries[10].Line, "An entry with fields should have the caller's source line");
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_LogWide_WritesThroughARealLogger()
+{
+    // Arrange
+    ASWLog::TASWMemoryLog log;
+    log.Initialize(MakeQuietConfig());
+
+    // Act
+    log.LogInfo(L"Opened \x03BB.txt");
+    log.LogWarnFmt(L"{} of {}", 3, ASWLog::UTF8("\xE6\x97\xA5"));
+    log.LogErrorFmt("{} failed", ASWLog::Wide(u"\x03BB"));
+    log.LogDebug(L"filtered");
+    const auto lines = log.GetLines();
+
+    // Assert
+    const std::vector<std::string> expected{ "[INFO]: Opened \xCE\xBB.txt", "[WARN]: 3 of \xE6\x97\xA5", "[ERROR]: \xCE\xBB failed" };
+    CheckEquals(expected.size(), lines.size(), "Each entry at or above Info should be written");
+    for (std::size_t index = 0; index < expected.size() && index < lines.size(); ++index)
+        CheckEquals(expected[index], lines[index], "The line should hold the message in UTF-8");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_RoundTrip_KeepsEveryCharacter()
+{
+    // Arrange: the first and last characters of each UTF-8 length, around the surrogates, and the largest
+    const std::vector<TCodePoint> codePoints{
+        { 0x0000, std::string(1, '\0') }, { 0x007F, "\x7F" }, { 0x0080, "\xC2\x80" }, { 0x07FF, "\xDF\xBF" },
+        { 0x0800, "\xE0\xA0\x80" }, { 0xD7FF, "\xED\x9F\xBF" }, { 0xE000, "\xEE\x80\x80" }, { 0xFFFD, "\xEF\xBF\xBD" },
+        { 0xFFFF, "\xEF\xBF\xBF" }, { 0x10000, "\xF0\x90\x80\x80" }, { 0x10FFFF, "\xF4\x8F\xBF\xBF" }
+    };
+
+    for (const auto& item : codePoints)
+    {
+        // Act
+        const std::u16string utf16 = ToUTF16(item.Value);
+        const std::wstring wide = ToWideString(item.Value);
+
+        const auto fromUTF16 = ASWLog::WideToUTF8(utf16);
+        const auto fromWide = ASWLog::WideToUTF8(wide);
+        const auto toUTF16 = ASWLog::UTF8ToUTF16(item.UTF8);
+        const auto toWide = ASWLog::UTF8ToWide(item.UTF8);
+
+        // Assert
+        const std::string what = ": " + ToHex(item.UTF8);
+        CheckEquals(item.UTF8, fromUTF16, "UTF-16 should become UTF-8" + what);
+        CheckEquals(item.UTF8, fromWide, "A wide string should become UTF-8" + what);
+        CheckTrue(toUTF16 == utf16, "UTF-8 should become UTF-16" + what);
+        CheckTrue(toWide == wide, "UTF-8 should become a wide string" + what);
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_UTF8ToUTF16_ReplacesInvalidSequences()
+{
+    // Arrange: valid text, then invalid sequences, each replaced by one U+FFFD per longest start of a valid sequence
+    struct TCase
+    {
+        std::string Text;
+        std::u16string Expected;
+    };
+
+    const std::vector<TCase> cases{
+        { "", u"" },
+        { "a\xCE\xBB" "\xE6\x97\xA5" "\xF0\x9F\x98\x80", u"a\x03BB\x65E5\xD83D\xDE00" },
+        { "x\xFFy", u"x\xFFFDy" },                                                       // Not a lead byte
+        { "\x80x", u"\xFFFDx" },                                                         // A lone continuation byte
+        { "\xC0\xAF", u"\xFFFD\xFFFD" },                                                 // Overlong 2-byte form
+        { "\xE0\x80\x80", u"\xFFFD\xFFFD\xFFFD" },                                       // Overlong 3-byte form
+        { "\xED\xA0\x80", u"\xFFFD\xFFFD\xFFFD" },                                       // A surrogate
+        { "\xF4\x90\x80\x80", u"\xFFFD\xFFFD\xFFFD\xFFFD" },                             // Above U+10FFFF
+        { "\xE6\x97" "x", u"\xFFFDx" },                                                  // Cut short by another character
+        { "a\xF0\x9F\x98", u"a\xFFFD" },                                                 // Cut short by the end
+    };
+
+    for (const auto& item : cases)
+    {
+        // Act
+        const auto result = ASWLog::UTF8ToUTF16(item.Text);
+
+        // Assert
+        CheckTrue(result == item.Expected, "UTF-8 should become UTF-16, invalid sequences U+FFFD: " + ToHex(item.Text));
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_UTF8ToWide_FollowsTheWidthOfWchar()
+{
+    // Arrange
+    const std::wstring expected = std::wstring(L"a") + ToWideString(0x1F600) + ToWideString(0xFFFD);
+
+    // Act
+    const auto result = ASWLog::UTF8ToWide("a\xF0\x9F\x98\x80\xFF");
+
+    // Assert
+    CheckTrue(result == expected, "UTF-8 should become UTF-16 where wchar_t has 16 bits, else UTF-32");
+    CheckEquals(sizeof(wchar_t) == sizeof(char16_t) ? 4 : 3, result.size(), "A character above U+FFFF should be two "
+        "wchar_t where it has 16 bits, else one");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_WideText_TakesEachKindOfText()
+{
+    // Arrange
+    const auto toUTF8 = [](ASWLog::TASWWideText text)
+        {
+            return text.ToUTF8();
+        };
+    const wchar_t* nullWide = nullptr;
+    const char16_t* nullUTF16 = nullptr;
+    const std::wstring wideString = L"wide \x03BB";
+    const std::u16string utf16String = u"utf16 \x03BB";
+
+    // Act & Assert: made implicitly from each kind of text
+    CheckEquals(std::string("a\xCE\xBB"), toUTF8(L"a\x03BB"), "A wchar_t literal should be taken");
+    CheckEquals(std::string("a\xCE\xBB"), toUTF8(u"a\x03BB"), "A char16_t literal should be taken");
+    CheckEquals(std::string("wide \xCE\xBB"), toUTF8(wideString), "A std::wstring should be taken");
+    CheckEquals(std::string("utf16 \xCE\xBB"), toUTF8(utf16String), "A std::u16string should be taken");
+    CheckEquals(std::string("wide"), toUTF8(std::wstring_view(wideString).substr(0, 4)), "A std::wstring_view should be taken");
+    CheckEquals(std::string("utf16"), toUTF8(std::u16string_view(utf16String).substr(0, 5)), "A std::u16string_view should be taken");
+    CheckEquals(std::string(), toUTF8(nullWide), "A null wchar_t pointer should be empty text");
+    CheckEquals(std::string(), toUTF8(nullUTF16), "A null char16_t pointer should be empty text");
+
+    // Act & Assert: as a wide string
+    CheckTrue(ASWLog::Wide(u"\xD83D\xDE00").ToWide() == ToWideString(0x1F600), "char16_t text should become a wide string");
+    CheckTrue(ASWLog::Wide(L"x\x03BB").ToWide() == L"x\x03BB", "wchar_t text should stay as it is");
+    const std::wstring unpaired = sizeof(wchar_t) == sizeof(char16_t) ? std::wstring(1, static_cast<wchar_t>(0xD83D)) :
+            ToWideString(0xFFFD);
+    CheckTrue(ASWLog::Wide(u"\xD83D").ToWide() == unpaired,
+        "An unpaired surrogate should stay where wchar_t has 16 bits, and become U+FFFD where it has 32");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Unicode::Test_WideToUTF8_ReplacesWhatIsNotACharacter()
+{
+    // Arrange: UTF-16 with unpaired surrogates
+    struct TCase
+    {
+        std::u16string Text;
+        std::string Expected;
+    };
+
+    const std::vector<TCase> cases{
+        { u"", "" },
+        { u"a\x03BB\xD83D\xDE00", "a\xCE\xBB\xF0\x9F\x98\x80" },
+        { u"x\xD83D", "x\xEF\xBF\xBD" },                                                  // A high surrogate at the end
+        { u"\xDE00y", "\xEF\xBF\xBDy" },                                                  // A lone low surrogate
+        { u"\xD83Dz", "\xEF\xBF\xBDz" },                                                  // A high surrogate, then no low one
+        { u"\xD83D\xD83D\xDE00", "\xEF\xBF\xBD\xF0\x9F\x98\x80" },                        // Two high surrogates, then a low one
+    };
+
+    // Act & Assert: wide text is UTF-16 too where wchar_t has 16 bits
+    for (const auto& item : cases)
+    {
+        CheckEquals(item.Expected, ASWLog::WideToUTF8(item.Text), "UTF-16 should become UTF-8: " + ToHex(item.Expected));
+        if constexpr (sizeof(wchar_t) == sizeof(char16_t))
+            CheckEquals(item.Expected, ASWLog::WideToUTF8(std::wstring(item.Text.begin(), item.Text.end())),
+                "16-bit wide text should become UTF-8 as UTF-16 does: " + ToHex(item.Expected));
+    }
+
+    // Arrange: values that aren't characters, which a 32-bit wchar_t holds one each
+    if constexpr (sizeof(wchar_t) != sizeof(char16_t))
+    {
+        const std::uint32_t surrogate = 0xD800;
+        const std::uint32_t tooLarge = 0x110000;
+        const std::wstring invalid{ static_cast<wchar_t>(surrogate), static_cast<wchar_t>(tooLarge), static_cast<wchar_t>(0x1F600) };
+
+        // Act & Assert
+        CheckEquals(std::string("\xEF\xBF\xBD\xEF\xBF\xBD\xF0\x9F\x98\x80"), ASWLog::WideToUTF8(invalid),
+            "A surrogate or a value above U+10FFFF should become U+FFFD");
+    }
+}
+//---------------------------------------------------------------------------
+
+} // namespace ASWUnitTests
+
+//---------------------------------------------------------------------------
+ASW_REGISTER_TEST_GROUP(ASWUnitTests::TTest_ASWLog_Unicode)
diff --git a/tests/tests/Test_ASWLog_Unicode.h b/tests/tests/Test_ASWLog_Unicode.h
new file mode 100644
index 0000000..d9f4703
--- /dev/null
+++ b/tests/tests/Test_ASWLog_Unicode.h
@@ -0,0 +1,67 @@
+/* **************************************************************************
+Test_ASWLog_Unicode.h
+Author: Anthony S. West - ASW Software
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#pragma once
+
+#ifndef Test_ASWLog_UnicodeH
+#define Test_ASWLog_UnicodeH
+//---------------------------------------------------------------------------
+#include "ASWUnitTests_TestBase.h"
+//---------------------------------------------------------------------------
+
+namespace ASWUnitTests
+{
+
+///////////////////////////////////////////////////////////////////////////
+// TTest_ASWLog_Unicode
+///////////////////////////////////////////////////////////////////////////
+class TTest_ASWLog_Unicode : public TTestGroupBase
+{
+private:
+    typedef TTestGroupBase inherited;
+
+private: // Test methods
+    void Test_Formatters_ConvertTheWrappedText();
+    void Test_LogFmt_NarrowFormatTakesWideArguments();
+    void Test_LogFmt_WideFormatSkipsFilteredEntries();
+    void Test_LogFmt_WideFormatWritesUTF8();
+    void Test_LogWide_ConvertsOnlyEntriesThatAreUsed();
+    void Test_LogWide_EachMethodWritesUTF8();
+    void Test_LogWide_WritesThroughARealLogger();
+    void Test_RoundTrip_KeepsEveryCharacter();
+    void Test_UTF8ToUTF16_ReplacesInvalidSequences();
+    void Test_UTF8ToWide_FollowsTheWidthOfWchar();
+    void Test_WideText_TakesEachKindOfText();
+    void Test_WideToUTF8_ReplacesWhatIsNotACharacter();
+
+public:
+    TTest_ASWLog_Unicode();
+    ~TTest_ASWLog_Unicode() override;
+
+    void SetUp_Group() override;
+    void SetUp_Test(ITestCase& testCase) override;
+    void TearDown_Group() override;
+    void TearDown_Test(ITestCase& testCase) override;
+};
+
+} // ASWUnitTests
+
+//---------------------------------------------------------------------------
+#endif // #ifndef Test_ASWLog_UnicodeH
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index ddbafae..b541ce5 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -134,8 +134,6 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_LocalTimeWithEachPrecision, "Time_WriteISO8601_LocalTimeWithEachPrecision");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision, "Time_WriteISO8601_UTCWithEachPrecision");
     RegisterTest(&TTest_ASWLog_Utils::Test_TrimSpaces_RemovesOuterSpacesAndTabs, "TrimSpaces_RemovesOuterSpacesAndTabs");
-    RegisterTest(&TTest_ASWLog_Utils::Test_UTF8ToWideString_ConvertsToUTF16, "UTF8ToWideString_ConvertsToUTF16");
-    RegisterTest(&TTest_ASWLog_Utils::Test_WideStringToUTF8_ConvertsFromUTF16, "WideStringToUTF8_ConvertsFromUTF16");
 }
 //---------------------------------------------------------------------------
 TTest_ASWLog_Utils::~TTest_ASWLog_Utils()
@@ -875,52 +873,6 @@ void TTest_ASWLog_Utils::Test_TrimSpaces_RemovesOuterSpacesAndTabs()
     CheckEquals(std::string("\nx\n"), std::string(ASWLog::Detail::TrimSpaces(" \nx\n ")), "Line breaks should stay");
 }
 //---------------------------------------------------------------------------
-void TTest_ASWLog_Utils::Test_UTF8ToWideString_ConvertsToUTF16()
-{
-#if defined(_WIN32)
-    // Arrange: ASCII, a 2-byte and a 4-byte character (a surrogate pair in UTF-16), and an invalid byte
-    struct TCase
-    {
-        std::string Text;
-        std::wstring Expected;
-    };
-
-    const std::vector<TCase> cases{
-        { "", L"" }, { "plain text\n", L"plain text\n" }, { "a\xCE\xBB" "b", L"a\x03BB" L"b" },
-        { "\xF0\x9F\x98\x80", L"\xD83D\xDE00" }, { "x\xFFy", L"x\xFFFDy" }
-    };
-
-    // Act & Assert
-    for (const auto& item : cases)
-        CheckTrue(ASWLog::Detail::UTF8ToWideString(item.Text) == item.Expected, "UTF-8 should become UTF-16: " + ToHex(item.Text));
-#else
-    Skip("UTF8ToWideString() exists only on Windows");
-#endif
-}
-//---------------------------------------------------------------------------
-void TTest_ASWLog_Utils::Test_WideStringToUTF8_ConvertsFromUTF16()
-{
-#if defined(_WIN32)
-    // Arrange: ASCII, a 2-byte and a 4-byte character (a surrogate pair in UTF-16), and an unpaired surrogate
-    struct TCase
-    {
-        std::wstring Text;
-        std::string Expected;
-    };
-
-    const std::vector<TCase> cases{
-        { L"", "" }, { L"plain text\n", "plain text\n" }, { L"a\x03BB" L"b", "a\xCE\xBB" "b" },
-        { L"\xD83D\xDE00", "\xF0\x9F\x98\x80" }, { L"x\xD800y", "x\xEF\xBF\xBDy" }
-    };
-
-    // Act & Assert
-    for (const auto& item : cases)
-        CheckEquals(item.Expected, ASWLog::Detail::WideStringToUTF8(item.Text), "UTF-16 should become UTF-8: " + ToHex(item.Expected));
-#else
-    Skip("WideStringToUTF8() exists only on Windows");
-#endif
-}
-//---------------------------------------------------------------------------
 
 } // namespace ASWUnitTests
 
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index 2a15eca..e177b70 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -66,8 +66,6 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_Time_WriteISO8601_LocalTimeWithEachPrecision();
     void Test_Time_WriteISO8601_UTCWithEachPrecision();
     void Test_TrimSpaces_RemovesOuterSpacesAndTabs();
-    void Test_UTF8ToWideString_ConvertsToUTF16();
-    void Test_WideStringToUTF8_ConvertsFromUTF16();
 
 public:
     TTest_ASWLog_Utils();
diff --git a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
index eb4767b..0320775 100644
--- a/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
+++ b/tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj
@@ -256,6 +256,10 @@
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Types.h</DependentOn>
             <BuildOrder>8</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\..\ASWLog\ASWLog_Unicode.cpp">
+            <DependentOn>..\..\..\..\ASWLog\ASWLog_Unicode.h</DependentOn>
+            <BuildOrder>66</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\..\ASWLog\ASWLog_Utils.cpp">
             <DependentOn>..\..\..\..\ASWLog\ASWLog_Utils.h</DependentOn>
             <BuildOrder>9</BuildOrder>
@@ -332,6 +336,10 @@
             <DependentOn>..\..\..\tests\Test_ASWLog_Types.h</DependentOn>
             <BuildOrder>32</BuildOrder>
         </CppCompile>
+        <CppCompile Include="..\..\..\tests\Test_ASWLog_Unicode.cpp">
+            <DependentOn>..\..\..\tests\Test_ASWLog_Unicode.h</DependentOn>
+            <BuildOrder>67</BuildOrder>
+        </CppCompile>
         <CppCompile Include="..\..\..\tests\Test_ASWLog_Utils.cpp">
             <DependentOn>..\..\..\tests\Test_ASWLog_Utils.h</DependentOn>
             <BuildOrder>33</BuildOrder>

From 660b155263b65b0018eb3b4e8fc6143f46670875 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 12:32:13 -0700
Subject: [PATCH 21/38] Bump version to 0.85.0-dev.3

---
 ASWLog/ASWLog_Version.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ASWLog/ASWLog_Version.h b/ASWLog/ASWLog_Version.h
index 690799f..cb65b4a 100644
--- a/ASWLog/ASWLog_Version.h
+++ b/ASWLog/ASWLog_Version.h
@@ -36,8 +36,8 @@ limitations under the License.
 #define ASWLOG_VERSION_MAJOR 0
 #define ASWLOG_VERSION_MINOR 85
 #define ASWLOG_VERSION_PATCH 0
-#define ASWLOG_VERSION_PRERELEASE "dev.2"
-#define ASWLOG_VERSION_STRING "0.85.0-dev.2"
+#define ASWLOG_VERSION_PRERELEASE "dev.3"
+#define ASWLOG_VERSION_STRING "0.85.0-dev.3"
 
 namespace ASWLog
 {

From d562284d877dbcba9b32afa687397db4531a5256 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 15:28:20 -0700
Subject: [PATCH 22/38] Build CI jobs in parallel and raise their timeouts

---
 .github/workflows/ci.yml | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c096c71..2f20a36 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,11 @@ jobs:
     # Safety net: a hung/looping test should fail the job quickly instead of burning the runner's full time
     # allotment. --test-timeout-seconds below covers a single hung test; this covers everything else. A sanitizer
     # build compiles and runs several times slower, so it gets longer.
-    timeout-minutes: ${{ matrix.sanitize && 10 || 5 }}
+    timeout-minutes: ${{ matrix.sanitize && 15 || 10 }}
+    env:
+      # cmake --build compiles up to 4 files at once (the runners have 4 cores). The Visual Studio generator only
+      # builds projects in parallel with it, so the MSVC job also compiles with -MP (its cxxflags).
+      CMAKE_BUILD_PARALLEL_LEVEL: 4
     strategy:
       fail-fast: false
       matrix:
@@ -33,6 +37,8 @@ jobs:
             generator: ""
             build_args: "--config Release"
             exe_path: build/bin/Release/ASWLogTests.exe
+            # cl takes -MP as well as /MP; Git Bash would turn "/MP" into a path when it starts CMake.
+            cxxflags: -MP
             sanitize: ""
           - name: Windows (MinGW)
             os: windows-latest
@@ -101,6 +107,10 @@ jobs:
             export CC="${{ matrix.cc }}"
             export CXX="${{ matrix.cxx }}"
           fi
+          # CMake adds CXXFLAGS to its default flags (setting CMAKE_CXX_FLAGS instead would replace them).
+          if [ -n "${{ matrix.cxxflags }}" ]; then
+            export CXXFLAGS="${{ matrix.cxxflags }}"
+          fi
           if [ -n "${{ matrix.generator }}" ]; then
             cmake -S tests/cmake -B build -G "${{ matrix.generator }}" -DCMAKE_BUILD_TYPE=Release \
               -DASWLOG_SANITIZE="${{ matrix.sanitize }}"

From 2efd1ebaa682823d6416642f39777df60bc6ed7f Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 15:59:11 -0700
Subject: [PATCH 23/38] Add CMake install and package config

---
 .github/workflows/ci.yml        | 36 +++++++++++++++++
 AGENTS.md                       |  5 ++-
 CHANGELOG.md                    | 10 +++++
 CMakeLists.txt                  | 69 ++++++++++++++++++++++++++++++--
 Deploy.bat                      |  3 ++
 README.md                       | 21 ++++++++++
 cmake/ASWLogConfig.cmake.in     | 14 +++++++
 tests/package/CMakeLists.txt    | 31 +++++++++++++++
 tests/package/Check_Package.cpp | 70 +++++++++++++++++++++++++++++++++
 9 files changed, 254 insertions(+), 5 deletions(-)
 create mode 100644 cmake/ASWLogConfig.cmake.in
 create mode 100644 tests/package/CMakeLists.txt
 create mode 100644 tests/package/Check_Package.cpp

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2f20a36..44a97dd 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,6 +39,9 @@ jobs:
             exe_path: build/bin/Release/ASWLogTests.exe
             # cl takes -MP as well as /MP; Git Bash would turn "/MP" into a path when it starts CMake.
             cxxflags: -MP
+            # A multi-config generator, so the package check builds and installs both into the same prefix (the Debug
+            # library is ASWLogd)
+            package_configs: Debug Release
             sanitize: ""
           - name: Windows (MinGW)
             os: windows-latest
@@ -166,3 +169,36 @@ jobs:
           name: test-results-${{ matrix.name }}
           path: junit-results.xml
           if-no-files-found: error
+
+      - name: Check the installed CMake package
+        # Builds and installs the library (the root project) to a temporary prefix, then builds tests/package against
+        # it with find_package() and runs it, which checks the install rules and the package files. Not in the
+        # sanitizer jobs: they build the same CMake files, and the package would pass their flags on to the consumer.
+        if: ${{ !matrix.sanitize }}
+        shell: bash
+        run: |
+          if [ -n "${{ matrix.cc }}" ]; then
+            export CC="${{ matrix.cc }}"
+            export CXX="${{ matrix.cxx }}"
+          fi
+          if [ -n "${{ matrix.cxxflags }}" ]; then
+            export CXXFLAGS="${{ matrix.cxxflags }}"
+          fi
+          generatorArgs=()
+          if [ -n "${{ matrix.generator }}" ]; then
+            generatorArgs=(-G "${{ matrix.generator }}")
+          fi
+          # Forward slashes, which CMake takes on Windows too (RUNNER_TEMP has backslashes there)
+          prefix="${RUNNER_TEMP//\\//}/aswlog"
+          configs="${{ matrix.package_configs || 'Release' }}"
+          cmake -S . -B build-install "${generatorArgs[@]}" -DCMAKE_BUILD_TYPE=Release
+          for config in $configs; do
+            cmake --build build-install --config "$config"
+            cmake --install build-install --config "$config" --prefix "$prefix"
+          done
+          cmake -S tests/package -B build-package "${generatorArgs[@]}" -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_PREFIX_PATH="$prefix"
+          for config in $configs; do
+            cmake --build build-package --config "$config"
+            ctest --test-dir build-package -C "$config" --output-on-failure
+          done
diff --git a/AGENTS.md b/AGENTS.md
index 09d22b0..6d21c27 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -9,9 +9,10 @@ These instructions apply to the entire repository unless a more specific `AGENTS
 ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux projects.
 
 - `ASWLog/` contains the framework implementation.
-- `tests/` contains the unit tests: test modules (`Test_ASWLog_<Unit>`, the tests of `ASWLog_<Unit>`) and shared test helpers (`UT_Helper_<Topic>`, e.g. `UT_Helper_DateTime`) in `tests/tests/`, their CMake project in `tests/cmake/`, their RAD Studio console project in `tests/rad370/`, and their RAD Studio VCL GUI runner project in `tests/vcl/gui/rad370/` (built from the submodule's `vcl/gui/src`). `tests/compile_checks/` holds "must not compile" checks, which `tests/cmake/CMakeLists.txt` runs with `try_compile` when configuring (a failed check stops the configure).
+- `tests/` contains the unit tests: test modules (`Test_ASWLog_<Unit>`, the tests of `ASWLog_<Unit>`) and shared test helpers (`UT_Helper_<Topic>`, e.g. `UT_Helper_DateTime`) in `tests/tests/`, their CMake project in `tests/cmake/`, their RAD Studio console project in `tests/rad370/`, and their RAD Studio VCL GUI runner project in `tests/vcl/gui/rad370/` (built from the submodule's `vcl/gui/src`). `tests/compile_checks/` holds "must not compile" checks, which `tests/cmake/CMakeLists.txt` runs with `try_compile` when configuring (a failed check stops the configure). `tests/package/` is a project that builds against an installed ASWLog with `find_package` (CI installs the library and runs it).
+- `CMakeLists.txt` (the root) defines the `ASWLog::ASWLog` library target and its install rules; `cmake/ASWLogConfig.cmake.in` is the template of the installed package file. The project version is read from `ASWLog/ASWLog_Version.h`.
 - `third_party/asw-unit-tests/` is the ASWUnitTests framework, a git submodule pinned to a release tag. Never edit files in it; test modules self-register with `ASW_REGISTER_TEST_GROUP`, so adding a test only touches `tests/` and its build files.
-- `.github/workflows/ci.yml` builds and runs the unit tests on Windows (MSVC, MinGW) and Linux (GCC, Clang), plus Linux Clang builds with ThreadSanitizer and with AddressSanitizer + UBSan (`ASWLOG_SANITIZE`).
+- `.github/workflows/ci.yml` builds and runs the unit tests on Windows (MSVC, MinGW) and Linux (GCC, Clang), plus Linux Clang builds with ThreadSanitizer and with AddressSanitizer + UBSan (`ASWLOG_SANITIZE`); the non-sanitizer jobs also check the installed CMake package (`tests/package/`).
 - `example/` contains example app that uses the logger.
 - `example/rad370/` contains the RAD Studio 13.1 project and Windows build scripts.
 - `README.md` contains repo details.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d914505..d171850 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -244,6 +244,16 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   Windows and UTF-32 on Linux); invalid input becomes U+FFFD. `std::format`
   has no `char16_t` format strings, so `char16_t` text goes in as a message
   or through `Wide()`.
+- CMake install and package files: `cmake --install` on the repository root
+  installs the static library, the headers (to `include/ASWLog`, so code
+  includes them as before, e.g. `#include "ASWLog_FileLog.h"`) and
+  `ASWLogConfig.cmake`, after which `find_package(ASWLog CONFIG)` gives the
+  `ASWLog::ASWLog` target. A requested version is met by any later release
+  with the same major version. The install rules are on by default only when
+  ASWLog is the top-level project (option `ASWLOG_INSTALL`). A Debug build of
+  the library is now named `ASWLogd` (e.g. `ASWLogd.lib`), so Debug and
+  Release can share an install prefix; nothing changes for code that links to
+  the `ASWLog::ASWLog` target.
 
 ### Changed
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3443741..0117f0b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,20 @@
 cmake_minimum_required(VERSION 3.20)
 
-project(ASWLog LANGUAGES CXX)
+# The version lives only in ASWLog/ASWLog_Version.h, so the project version comes from its ASWLOG_VERSION_MAJOR,
+# _MINOR, and _PATCH macros (a CMake version has no pre-release part).
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/ASWLog/ASWLog_Version.h" ASWLOG_VERSION_DEFINES
+    REGEX "^#define ASWLOG_VERSION_(MAJOR|MINOR|PATCH) ")
+foreach(versionPart MAJOR MINOR PATCH)
+    if(NOT ASWLOG_VERSION_DEFINES MATCHES "#define ASWLOG_VERSION_${versionPart} ([0-9]+)")
+        message(FATAL_ERROR "ASWLog/ASWLog_Version.h doesn't define ASWLOG_VERSION_${versionPart} as a number")
+    endif()
+    set(ASWLOG_VERSION_${versionPart} "${CMAKE_MATCH_1}")
+endforeach()
+
+project(ASWLog
+    VERSION ${ASWLOG_VERSION_MAJOR}.${ASWLOG_VERSION_MINOR}.${ASWLOG_VERSION_PATCH}
+    LANGUAGES CXX
+)
 
 # Building ASWLog itself (cmake -S .) rather than consuming it through add_subdirectory() or FetchContent.
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
@@ -11,6 +25,8 @@ endif()
 
 option(ASWLOG_BUILD_EXAMPLE "Build the ASWLog example (example/cmake)" OFF)
 option(ASWLOG_BUILD_TESTS "Build the ASWLog unit tests (tests/cmake; needs the asw-unit-tests submodule)" OFF)
+option(ASWLOG_INSTALL "Generate the install rules for the ASWLog library, headers, and CMake package files"
+    ${ASWLOG_IS_TOP_LEVEL})
 option(ASWLOG_WARNINGS "Compile the ASWLog sources with extra warnings" ${ASWLOG_IS_TOP_LEVEL})
 
 set(ASWLOG_SANITIZE "" CACHE STRING
@@ -64,9 +80,14 @@ add_library(ASWLog STATIC
 add_library(ASWLog::ASWLog ALIAS ASWLog)
 
 target_compile_features(ASWLog PUBLIC cxx_std_20)
-set_target_properties(ASWLog PROPERTIES CXX_EXTENSIONS OFF)
+# A Debug build is named ASWLogd, so Debug and Release can be installed to the same prefix.
+set_target_properties(ASWLog PROPERTIES
+    CXX_EXTENSIONS OFF
+    DEBUG_POSTFIX d
+)
 
-target_include_directories(ASWLog PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/ASWLog")
+# The installed target's include folder comes from install(TARGETS) below.
+target_include_directories(ASWLog PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ASWLog>")
 
 if(WIN32)
     # ASWLog_Utils.cpp uses the process memory APIs from psapi, and ASWLog_WindowsEventLog.cpp the Event Log and
@@ -108,6 +129,48 @@ if(ASWLOG_SANITIZE)
     target_link_options(ASWLog PUBLIC ${ASWLOG_SANITIZE_FLAGS})
 endif()
 
+# After `cmake --install`, find_package(ASWLog CONFIG) gives the ASWLog::ASWLog target. The headers are installed to
+# <prefix>/include/ASWLog, the installed target's include folder, so code includes them the same way as from the
+# sources (e.g. #include "ASWLog_FileLog.h").
+if(ASWLOG_INSTALL)
+    include(CMakePackageConfigHelpers)
+    include(GNUInstallDirs)
+
+    set(ASWLOG_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/ASWLog")
+
+    install(TARGETS ASWLog
+        EXPORT ASWLogTargets
+        ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+        INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/ASWLog"
+    )
+
+    # Every header is public.
+    get_target_property(ASWLOG_HEADERS ASWLog SOURCES)
+    list(FILTER ASWLOG_HEADERS INCLUDE REGEX "\\.h$")
+    install(FILES ${ASWLOG_HEADERS} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/ASWLog")
+
+    install(EXPORT ASWLogTargets
+        NAMESPACE ASWLog::
+        DESTINATION "${ASWLOG_INSTALL_CMAKEDIR}"
+    )
+
+    configure_package_config_file(cmake/ASWLogConfig.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/ASWLogConfig.cmake"
+        INSTALL_DESTINATION "${ASWLOG_INSTALL_CMAKEDIR}"
+    )
+
+    # As in Semantic Versioning, find_package(ASWLog 1.2) accepts version 1.2.0 or any later 1.x, but not 2.0.
+    write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/ASWLogConfigVersion.cmake"
+        VERSION "${ASWLog_VERSION}"
+        COMPATIBILITY SameMajorVersion
+    )
+
+    install(FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/ASWLogConfig.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/ASWLogConfigVersion.cmake"
+        DESTINATION "${ASWLOG_INSTALL_CMAKEDIR}"
+    )
+endif()
+
 if(ASWLOG_BUILD_EXAMPLE)
     add_subdirectory(example/cmake example)
 endif()
diff --git a/Deploy.bat b/Deploy.bat
index 9edb618..8657210 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -64,6 +64,9 @@ if errorlevel 1 exit /b 1
 call :CopyFile "README.md" "%TARGET_DIR%\README.md"
 if errorlevel 1 exit /b 1
 
+call :CopyFile "cmake\ASWLogConfig.cmake.in" "%TARGET_DIR%\cmake\ASWLogConfig.cmake.in"
+if errorlevel 1 exit /b 1
+
 call :CopyFile "ASWLog\ASWLog_Base.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Base.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Base.h" "%TARGET_DIR%\ASWLog\ASWLog_Base.h"
diff --git a/README.md b/README.md
index 9280917..3f4ce05 100644
--- a/README.md
+++ b/README.md
@@ -107,6 +107,27 @@ Either way, only the library is built. When ASWLog is the top-level project, `-D
 `-DASWLOG_BUILD_TESTS=ON` also build the example and the unit tests, and `ASWLOG_WARNINGS` (on by default only there)
 compiles the library with extra warnings.
 
+To use a prebuilt copy instead, build and install the library from the repository root (a Debug build is named
+`ASWLogd`, so Debug and Release can share one install prefix):
+
+```
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build --config Release
+cmake --install build --config Release --prefix C:/Libraries/ASWLog
+```
+
+and find it with `find_package` (pass the prefix in `CMAKE_PREFIX_PATH`):
+
+```
+find_package(ASWLog 1.0 CONFIG REQUIRED)
+target_link_libraries(MyApp PRIVATE ASWLog::ASWLog)
+```
+
+The headers are installed to `<prefix>/include/ASWLog`, the target's include folder, so code includes them as it does
+from the sources (`#include "ASWLog_FileLog.h"`). A requested version is met by any later release with the same major
+version. The install rules are on by default only when ASWLog is the top-level project; set `ASWLOG_INSTALL` to change
+that. `tests/package` is a small project that builds against an installed copy; CI runs it.
+
 The `example/cmake` folder contains a portable CMake project for building the example with CMake, JetBrains CLion,
 Visual Studio, Clang, or MinGW. From the repository root, configure and build it with:
 
diff --git a/cmake/ASWLogConfig.cmake.in b/cmake/ASWLogConfig.cmake.in
new file mode 100644
index 0000000..a8ce389
--- /dev/null
+++ b/cmake/ASWLogConfig.cmake.in
@@ -0,0 +1,14 @@
+# The CMake package file of an installed ASWLog (see the root CMakeLists.txt). After
+#     find_package(ASWLog CONFIG REQUIRED)
+# link to the ASWLog::ASWLog target.
+
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+# ASWLog::ASWLog links to Threads::Threads (TASWTextLogBase runs a std::thread).
+find_dependency(Threads)
+
+include("${CMAKE_CURRENT_LIST_DIR}/ASWLogTargets.cmake")
+
+check_required_components(ASWLog)
diff --git a/tests/package/CMakeLists.txt b/tests/package/CMakeLists.txt
new file mode 100644
index 0000000..2226d61
--- /dev/null
+++ b/tests/package/CMakeLists.txt
@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.20)
+
+project(ASWLogPackageCheck LANGUAGES CXX)
+
+# Checks the installed CMake package: builds Check_Package.cpp against an ASWLog installed with `cmake --install`
+# (point CMAKE_PREFIX_PATH at the install prefix), and `ctest` runs it. See the README's CMake section.
+find_package(ASWLog CONFIG REQUIRED)
+
+add_executable(ASWLogPackageCheck
+    "${CMAKE_CURRENT_SOURCE_DIR}/Check_Package.cpp"
+)
+
+target_link_libraries(ASWLogPackageCheck PRIVATE ASWLog::ASWLog)
+
+# The version the package's version file reported, which the check compares with the installed headers' version
+target_compile_definitions(ASWLogPackageCheck PRIVATE "ASWLOG_PACKAGE_VERSION=\"${ASWLog_VERSION}\"")
+
+if(MSVC)
+    target_compile_options(ASWLogPackageCheck PRIVATE /W4)
+else()
+    target_compile_options(ASWLogPackageCheck PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+
+if(MINGW)
+    # Statically link the MinGW runtime so the executable launches without MinGW's bin directory on PATH (e.g. on a
+    # CI runner).
+    target_link_options(ASWLogPackageCheck PRIVATE -static-libgcc -static-libstdc++ -static)
+endif()
+
+enable_testing()
+add_test(NAME ASWLogPackageCheck COMMAND ASWLogPackageCheck)
diff --git a/tests/package/Check_Package.cpp b/tests/package/Check_Package.cpp
new file mode 100644
index 0000000..b4614c9
--- /dev/null
+++ b/tests/package/Check_Package.cpp
@@ -0,0 +1,70 @@
+/* **************************************************************************
+Check_Package.cpp
+Author: Anthony S. West - ASW Software
+
+Check of the installed CMake package: tests/package/CMakeLists.txt builds this file against an ASWLog installed with
+`cmake --install` and found with find_package(), and running it returns 0 when the package works.
+
+Copyright 2026 ASW Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************** */
+
+#include <format>
+#include <iostream>
+#include <string>
+#include <string_view>
+//---------------------------------------------------------------------------
+#include "ASWLog_MemoryLog.h"
+#include "ASWLog_Version.h"
+//---------------------------------------------------------------------------
+
+#if !defined(ASWLOG_PACKAGE_VERSION)
+#error Define ASWLOG_PACKAGE_VERSION
+#endif
+
+int main()
+{
+    // The version find_package() found (from ASWLogConfigVersion.cmake) must be the installed headers' version
+    const std::string headerVersion = std::format("{}.{}.{}", ASWLog::VersionMajor, ASWLog::VersionMinor,
+        ASWLog::VersionPatch);
+    if (headerVersion != ASWLOG_PACKAGE_VERSION)
+    {
+        std::cerr << std::format("The package version {} isn't the headers' version {}\n", ASWLOG_PACKAGE_VERSION,
+            headerVersion);
+        return 1;
+    }
+
+    // The default configuration writes the startup lines, which use the system libraries the installed target links to
+    // (e.g. the memory usage)
+    constexpr std::string_view message = "Logged through the installed ASWLog package";
+    ASWLog::TASWMemoryLog log;
+    if (!log.Initialize(ASWLog::TASWLogConfig()))
+    {
+        std::cerr << "TASWMemoryLog::Initialize() failed\n";
+        return 1;
+    }
+
+    log.LogInfo(message);
+    const auto lines = log.GetLines();
+    if (lines.size() < 2 || !lines.back().ends_with(message))
+    {
+        std::cerr << "The memory logger should have kept the startup lines and the message\n";
+        return 1;
+    }
+
+    std::cout << "ASWLog " << ASWLog::Version << " package works: " << lines.size() << " lines logged\n";
+
+    return 0;
+}

From 9a3539d4bc0eb6d2166fa938aadb1ebc22400f6c Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 17:13:55 -0700
Subject: [PATCH 24/38] Update ASWLog description and add/update header
 descriptions

---
 AGENTS.md                       |  2 +-
 ASWLog/ASWLog_Base.h            |  6 +++++-
 ASWLog/ASWLog_CategoryLog.h     |  5 ++++-
 ASWLog/ASWLog_Config.h          |  6 ++++--
 ASWLog/ASWLog_ConsoleLog.h      |  5 ++++-
 ASWLog/ASWLog_CrashHandler.h    |  5 ++++-
 ASWLog/ASWLog_DebuggerLog.h     |  5 ++++-
 ASWLog/ASWLog_Fields.h          |  5 +++--
 ASWLog/ASWLog_FileLog.h         |  5 ++++-
 ASWLog/ASWLog_Formatter.h       |  6 ++++--
 ASWLog/ASWLog_Interface.h       |  5 ++++-
 ASWLog/ASWLog_Limiter.h         |  3 +++
 ASWLog/ASWLog_MemoryLog.h       |  5 ++++-
 ASWLog/ASWLog_MultiLog.h        |  5 ++++-
 ASWLog/ASWLog_NullLog.h         |  5 ++++-
 ASWLog/ASWLog_SyslogLog.h       |  5 ++++-
 ASWLog/ASWLog_TextLogBase.h     |  6 +++++-
 ASWLog/ASWLog_Types.h           |  5 +++--
 ASWLog/ASWLog_Unicode.h         |  5 +++--
 ASWLog/ASWLog_Utils.h           |  5 +++--
 ASWLog/ASWLog_Version.h         |  5 ++++-
 ASWLog/ASWLog_WindowsEventLog.h |  3 +++
 CMakeLists.txt                  |  2 ++
 README.md                       | 12 ++++++++++--
 24 files changed, 93 insertions(+), 28 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 6d21c27..2e0badf 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -6,7 +6,7 @@ These instructions apply to the entire repository unless a more specific `AGENTS
 
 ## Repository Overview
 
-ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux projects.
+ASWLog is a thread-safe, dependency-free C++20 logging library for Windows and Linux.
 
 - `ASWLog/` contains the framework implementation.
 - `tests/` contains the unit tests: test modules (`Test_ASWLog_<Unit>`, the tests of `ASWLog_<Unit>`) and shared test helpers (`UT_Helper_<Topic>`, e.g. `UT_Helper_DateTime`) in `tests/tests/`, their CMake project in `tests/cmake/`, their RAD Studio console project in `tests/rad370/`, and their RAD Studio VCL GUI runner project in `tests/vcl/gui/rad370/` (built from the submodule's `vcl/gui/src`). `tests/compile_checks/` holds "must not compile" checks, which `tests/cmake/CMakeLists.txt` runs with `try_compile` when configuring (a failed check stops the configure). `tests/package/` is a project that builds against an installed ASWLog with `find_package` (CI installs the library and runs it).
diff --git a/ASWLog/ASWLog_Base.h b/ASWLog/ASWLog_Base.h
index 685181a..1a6cf3f 100644
--- a/ASWLog/ASWLog_Base.h
+++ b/ASWLog/ASWLog_Base.h
@@ -2,7 +2,11 @@
 ASWLog_Base.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWLogBase, the base of the built-in loggers: the minimum level, the
+enabled flag, the backtrace, the config and the error reporting that every
+logger shares.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_CategoryLog.h b/ASWLog/ASWLog_CategoryLog.h
index f674423..58c20f8 100644
--- a/ASWLog/ASWLog_CategoryLog.h
+++ b/ASWLog/ASWLog_CategoryLog.h
@@ -2,7 +2,10 @@
 ASWLog_CategoryLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWCategoryLog, a named category of entries (e.g. "Net") with a minimum
+level of its own, which wraps another logger.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 8920a8b..f3b08bd 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -2,9 +2,11 @@
 ASWLog_Config.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
 
-Source for the ASWLog config options.
+TASWLogConfig, the settings of a logger, and the structs that group them
+(line layout, file, asynchronous writing, backtrace, startup and shutdown
+lines, and the settings of the system loggers).
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_ConsoleLog.h b/ASWLog/ASWLog_ConsoleLog.h
index 3ea3338..11e5fd1 100644
--- a/ASWLog/ASWLog_ConsoleLog.h
+++ b/ASWLog/ASWLog_ConsoleLog.h
@@ -2,7 +2,10 @@
 ASWLog_ConsoleLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWConsoleLog, a text logger that writes to the console (stdout, and
+stderr for warnings and errors), optionally in color.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_CrashHandler.h b/ASWLog/ASWLog_CrashHandler.h
index cc27630..b176262 100644
--- a/ASWLog/ASWLog_CrashHandler.h
+++ b/ASWLog/ASWLog_CrashHandler.h
@@ -2,7 +2,10 @@
 ASWLog_CrashHandler.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+Crash handlers that flush every text logger and write a "Crash: <reason>"
+line when the application crashes (InstallCrashHandlers(), HandleCrash()).
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_DebuggerLog.h b/ASWLog/ASWLog_DebuggerLog.h
index 5c5c6e6..64ab5aa 100644
--- a/ASWLog/ASWLog_DebuggerLog.h
+++ b/ASWLog/ASWLog_DebuggerLog.h
@@ -2,7 +2,10 @@
 ASWLog_DebuggerLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWDebuggerLog, a text logger that writes to the debugger's output on
+Windows (OutputDebugStringW); it writes nothing on other platforms.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Fields.h b/ASWLog/ASWLog_Fields.h
index ed8eb86..3bf8c20 100644
--- a/ASWLog/ASWLog_Fields.h
+++ b/ASWLog/ASWLog_Fields.h
@@ -2,9 +2,10 @@
 ASWLog_Fields.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
 
-Source for the ASWLog structured fields and scoped context.
+Structured fields: TASWLogField, a named value attached to one entry, and
+TASWLogScope, context that every entry logged on the thread carries.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_FileLog.h b/ASWLog/ASWLog_FileLog.h
index 80e08ba..4746515 100644
--- a/ASWLog/ASWLog_FileLog.h
+++ b/ASWLog/ASWLog_FileLog.h
@@ -2,7 +2,10 @@
 ASWLog_FileLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWFileLog, a text logger that writes to a file, with rotation by size and
+by day, backup cleanup, and flush and sync settings for crash durability.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Formatter.h b/ASWLog/ASWLog_Formatter.h
index ca9b42c..d5c9922 100644
--- a/ASWLog/ASWLog_Formatter.h
+++ b/ASWLog/ASWLog_Formatter.h
@@ -2,9 +2,11 @@
 ASWLog_Formatter.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
 
-Source for the ASWLog line formatters.
+IASWLogFormatter, which turns an entry into the line a text logger writes,
+and the built-in formatters: TASWTextFormatter (the default layout),
+TASWPatternFormatter and TASWJSONFormatter (JSON Lines).
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Interface.h b/ASWLog/ASWLog_Interface.h
index e3cc936..ee8a5d0 100644
--- a/ASWLog/ASWLog_Interface.h
+++ b/ASWLog/ASWLog_Interface.h
@@ -2,7 +2,10 @@
 ASWLog_Interface.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+IASWLog, the interface of every logger, with its logging methods: plain,
+formatted (*Fmt, checked at compile time), raw and forced.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Limiter.h b/ASWLog/ASWLog_Limiter.h
index 8bcf342..6639388 100644
--- a/ASWLog/ASWLog_Limiter.h
+++ b/ASWLog/ASWLog_Limiter.h
@@ -4,6 +4,9 @@ Author: Anthony S. West - ASW Software
 
 A logging library.
 
+Rate-limited logging for entries that can repeat often: the ASWLOG_ONCE,
+ASWLOG_EVERY_N and ASWLOG_EVERY_INTERVAL macros, and TASWLogLimiter.
+
 Requires C++ 20 or higher.
 
 Copyright 2026 ASW Software
diff --git a/ASWLog/ASWLog_MemoryLog.h b/ASWLog/ASWLog_MemoryLog.h
index b0bc05c..7918925 100644
--- a/ASWLog/ASWLog_MemoryLog.h
+++ b/ASWLog/ASWLog_MemoryLog.h
@@ -2,7 +2,10 @@
 ASWLog_MemoryLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWMemoryLog, a text logger that keeps its newest lines in memory, e.g.
+for an in-app log viewer, a crash report or tests.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_MultiLog.h b/ASWLog/ASWLog_MultiLog.h
index eaa6ebd..a169b0f 100644
--- a/ASWLog/ASWLog_MultiLog.h
+++ b/ASWLog/ASWLog_MultiLog.h
@@ -2,7 +2,10 @@
 ASWLog_MultiLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWMultiLog, which passes each entry on to several loggers, e.g. a file
+logger and a console logger.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_NullLog.h b/ASWLog/ASWLog_NullLog.h
index 52a654e..03fdb42 100644
--- a/ASWLog/ASWLog_NullLog.h
+++ b/ASWLog/ASWLog_NullLog.h
@@ -2,7 +2,10 @@
 ASWLog_NullLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWNullLog, a logger that writes nothing, e.g. to turn logging off without
+changing the code that logs, or to pass to code under test.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_SyslogLog.h b/ASWLog/ASWLog_SyslogLog.h
index 013dec8..a2e126f 100644
--- a/ASWLog/ASWLog_SyslogLog.h
+++ b/ASWLog/ASWLog_SyslogLog.h
@@ -2,7 +2,10 @@
 ASWLog_SyslogLog.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWSyslogLog, a text logger that sends its lines to the Linux system log
+(and the systemd journal); it writes nothing on Windows.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_TextLogBase.h b/ASWLog/ASWLog_TextLogBase.h
index 69c49b9..bbcc4cb 100644
--- a/ASWLog/ASWLog_TextLogBase.h
+++ b/ASWLog/ASWLog_TextLogBase.h
@@ -2,7 +2,11 @@
 ASWLog_TextLogBase.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
+
+TASWTextLogBase, the base of the loggers that write each entry as a line of
+text: locking, formatting, asynchronous writing and the startup lines. A
+custom text logger derives from it and implements only its output.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Types.h b/ASWLog/ASWLog_Types.h
index 95ea589..de6855f 100644
--- a/ASWLog/ASWLog_Types.h
+++ b/ASWLog/ASWLog_Types.h
@@ -2,9 +2,10 @@
 ASWLog_Types.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
 
-Source for the ASWLog types.
+The basic types: Level and the other enums, TASWLogRecord (an entry as a
+logger receives it) and TASWLogError (a logger's internal failure).
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Unicode.h b/ASWLog/ASWLog_Unicode.h
index e64cb93..0f68a10 100644
--- a/ASWLog/ASWLog_Unicode.h
+++ b/ASWLog/ASWLog_Unicode.h
@@ -4,8 +4,9 @@ Author: Anthony S. West - ASW Software
 
 A logging library.
 
-Source for logging wide (UTF-16 and UTF-32) text: conversions to and from UTF-8, and the text wrappers the logging
-methods and the *Fmt arguments take.
+Wide-string support: TASWWideText (wchar_t and char16_t messages), the
+Wide() and UTF8() wrappers for *Fmt arguments, and conversions between
+UTF-8 and UTF-16 or UTF-32.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index 99d1bf5..0613531 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -2,9 +2,10 @@
 ASWLog_Utils.h
 Author: Anthony S. West - ASW Software
 
-A light-weight logging tool.
+A logging library.
 
-Source for the ASWLog utility functions, etc.
+Helpers the loggers use, which an application can use too: log file names,
+process and system information, paths, time formatting and JSON escaping.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_Version.h b/ASWLog/ASWLog_Version.h
index cb65b4a..cb787d0 100644
--- a/ASWLog/ASWLog_Version.h
+++ b/ASWLog/ASWLog_Version.h
@@ -2,7 +2,10 @@
 ASWLog_Version.h
 Author: Anthony S. West - ASW Software
 
-Single source for the ASWLog semantic version (https://semver.org).
+A logging library.
+
+The ASWLog version (https://semver.org), as macros and constants: the only
+place where the version is set.
 
 Requires C++ 20 or higher.
 
diff --git a/ASWLog/ASWLog_WindowsEventLog.h b/ASWLog/ASWLog_WindowsEventLog.h
index 787075d..048fcfe 100644
--- a/ASWLog/ASWLog_WindowsEventLog.h
+++ b/ASWLog/ASWLog_WindowsEventLog.h
@@ -4,6 +4,9 @@ Author: Anthony S. West - ASW Software
 
 A logging library.
 
+TASWWindowsEventLog, a text logger that reports its lines to the Windows
+Event Log; it writes nothing on other platforms.
+
 Requires C++ 20 or higher.
 
 Copyright 2026 ASW Software
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0117f0b..e881b47 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,6 +13,8 @@ endforeach()
 
 project(ASWLog
     VERSION ${ASWLOG_VERSION_MAJOR}.${ASWLOG_VERSION_MINOR}.${ASWLOG_VERSION_PATCH}
+    DESCRIPTION "A thread-safe, dependency-free C++20 logging library for Windows and Linux"
+    HOMEPAGE_URL "https://github.com/ASWSoftware/asw-log"
     LANGUAGES CXX
 )
 
diff --git a/README.md b/README.md
index 3f4ce05..80f9265 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,14 @@
 # ASWLog - https://github.com/ASWSoftware/asw-log
 
-ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux projects.
+ASWLog is a thread-safe, dependency-free C++20 logging library for Windows and Linux.
+
+## Design
+
+ASWLog is a folder of standard C++ sources, or one CMake target, with no third-party code. Its defaults put crash
+durability first: a logging call is synchronous and every entry is flushed before the call returns, so the last
+entries before a crash are in the file. A call below the logger's level costs a few nanoseconds, so Debug and Trace
+calls can stay in release builds and be turned on at run time. The rest (asynchronous writing, backtrace, JSON and
+pattern formatters, crash handlers, and the other extras below) is opt-in.
 
 ## Features
 
@@ -67,7 +75,7 @@ ASWLog is a thread-safe light-weight C++ logging tool for Windows and Linux proj
 
 # Donations:
 
-If you find this tool helpful, donations are always appreciated:
+If you find this library helpful, donations are always appreciated:
 
 PayPal:
 donate@aswsoftware.com

From b693e6ced2a3f27fc75023ac4a34d92b7ee74c33 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 18:15:33 -0700
Subject: [PATCH 25/38] Update documentation in prep for 1.0

---
 AGENTS.md             |   4 +-
 Deploy.bat            |   7 ++
 README.md             | 126 ++++++++++++++++++++++++-
 docs/Configuration.md | 211 ++++++++++++++++++++++++++++++++++++++++++
 docs/CustomLoggers.md | 155 +++++++++++++++++++++++++++++++
 docs/Guarantees.md    |  93 +++++++++++++++++++
 example/src/main.cpp  |  36 +++++--
 7 files changed, 620 insertions(+), 12 deletions(-)
 create mode 100644 docs/Configuration.md
 create mode 100644 docs/CustomLoggers.md
 create mode 100644 docs/Guarantees.md

diff --git a/AGENTS.md b/AGENTS.md
index 2e0badf..670ad39 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -15,7 +15,8 @@ ASWLog is a thread-safe, dependency-free C++20 logging library for Windows and L
 - `.github/workflows/ci.yml` builds and runs the unit tests on Windows (MSVC, MinGW) and Linux (GCC, Clang), plus Linux Clang builds with ThreadSanitizer and with AddressSanitizer + UBSan (`ASWLOG_SANITIZE`); the non-sanitizer jobs also check the installed CMake package (`tests/package/`).
 - `example/` contains example app that uses the logger.
 - `example/rad370/` contains the RAD Studio 13.1 project and Windows build scripts.
-- `README.md` contains repo details.
+- `README.md` contains repo details: features, quick start, project setup, API overview, versions and tests.
+- `docs/` contains the reference documentation: `Configuration.md` (every `TASWLogConfig` setting, its default and which loggers use it, and the environment variables), `Guarantees.md` (thread safety, order, callback threads, lifetimes, crash durability) and `CustomLoggers.md` (custom formatters and loggers).
 - `CHANGELOG.md` records notable changes per release (see Changelog below).
 - `CONTRIBUTING.md` contains the guidelines for contributors (issues, branches, commit history, pull requests, and bug reports); it defers to this file for coding rules, so keep the two consistent.
 - `.uncrustify.cfg` and `.githooks/` define the repository formatting workflow.
@@ -54,6 +55,7 @@ Prefer standard C++ and portable library facilities. Avoid compiler-, IDE-, or o
 - Follow the surrounding naming, indentation, brace, include, and comment style. Avoid unrelated formatting changes.
 - Keep declarations and definitions consistent, and update all relevant project or build files when adding source files.
 - Add or update focused tests for behavior changes, including error and platform-specific cases where applicable.
+- Keep the documentation in step: a new or changed `TASWLogConfig` setting or environment key goes in `docs/Configuration.md`, a new logger in the README's API overview, and a change to threading, lifetimes or durability in `docs/Guarantees.md`. Add a new docs file to `Deploy.bat`.
 
 ## Building and Testing
 
diff --git a/Deploy.bat b/Deploy.bat
index 8657210..d85cd89 100644
--- a/Deploy.bat
+++ b/Deploy.bat
@@ -67,6 +67,13 @@ if errorlevel 1 exit /b 1
 call :CopyFile "cmake\ASWLogConfig.cmake.in" "%TARGET_DIR%\cmake\ASWLogConfig.cmake.in"
 if errorlevel 1 exit /b 1
 
+call :CopyFile "docs\Configuration.md" "%TARGET_DIR%\docs\Configuration.md"
+if errorlevel 1 exit /b 1
+call :CopyFile "docs\CustomLoggers.md" "%TARGET_DIR%\docs\CustomLoggers.md"
+if errorlevel 1 exit /b 1
+call :CopyFile "docs\Guarantees.md" "%TARGET_DIR%\docs\Guarantees.md"
+if errorlevel 1 exit /b 1
+
 call :CopyFile "ASWLog\ASWLog_Base.cpp" "%TARGET_DIR%\ASWLog\ASWLog_Base.cpp"
 if errorlevel 1 exit /b 1
 call :CopyFile "ASWLog\ASWLog_Base.h" "%TARGET_DIR%\ASWLog\ASWLog_Base.h"
diff --git a/README.md b/README.md
index 80f9265..766fd92 100644
--- a/README.md
+++ b/README.md
@@ -55,6 +55,10 @@ pattern formatters, crash handlers, and the other extras below) is opt-in.
 - Rate-limited logging for entries that can repeat often: `ASWLOG_ONCE`, `ASWLOG_EVERY_N` and `ASWLOG_EVERY_INTERVAL`
   (`ASWLog_Limiter.h`), e.g. `ASWLOG_EVERY_INTERVAL(log, std::chrono::seconds(5), ASWLog::Level::Warn, "Retrying {}",
   host);`, which counts the skipped entries in a `suppressed` field.
+- Settings from environment variables (`TASWLogConfig::ApplyEnvironment()`), e.g. `ASWLOG_LEVEL=Trace` to see
+  everything a deployed release build logs, without rebuilding it.
+- Wide-string messages: every logging method also takes `wchar_t` or `char16_t` text (e.g. `L"..."`, a
+  `std::wstring`, or C++Builder's `UnicodeString::c_str()`), converted to UTF-8 only if the entry is written.
 - A hook to drop or change entries before they are written (`TASWLogConfig::OnBeforeWrite`), e.g. to redact secrets
   or drop noisy entries by content, category or field.
 - Structured fields per entry, e.g. `logger.LogInfo("Order placed", {{"orderId", 17}})`, and scoped context that every
@@ -85,13 +89,64 @@ Bitcoin:
 
 # How to Use
 
-Add the source in `ASWLog` to your C++ project.
+## Quick start
 
-## CMake
+```cpp
+#include "ASWLog_CrashHandler.h"
+#include "ASWLog_FileLog.h"
+
+int main()
+{
+    ASWLog::TASWLogConfig config;
+    config.File.FilePath = "myapp.txt"; // In the "logs" folder
+    config.ApplyEnvironment(); // Optional: e.g. ASWLOG_LEVEL=Debug overrides the level
+
+    auto& log = ASWLog::TASWFileLog::GetInstance();
+    if (!log.Initialize(config))
+        return 1;
+
+    ASWLog::InstallCrashHandlers(); // Flushes the log and adds a "Crash:" line if the application crashes
+
+    log.LogInfo("Started");
+    log.LogWarnFmt("Disk {} is {}% full", "C:", 93); // Checked against its arguments at compile time
+    log.LogInfo("Order placed", { { "orderId", 17 }, { "total", 9.99 } });
+    log.LogDebug("Not written: below the minimum level (Info by default)");
+
+    return 0;
+}
+```
+
+writes `logs/myapp.txt`, after the startup lines (time, OS, drive, memory, application; see `TASWLogConfig::Startup`):
+
+```text
+[2026-10-11T00:24:25.089Z][INFO][P:6180][T:6648]: Started
+[2026-10-11T00:24:25.089Z][WARN][P:6180][T:6648]: Disk C: is 93% full
+[2026-10-11T00:24:25.089Z][INFO][P:6180][T:6648][orderId=17 total=9.99]: Order placed
+[2026-10-11T00:24:25.089Z][INFO][P:6180][T:6648]: Logger shutdown: 2026-10-11T00:24:25.089Z
+```
+
+The `example/src/main.cpp` app shows more: console, multi-log, categories, scopes, rate limiting and wide text.
+
+## Adding ASWLog to a project
+
+### Copied sources (any build system)
+
+Add every `.cpp` file in `ASWLog/` to the project, and the `ASWLog` folder to its include path, and compile as C++20.
+On Windows, link `psapi` and `advapi32` (RAD Studio links them by default); on Linux, the threads library
+(`-pthread`). `Deploy.bat <folder>` copies the library sources, the examples and the docs to a folder, e.g. for a
+release package.
+
+### RAD Studio
+
+Add the `ASWLog/*.cpp` files to the project (Project > Add to Project) and the `ASWLog` folder to the include path
+(Project > Options > Building > C++ Shared Options > Include path). RAD Studio 13.1 or later with the modern Clang
+toolchain (Win64x). `example/rad370/ASWLogExample.cbproj` is a working project to copy settings from.
+
+### CMake
 
 The repository's root `CMakeLists.txt` defines the static library target `ASWLog::ASWLog`. Linking to it adds the
-`ASWLog` include folder, C++20, and the system libraries the logger needs (the threads library, and `psapi` on
-Windows). Add it from a copy of the repository, such as a git submodule:
+`ASWLog` include folder, C++20, and the system libraries the logger needs (the threads library, and `psapi` and
+`advapi32` on Windows). Add it from a copy of the repository, such as a git submodule:
 
 ```
 add_subdirectory(third_party/asw-log)
@@ -146,6 +201,60 @@ cmake --build example/cmake/build --config Release
 
 The executable is written to `example/build/bin/Release/ASWLogExample.exe`, alongside RAD Studio output.
 
+## API overview
+
+**Loggers.** Each implements `ASWLog::IASWLog` (`ASWLog_Interface.h`), so code that logs can take an `IASWLog&` and
+not care where the entries go. Most have a `GetInstance()` singleton, and any of them can also be created as an
+ordinary object.
+
+| Class | Header | Writes to |
+|---|---|---|
+| `TASWFileLog` | `ASWLog_FileLog.h` | A file, with rotation, daily rolling and backup cleanup |
+| `TASWConsoleLog` | `ASWLog_ConsoleLog.h` | stdout, and stderr for Warn and above, in color on a terminal |
+| `TASWDebuggerLog` | `ASWLog_DebuggerLog.h` | The debugger's output (Windows) |
+| `TASWMemoryLog` | `ASWLog_MemoryLog.h` | Memory: the newest lines, e.g. for an in-app log viewer |
+| `TASWSyslogLog` | `ASWLog_SyslogLog.h` | The system log and the systemd journal (Linux) |
+| `TASWWindowsEventLog` | `ASWLog_WindowsEventLog.h` | The Windows Event Log (Windows) |
+| `TASWNullLog` | `ASWLog_NullLog.h` | Nothing |
+| `TASWMultiLog` | `ASWLog_MultiLog.h` | Several loggers at once, e.g. a file and the console |
+| `TASWCategoryLog` | `ASWLog_CategoryLog.h` | Another logger, marking the entries with a category (e.g. `[Net]`) that can have a level of its own |
+
+The loggers that write to only one platform build on both and write nothing on the other, so the same code can add
+them everywhere.
+
+**Logging.** On any logger:
+
+- `LogTrace()`, `LogDebug()`, `LogInfo()`, `LogWarn()`, `LogError()`, `LogCritical()`, and `Log(level, ...)`.
+- `LogInfoFmt("Opened {} in {} ms", name, ms)` and the other `*Fmt` methods: `std::format`, with the format string
+  checked against its arguments at compile time (wrap a format string built at run time in `ASWLog::RuntimeFormat()`).
+  An entry below the minimum level isn't formatted.
+- `LogRaw()` writes the message as it is, without the line layout; `LogForce()` and `LogForceRaw()` write it whatever
+  the minimum level.
+- Fields: `LogInfo("Order placed", {{"orderId", 17}})`, `LogInfoFmt({{"orderId", id}}, "Order {} placed", id)`, and
+  `ASWLog::TASWLogScope scope{{"requestId", id}};` for fields that every entry on the thread carries while it exists
+  (`ASWLog_Fields.h`).
+- Wide text: `LogInfo(L"...")`, `LogInfoFmt(L"... {}", ...)`, and `ASWLog::Wide(text)` / `ASWLog::UTF8(text)` for
+  arguments (`ASWLog_Unicode.h`).
+- The caller's function and source line are captured automatically (shown with `Line.ShowFunctionName` and
+  `Line.ShowSourceLine`).
+
+**Control.** `Initialize(config)`, `Reconfigure(config)`, `GetConfig()`, `SetMinimumLevel()`, `ShouldLog(level)` (to
+skip building an expensive message), `SetEnabled()`, `Flush()`, `Open()`, `Close()` and `DumpBacktrace()`; a file
+logger also has `RotateLogFiles()` and `DeleteOldLogs()`.
+
+**More.** `ASWLog::InstallCrashHandlers()` (`ASWLog_CrashHandler.h`), the `ASWLOG_ONCE`, `ASWLOG_EVERY_N` and
+`ASWLOG_EVERY_INTERVAL` macros (`ASWLog_Limiter.h`), `TASWLogConfig::ApplyEnvironment()`, the formatters
+(`ASWLog_Formatter.h`), and the version (`ASWLog_Version.h`). The header comments document every class and method.
+
+## Documentation
+
+- [docs/Configuration.md](docs/Configuration.md): every setting, its default, and which loggers use it, plus the
+  environment variables.
+- [docs/Guarantees.md](docs/Guarantees.md): thread safety, the order of entries, which thread runs each callback,
+  object lifetimes, and choosing settings for crash durability.
+- [docs/CustomLoggers.md](docs/CustomLoggers.md): writing a formatter or a logger of your own.
+- [CHANGELOG.md](CHANGELOG.md): the changes in each release.
+
 ## Versions
 
 ASWLog follows [Semantic Versioning](https://semver.org). Releases are tagged on `main` (e.g. `v1.1.0`). Between
@@ -161,6 +270,15 @@ and as constants in the `ASWLog` namespace:
 #endif
 ```
 
+### Upgrading from 0.x
+
+1.0.0 is the first release with a stable interface; the 0.x releases changed it as the design settled. The releases
+that can need changes in code that uses ASWLog are 0.43.0, 0.45.0, 0.65.0, 0.75.0 (only for a class that implements
+`IASWLog` directly) and 1.0.0. In [CHANGELOG.md](CHANGELOG.md), read the **Changed** and **Removed** sections, and
+the entries marked "Breaking", of every release after the one you use: each says what existing code must change.
+Projects that list the ASWLog sources must also add the files that new releases added (the CHANGELOG names them, e.g.
+`ASWLog_Unicode.cpp`).
+
 # Unit Tests
 
 Using the logger only requires the `ASWLog` source. The unit tests in `tests` additionally use the
diff --git a/docs/Configuration.md b/docs/Configuration.md
new file mode 100644
index 0000000..de42c30
--- /dev/null
+++ b/docs/Configuration.md
@@ -0,0 +1,211 @@
+# Configuration reference
+
+Every logger takes a `ASWLog::TASWLogConfig` (`ASWLog_Config.h`) in `Initialize()`. Its settings are grouped by
+concern, and a logger ignores the groups it doesn't use, so one config can be passed to several loggers (a multi-log
+passes its config on to the loggers it holds).
+
+```cpp
+ASWLog::TASWLogConfig config;
+config.InitialMinimumLevel = ASWLog::Level::Debug;
+config.File.FolderPath = "logs";
+config.File.FilePath = "myapp.txt";
+config.File.EnableRotation = true;
+config.ApplyEnvironment(); // Optional: lets ASWLOG_* environment variables override the settings (see below)
+
+auto& log = ASWLog::TASWFileLog::GetInstance();
+log.Initialize(config);
+```
+
+To change the settings of a running logger, copy its current config, change the copy, and pass it to `Reconfigure()`,
+which is safe while other threads log:
+
+```cpp
+auto config = *log.GetConfig();
+config.Line.ShowThreadId = false;
+log.Reconfigure(config);
+```
+
+`Reconfigure()` doesn't change the minimum level (use `SetMinimumLevel()`) and doesn't write the startup lines again.
+
+The header comments in `ASWLog_Config.h` have the full details of each setting; this page is the overview.
+
+## Which logger uses what
+
+| Group | Used by |
+|---|---|
+| `InitialMinimumLevel` | Every logger, including the multi-log (its own pre-filter) |
+| `Line`, `Startup`, `Shutdown`, `Async` | The text loggers: file, console, debugger, memory, syslog, Windows Event Log, and loggers derived from `TASWTextLogBase` |
+| `File` | `TASWFileLog` |
+| `Backtrace` | Every logger except the multi-log (each of its loggers keeps its own), the category logger and the null logger |
+| `Memory` | `TASWMemoryLog` |
+| `Syslog` | `TASWSyslogLog` |
+| `EventLog` | `TASWWindowsEventLog` |
+| `OnBeforeWrite` | Every logger; a multi-log calls its own once per entry, before passing the entry on |
+| `OnLogEntry`, `OnLogEntryMinimumLevel` | The text loggers |
+| `OnError`, `ErrorReportInterval` | Every logger; a multi-log passes them on, and each of its loggers reports its own failures |
+
+A category logger (`TASWCategoryLog`) and the null logger (`TASWNullLog`) take no config: the category's output
+belongs to the logger it wraps.
+
+## Top level
+
+| Setting | Default | What it does |
+|---|---|---|
+| `InitialMinimumLevel` | `Level::Info` | The minimum level `Initialize()` sets. Change it later with `SetMinimumLevel()`; this field doesn't follow it. |
+| `OnBeforeWrite` | empty | Called for each entry that passes the level checks, before it is written: return `false` to drop it, or change it with `entry.SetMessage()`, `SetField()` or `RemoveField()` (e.g. to redact secrets). Runs on the logging thread, before the logger's lock, possibly on several threads at once. |
+| `OnLogEntry` | empty | Called after an entry at or above `OnLogEntryMinimumLevel` was written, with the record and the line as written (e.g. for alerting). Runs outside the logger's lock; with `Async.Enabled`, on the logger's own thread. Exceptions are swallowed. |
+| `OnLogEntryMinimumLevel` | `Level::Error` | The level an entry needs for `OnLogEntry`. `Level::Off` = never. |
+| `OnError` | empty | Receives the logger's internal failures (a file that can't be opened, written, flushed or rotated, an invalid setting, ...) as a `TASWLogError`. Empty: each is written to stderr as one line. Runs outside the logger's lock. |
+| `ErrorReportInterval` | 1 minute | Each kind of failure is reported at most once per interval; the next report says how many were left out. 0 = report every failure. |
+
+## `Line`: the line layout (`TASWLineConfig`)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `Formatter` | empty | Formats each line. Empty: the built-in layout (`TASWTextFormatter`) from the `Show*` settings. Assign a `TASWPatternFormatter` (e.g. `"{time} {level:5} {message}"`), a `TASWJSONFormatter` (JSON Lines) or your own `IASWLogFormatter`. One formatter can be shared by several loggers. |
+| `Ending` | `LineEnding::LF` | Added after each formatted line (`LF` or `CRLF`); not after `LogRaw()` entries written as they are. |
+| `Multiline` | `MultilineMode::Preserve` | The line breaks inside an entry: written as they are (`Preserve`), each followed by `    \| ` (`Indent`), or as `\r` and `\n` (`Escape`). |
+| `TimestampZone` | `TimeZone::UTC` | `UTC` (e.g. `2026-09-28T21:02:44.342Z`) or `Local` (e.g. `2026-09-28T16:02:44.342-05:00`). Also sets when daily rolling starts a new file and the time in backup names. |
+| `TimestampPrecision` | `TimePrecision::Milliseconds` | `Milliseconds`, `Microseconds` or `Nanoseconds`. |
+| `ShowTimestamp` | `true` | The entry's time. |
+| `ShowLevel` | `true` | The entry's level, e.g. `[INFO]`. |
+| `ShowCategory` | `true` | The entry's category, e.g. `[Net]`, if it has one. |
+| `ShowProcessId` | `true` | The OS process id. |
+| `ShowThreadId` | `true` | The OS id of the thread that logged the entry. |
+| `ShowWorkingSet` | `false` | The process's memory use. |
+| `ShowPeakWorkingSet` | `false` | The process's peak memory use. |
+| `ShowFunctionName` | `false` | The function that logged the entry. |
+| `ShowSourceLine` | `false` | The source file and line that logged the entry. |
+| `ShowFields` | `true` | The entry's fields (its own and its scopes'), if it has any. |
+
+The `Show*` settings are read by the built-in layout and by `TASWJSONFormatter`; a pattern decides its own fields.
+
+## `Startup`: the lines `Initialize()` writes (`TASWStartupConfig`)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `Banner` | empty | A line written first, if set. |
+| `WriteApplicationInfo` | `true` | The executable's path and build target, e.g. `App: app_exe='C:\MyApp\MyApp.exe', app_target=Win64`. |
+| `WriteCommandLine` | `false` | The command line, added to the application line. |
+| `WriteDriveInfo` | `true` | The disk's total, free and used space. |
+| `WriteMemoryUsage` | `true` | The process's memory use (working set and peak). |
+| `WriteOSInfo` | `true` | The operating system, its version and the architecture. |
+| `WriteSystemMemoryInfo` | `true` | The system's total and available memory. |
+| `WriteTimeInfo` | `true` | The time in UTC, and in local time with its offset. |
+
+## `Shutdown`: the lines at shutdown and on a crash (`TASWShutdownConfig`)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `WriteLine` | `true` | "Logger shutdown: <time>" when the logger is finalized (its destructor, or process exit for a `GetInstance()` singleton), followed by the banner if set. |
+| `Banner` | empty | A line after the shutdown line. |
+| `WriteCrashLine` | `true` | A Critical "Crash: <reason>" line when the application crashes (with the crash handlers installed, see `ASWLog_CrashHandler.h`). The logger is flushed on a crash either way. |
+
+## `File`: the log file (`TASWFileConfig`)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `FolderPath` | `"logs"` | The folder of the log file, relative to the working directory unless absolute. |
+| `FilePath` | `"aswlog.txt"` | The log file's name, inside `FolderPath`, or a path of its own if absolute. `ResolvePath()` gives the result. |
+| `AutoOpenClosePerWrite` | `false` | Opens and closes the file for every entry. Required when several processes write to one log file. |
+| `Flush` | `FlushMode::EveryWrite` | When the file's buffer is flushed: after every entry (`EveryWrite`), after every entry that ends a line (`OnNewLine`, so a `LogRaw()` piece without a line break waits), only on `Flush()` or when the buffer is full (`Manual`), or every `FlushInterval` by the logger's own thread (`Periodic`). See [Guarantees.md](Guarantees.md#crash-durability). |
+| `FlushInterval` | 1000 ms | `FlushMode::Periodic`'s interval. 0 or less = every entry. |
+| `FlushImmediatelyAtLevel` | `Level::Error` | An entry at or above this level is flushed as soon as it is written, whatever `Flush` says. `Level::Off` = only `Flush` decides. |
+| `SyncToDiskAtLevel` | `Level::Off` | An entry at or above this level is also synced to disk (`FlushFileBuffers`/`fsync`), so it survives a power loss. A sync often takes milliseconds: keep it for rare entries. |
+| `OpenRetryCount` | 5 | How often opening the file is tried before an entry is dropped (e.g. while another program holds the file). |
+| `OpenRetryDelay` | 50 ms | The wait between those tries. |
+| `CircuitBreakerResetDelay` | 500 ms | After the file couldn't be reopened, entries are dropped without trying again until this long after the last failure. 0 = try on every entry. |
+| `EnableRotation` | `false` | Renames the file to a backup when it reaches `MaxFileSizeBytes`. |
+| `MaxFileSizeBytes` | 10 MB | The size that triggers a rotation. |
+| `RotationRetryDelay` | 500 ms | After a failed rotation, entries go on to the current file, and rotating isn't tried again until this long after the failure. |
+| `EnableDailyRolling` | `false` | Rotates the file at midnight (in `Line.TimestampZone`), and at `Initialize()` if the file was last written on an earlier day. |
+| `OnBackupCreated` | empty | Called for each backup a rotation makes, with its path and reason, e.g. to compress, upload or move it. Runs outside the logger's lock, on the thread whose call rotated the log. |
+| `RetentionMaxAge` | 0 (off) | After each rotation, deletes this log's backups older than this. |
+| `MaxBackupFiles` | 0 (unlimited) | After each rotation, keeps only the newest this many backups. |
+| `MaxBackupTotalBytes` | 0 (unlimited) | After each rotation, keeps only the newest backups that together take at most this many bytes. Set it above `MaxFileSizeBytes`. |
+
+Backups are named `<stem>.<reason>.<time>.bak`, e.g. `myapp.size.2026-10-10_143005_123.bak`, and a name is never
+reused. `TASWFileLog::DeleteOldLogs()` deletes other old files by a wildcard pattern.
+
+## `Async`: asynchronous writing (`TASWAsyncConfig`)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `Enabled` | `false` | The logging call formats the entry and queues it; the logger's own thread writes the queued entries in order. |
+| `QueueCapacity` | 8192 | How many entries can wait in the queue. |
+| `OverflowPolicy` | `AsyncOverflowPolicy::Block` | When the queue is full: the call waits for room (`Block`), or the entry is dropped and the drops are counted and reported (`DropNewest`). |
+| `WaitAtLevel` | `Level::Error` | The call of an entry at or above this level returns only once the entry (and every entry queued before it) is written and flushed, and such an entry is never dropped. `Level::Off` = no call waits. |
+
+## `Backtrace`: recent entries below the minimum level (`TASWBacktraceConfig`)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `Capacity` | 0 (off) | How many entries below the minimum level are kept in memory; the oldest goes when it is full. |
+| `LowestLevel` | `Level::Trace` | Entries below it aren't kept. |
+| `DumpAtLevel` | `Level::Error` | Writing an entry at or above this level writes the kept entries first. `Level::Off` = only `DumpBacktrace()` and a crash write them. |
+
+## `Memory`: what a memory logger keeps (`TASWMemoryConfig`)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `MaxLines` | 1000 | The most lines kept; the oldest go first. 0 = no limit. |
+| `MaxBytes` | 0 (no limit) | The most bytes of text kept. A line longer than this on its own is cut, ending with `" [cut]"`. |
+
+## `Syslog`: the syslog logger (`TASWSyslogConfig`, Linux)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `Ident` | empty | The name syslog shows, e.g. `myapp` in `myapp[1234]: ...`. Empty: the executable's file name. Process-wide: the syslog logger initialized last sets it. |
+| `Facility` | `SyslogFacility::User` | The facility each message is sent with. |
+
+## `EventLog`: the Windows Event Log logger (`TASWEventLogConfig`, Windows)
+
+| Setting | Default | What it does |
+|---|---|---|
+| `Source` | empty | The event source Event Viewer shows, in the Application log. Empty: the executable's file name without its extension. Register it once with `TASWWindowsEventLog::RegisterSource()` (needs administrator rights) for plain messages. |
+| `EventIds` | 1000 to 1005 | The event ID of each level's entries, indexed by level (Trace first). |
+
+## Settings from environment variables
+
+`config.ApplyEnvironment()` reads these variables, named with a prefix (`ASWLOG_` by default), and their values
+replace what the code set. Nothing reads the environment unless the application calls it. Call it after setting
+`OnError` and before `Initialize()`. A variable that isn't set or is empty changes nothing, and neither does an invalid
+value, which is reported to `OnError` (or stderr) as `ErrorKind::InvalidSetting`. Keys and values ignore case. Each
+logger can have its own prefix, e.g. `config.ApplyEnvironment("MYAPP_CONSOLE_")`. `config.ApplySetting(key, value)`
+sets one of the same settings, e.g. from a command line.
+
+| Variable | Values | Setting |
+|---|---|---|
+| `ASWLOG_LEVEL` | `Trace`, `Debug`, `Info`, `Warn`, `Error`, `Critical` or `Off` | `InitialMinimumLevel` |
+| `ASWLOG_CATEGORIES` | Category levels, e.g. `*=Info,Net=Debug,Net.Http=Trace` | `TASWCategoryLog::ApplyLevels()` (process-wide: use it under one prefix only) |
+| `ASWLOG_FOLDER` | A folder (UTF-8) | `File.FolderPath` |
+| `ASWLOG_FILE` | A file name or path (UTF-8) | `File.FilePath` |
+| `ASWLOG_FLUSH` | `EveryWrite`, `OnNewLine`, `Manual` or `Periodic` | `File.Flush` |
+| `ASWLOG_SYNC_AT_LEVEL` | A level | `File.SyncToDiskAtLevel` |
+| `ASWLOG_ASYNC` | `1`, `true`, `yes`, `on`; `0`, `false`, `no`, `off` | `Async.Enabled` |
+| `ASWLOG_BACKTRACE` | How many entries to keep; 0 = none | `Backtrace.Capacity` |
+| `ASWLOG_TIME_ZONE` | `UTC` or `Local` | `Line.TimestampZone` |
+| `ASWLOG_TIME_PRECISION` | `ms`, `us` or `ns` (or `Milliseconds`, ...) | `Line.TimestampPrecision` |
+| `ASWLOG_MULTILINE` | `Preserve`, `Indent` or `Escape` | `Line.Multiline` |
+| `ASWLOG_SHOW_FUNCTION` | As `ASWLOG_ASYNC` | `Line.ShowFunctionName` |
+| `ASWLOG_SHOW_SOURCE` | As `ASWLOG_ASYNC` | `Line.ShowSourceLine` |
+| `ASWLOG_FORMAT` | `Text` (the built-in layout) or `JSON` | `Line.Formatter` |
+| `ASWLOG_PATTERN` | A `TASWPatternFormatter` pattern, e.g. `{time} {message}` (applied after `FORMAT`) | `Line.Formatter` |
+
+For example, to see everything a deployed application logs, without rebuilding it:
+
+```text
+set ASWLOG_LEVEL=Trace
+myapp.exe
+```
+
+## Settings on the logger itself
+
+Some settings belong to the logger object rather than its config, and can be changed from any thread at any time:
+
+| Method | What it does |
+|---|---|
+| `SetMinimumLevel(level)` | The level an entry needs to be written (lock-free). |
+| `SetEnabled(enabled)` | Turns all writing off and on, forced entries included, keeping the output open (lock-free). |
+| `TASWConsoleLog::SetColorMode(mode)` | `ColorMode::Auto` (color only on a console or terminal that shows it, unless `NO_COLOR` is set), `Always` or `Never`. |
+| `TASWCategoryLog::SetMinimumLevel(level)` | A category's own level, which replaces the wrapped logger's for that category's entries. |
diff --git a/docs/CustomLoggers.md b/docs/CustomLoggers.md
new file mode 100644
index 0000000..3f4f02e
--- /dev/null
+++ b/docs/CustomLoggers.md
@@ -0,0 +1,155 @@
+# Custom formatters and loggers
+
+ASWLog can be extended without changing its sources, so a copy in a submodule or a vendored folder stays untouched:
+
+- To change how a line looks, write a **formatter**, and any text logger (file, console, ...) uses it.
+- To send lines somewhere new (a socket, a GUI control, another library), write a **text logger**: derive from
+  `TASWTextLogBase` and implement only the output. Levels, formatting, the startup and shutdown lines, asynchronous
+  writing, the backtrace, the hooks and crash handling come with it.
+- For output that isn't lines of text (e.g. passing entries on to another logging framework), derive from
+  `TASWLogBase` and implement `WriteRecord()`, as `TASWMultiLog` does.
+
+Before writing a formatter, check whether a pattern does the job, e.g.
+`std::make_shared<ASWLog::TASWPatternFormatter>("{time} {level:5} {[category] }{message}")` (see
+`ASWLog_Formatter.h` for the fields), or `TASWJSONFormatter` for JSON Lines.
+
+## A formatter
+
+A formatter derives from `IASWLogFormatter` (`ASWLog_Formatter.h`) and turns a `TASWLogRecord` into a line, without
+its line ending (the logger adds `Line.Ending`, and applies `Line.Multiline`):
+
+```cpp
+#include <format>
+#include <string>
+
+#include "ASWLog_Formatter.h"
+
+// Writes "WARN [Net] Retrying", or "INFO Started" for an entry without a category
+class TShortFormatter : public ASWLog::IASWLogFormatter
+{
+public:
+    std::string Format(const ASWLog::TASWLogRecord& record, const ASWLog::TASWLogConfig& /*config*/) const override
+    {
+        if (record.Category.empty())
+            return std::format("{} {}", ASWLog::Level_ToString(record.LogLevel), record.Message);
+
+        return std::format("{} [{}] {}", ASWLog::Level_ToString(record.LogLevel), record.Category, record.Message);
+    }
+};
+```
+
+Assign it to the config of the loggers that should use it:
+
+```cpp
+ASWLog::TASWLogConfig config;
+config.Line.Formatter = std::make_shared<TShortFormatter>();
+```
+
+- The record has the entry's time (`Timestamp`, UTC), `LogLevel`, `Message`, `Category`, source `Location`,
+  `ProcessId`, `ThreadId`, and its fields through `record.ForEachField([](const ASWLog::TASWLogField& field) {...})`.
+  `config` is the calling logger's config, e.g. for `Line.TimestampZone`.
+- Several loggers, and several threads, may call one formatter at once: keep `Format()` free of unguarded state.
+- `Format()` may throw (e.g. `std::bad_alloc`); the entry is then dropped and the logger goes on.
+- A `LogRaw()` entry is written as it is, without calling the formatter, unless `FormatsRawEntries()` returns `true`.
+
+## A text logger
+
+A text logger derives from `TASWTextLogBase` (`ASWLog_TextLogBase.h`). This one writes each line to a `std::ostream`,
+e.g. a stream that sends to a socket:
+
+```cpp
+#include <ostream>
+#include <string_view>
+
+#include "ASWLog_TextLogBase.h"
+
+// Writes each line to a std::ostream that outlives the logger
+class TStreamLog : public ASWLog::TASWTextLogBase
+{
+private:
+    std::ostream& m_Stream;
+
+protected: // TASWTextLogBase hooks, called with the logger's lock held
+    bool CloseUnlocked() override
+    {
+        m_IsOpen.store(false);
+        m_IsInitialized.store(false);
+
+        return true;
+    }
+
+    bool FlushUnlocked() override
+    {
+        m_Stream.flush();
+
+        return m_IsOpen.load() && m_Stream.good();
+    }
+
+    bool InitializeUnlocked() override
+    {
+        return OpenUnlocked();
+    }
+
+    bool OpenUnlocked() override
+    {
+        m_IsOpen.store(true);
+        m_IsInitialized.store(true);
+
+        return true;
+    }
+
+    // 'line' already ends with the line ending, unless it is a LogRaw() entry written as is
+    void WriteLineUnlocked(ASWLog::Level /*level*/, std::string_view line, bool /*endsLine*/) override
+    {
+        m_Stream << line;
+    }
+
+    std::string_view GetLoggerClassName() const noexcept override
+    {
+        return "TStreamLog";
+    }
+
+public:
+    explicit TStreamLog(std::ostream& stream) :
+        m_Stream(stream)
+    {
+    }
+
+    // Writes the shutdown line and closes the output while this class's hooks still exist
+    ~TStreamLog() override
+    {
+        Finalize();
+    }
+};
+```
+
+It is used like any other logger:
+
+```cpp
+TStreamLog log(stream);
+log.Initialize(config);
+log.LogWarnFmt("Retrying {}", host);
+```
+
+The rules for the hooks:
+
+- **Required:** `InitializeUnlocked()` (prepare and open the output), `OpenUnlocked()` (set `m_IsOpen` and
+  `m_IsInitialized`), `CloseUnlocked()` (clear them), `FlushUnlocked()` and `WriteLineUnlocked()`, plus
+  `GetLoggerClassName()` (used by `GetFullVersionStr()`).
+- **Call `Finalize()` in the destructor.** The base class can't call the hooks from its own destructor, since the
+  derived part is gone by then.
+- The hooks run with the logger's lock held, one entry at a time, so they need no locking of their own. They must not
+  log to the same logger. To call back into the application (which may log), queue the work with `DeferUnlocked()`;
+  to report a failure, call `ReportErrorUnlocked()`, which passes it to `OnError` after the lock is released.
+- An exception from a hook is caught: the entry is dropped and the failure reported, so logging still never throws.
+- **Optional hooks:** `PrepareWriteUnlocked()` (before each line, e.g. to rotate; return `false` to drop the line),
+  `ReconfigureUnlocked()` (apply a new config), `GetWorkerIntervalUnlocked()` and `OnWorkerWakeUnlocked()` (periodic
+  work on the logger's own thread, e.g. a timed flush), and, for crash handling, `FlushForCrashUnlocked()` and
+  `WriteCrashLineDirect()`. The crash hooks may run in a POSIX signal handler, so they must only do
+  async-signal-safe work (no allocation, no locks). Without them, a crash still flushes the logger through
+  `FlushUnlocked()` where it can.
+- A logger whose output exists only on some platforms can override `ShouldLog()` to return `false` elsewhere, so no
+  line is formatted there (see `TASWDebuggerLog`).
+
+The built-in loggers are examples to start from: `TASWDebuggerLog` and `TASWMemoryLog` are short, and
+`TASWFileLog` shows rotation, the worker thread and the crash hooks.
diff --git a/docs/Guarantees.md b/docs/Guarantees.md
new file mode 100644
index 0000000..c666694
--- /dev/null
+++ b/docs/Guarantees.md
@@ -0,0 +1,93 @@
+# Guarantees: thread safety, lifetime and crash durability
+
+What ASWLog promises about threads, object lifetimes and crashes, and how to choose the settings that trade speed for
+durability. The header comments have the details of each class and setting.
+
+## Logging never throws
+
+Every logging method is `noexcept`, and so is every other method of `IASWLog` except `GetFullVersionStr()`. A logger
+reports a failure by returning `false` (`Initialize()`, `Reconfigure()`, `Open()`, `Close()`, `Flush()`) or by
+dropping the entry, and reports its internal failures (e.g. a log file that can't be opened, written or rotated) to
+`TASWLogConfig::OnError`, or to stderr if that is empty. A `*Fmt` format string that fails at run time (only possible
+with `RuntimeFormat()`) writes the error in the entry's line instead of the message.
+
+## Thread safety
+
+- Every logger is thread-safe: any thread may log, flush, open, close or reconfigure it at any time.
+- `SetMinimumLevel()`, `SetEnabled()` and the level check of a logging call are lock-free.
+- `Reconfigure()` is safe while other threads log: the entries written after it returns use the new settings.
+  `GetConfig()` returns an immutable snapshot that stays valid after a later `Reconfigure()`.
+- A text logger writes one entry at a time under its own lock, so lines from different threads never mix.
+- A category logger is lock-free (making or destroying one takes a short process-wide lock). A multi-log guards its
+  list of loggers, and each of its loggers its own output.
+- Scoped fields (`TASWLogScope`) belong to the thread that made them; `TASWLogScope::Capture()` copies them for
+  another thread.
+- Several processes can share one log file with `File.AutoOpenClosePerWrite`, which opens and closes the file for
+  every entry (slower, but no process keeps it open).
+
+## Timestamps and order
+
+- An entry's time, process id and thread id are taken on the calling thread, during the call (after the level check,
+  so a filtered call doesn't read the clock). The time is when the event happened, not when the logger got to it.
+- One thread's entries are written in the order it logged them, also with asynchronous writing, which uses one queue.
+- Entries that two threads log at the same moment can be written in either order, so the times in a log can step back
+  slightly between lines of different threads.
+
+## Which thread runs a callback
+
+| Callback | Thread | Notes |
+|---|---|---|
+| `OnBeforeWrite` | The logging thread, before the logger takes its lock or queues the entry | Threads that log at once call it at once: keep it thread-safe and quick. It may log to another logger; an entry logged from inside it, on its thread, skips the hooks. If it throws, the entry is dropped and the exception reported. |
+| `OnLogEntry` | The logging thread after the entry is written, outside the lock; with `Async.Enabled`, the logger's own thread | Exceptions are swallowed. The record and line are only valid during the call. |
+| `OnError` | A thread that was using the logger (logging, `Flush()`, `Close()`, ...), outside the lock, or the logger's own thread (e.g. a failed periodic flush) | It may log, even to the failing logger: failures caused by the handler itself aren't reported again. Exceptions are swallowed. |
+| `File.OnBackupCreated` | The thread whose call rotated the log (a logging call, `Initialize()`, `Reconfigure()` or `RotateLogFiles()`; with `Async.Enabled`, the logger's own thread), outside the lock | That call waits for it: hand slow work (compressing, uploading) to another thread. Exceptions are swallowed. |
+
+## Lifetime
+
+- **Singletons.** `GetInstance()` (file, console, debugger, syslog, Windows Event Log and null loggers) returns an
+  instance that is never destroyed, so it can be used until the process ends, e.g. from another static object's
+  destructor or a thread still running at exit. At exit it is finalized (shutdown line, flush, close) in static
+  destruction order: a static object constructed after the first `GetInstance()` call can still log from its
+  destructor. In a Windows DLL or package that is unloaded before the process ends, `Close()` a logger that uses
+  `FlushMode::Periodic` (or `Async`) before unloading, since stopping its thread during the unload can deadlock.
+- **Instances.** A logger you create writes its shutdown line, writes the entries still queued, flushes and closes in
+  its destructor.
+- **Multi-log.** `TASWMultiLog` holds its loggers by reference and doesn't own them: each must outlive the multi-log,
+  or be removed from it (`RemoveLogger()`) first.
+- **Category.** The logger a `TASWCategoryLog` wraps must outlive the category, and must not be a multi-log that
+  holds the category.
+- **Scopes.** A `TASWLogScope` must end on the thread that made it, in the reverse order of making, as local variables
+  do. It copies its keys and texts, so they may be temporaries.
+- **Fields of a call.** The keys and texts of an entry's fields are only read during the call, so they may be
+  temporaries too; a logger that keeps the entry (asynchronous writing, the backtrace) copies them.
+
+## Crash durability
+
+ASWLog's first purpose is that the last entries before a crash are in the log. The defaults are the most durable;
+each faster option says what it gives up.
+
+| Setting | What reaches the file | Cost per entry |
+|---|---|---|
+| Default: synchronous, `File.Flush = EveryWrite` | Every entry is handed to the operating system before the call returns, so it survives an application crash. | One write and flush per entry. |
+| `File.Flush = Periodic`, `Manual` or `OnNewLine` | Entries wait in the logger's buffer until a flush. Entries at or above `File.FlushImmediatelyAtLevel` (Error by default) are still flushed at once. On a crash, the crash handlers (below) flush the buffer. | Less I/O; fewer, larger writes. |
+| `File.SyncToDiskAtLevel` (e.g. `Level::Error`) | Those entries are also synced to the disk, so they survive a power loss or a system crash. | A sync often takes milliseconds: use it for rare entries. |
+| `Async.Enabled` | The call only formats and queues the entry; the logger's thread writes it. Entries at or above `Async.WaitAtLevel` (Error by default) wait until they are written and flushed. On a crash, the handlers give the logger's thread up to `TASWCrashHandlerOptions::WaitTimeout` (1 s) to write the queue. | The call doesn't wait for the output. |
+| `Backtrace.Capacity` | The last N entries below the minimum level are kept in memory and written just before the next Error, on `DumpBacktrace()`, or on a crash. | About the cost of copying the message, for entries that would otherwise be filtered. |
+
+**Crash handlers.** `ASWLog::InstallCrashHandlers()` (in `ASWLog_CrashHandler.h`) catches `std::terminate()`,
+`abort()` and fatal faults (an access violation on Windows, SIGSEGV and the like on Linux). Every initialized text
+logger is then flushed, including its buffered and queued entries, and gets a Critical "Crash: <reason>" line, before
+the crash is passed on to the handler installed before (so error reports and core dumps still happen). This is best
+effort, since a crashed process may be in any state; the header lists what is and isn't handled. An application with
+its own crash reporter can call `ASWLog::HandleCrash()` from it instead.
+
+### Choosing settings
+
+| Goal | Settings |
+|---|---|
+| Find the cause of any crash (the default) | The defaults; call `InstallCrashHandlers()` early in `main()`. |
+| Less I/O for a busy log, errors still at once | `File.Flush = FlushMode::Periodic` (every `File.FlushInterval`, 1 s by default) and `InstallCrashHandlers()`. `File.FlushImmediatelyAtLevel` stays at Error. |
+| Errors that survive a power loss | `File.SyncToDiskAtLevel = Level::Error`. |
+| Logging calls that don't wait for a slow disk | `Async.Enabled = true`; `Async.WaitAtLevel` stays at Error, and `InstallCrashHandlers()`. |
+| The details leading up to an error, without logging them all | `InitialMinimumLevel = Level::Info` and `Backtrace.Capacity = 200` (or another count). |
+| Full verbosity in a deployed build, without rebuilding | `config.ApplyEnvironment()` before `Initialize()`, then run with `ASWLOG_LEVEL=Trace` (see [Configuration.md](Configuration.md#settings-from-environment-variables)). |
diff --git a/example/src/main.cpp b/example/src/main.cpp
index f752fd8..0070f5b 100644
--- a/example/src/main.cpp
+++ b/example/src/main.cpp
@@ -28,8 +28,10 @@ limitations under the License.
 #include "ASWLog_CategoryLog.h"
 #include "ASWLog_ConsoleLog.h"
 #include "ASWLog_CrashHandler.h"
+#include "ASWLog_DebuggerLog.h"
 #include "ASWLog_Fields.h"
 #include "ASWLog_FileLog.h"
+#include "ASWLog_Limiter.h"
 #include "ASWLog_MultiLog.h"
 #include "ASWLog_Utils.h"
 //---------------------------------------------------------------------------
@@ -103,6 +105,10 @@ int main(int argc, char* argv[])
     globalConfig.Line.ShowWorkingSet = true;
     globalConfig.Line.ShowPeakWorkingSet = true;
 
+    // Environment variables may replace these settings, e.g. ASWLOG_LEVEL=Info or ASWLOG_FORMAT=JSON, so a deployed
+    // build can log differently without being rebuilt. Unset variables change nothing.
+    globalConfig.ApplyEnvironment();
+
     // Get singleton instance - the logger supports singleton and non-singleton instances
     auto& globalLogger = ASWLog::TASWFileLog::GetInstance();
     if (!globalLogger.Initialize(globalConfig))
@@ -141,6 +147,14 @@ int main(int argc, char* argv[])
     // New C++ 'format' is supported
     globalLogger.LogCriticalFmt("CRITICAL EVENT BOUNDARY RECOVERY CODE: {:X}", 0xDEADBEEF);
 
+    // Rate limiting: of these 25 warnings in a loop, only the 1st, 11th and 21st are written
+    for (int attempt = 1; attempt <= 25; ++attempt)
+        ASWLOG_EVERY_N(globalLogger, 10, ASWLog::Level::Warn, "Retrying the connection, attempt {}", attempt);
+
+    // Wide text (e.g. C++Builder's UnicodeString::c_str()) is written as UTF-8, here "Wide text: cafe" with an e acute
+    globalLogger.LogInfo(L"Wide text: caf\x00E9");
+    globalLogger.LogInfoFmt("Opened {}", ASWLog::Wide(L"C:\\Data\\report.txt"));
+
     // Example of independent standalone/local logger instance
     std::cout << "Testing independent local stack instance execution...\n";
     ASWLog::TASWLogConfig localConfig;
@@ -191,19 +205,27 @@ int main(int argc, char* argv[])
         std::cout << "Console logger failed to initialize!\n";
     }
 
-    // Example of fanning a single call out to multiple sinks at once
-    std::cout << "Testing multi-sink logger (file + console fan-out)...\n";
+    // The debugger's output: on Windows, the RAD Studio Event Log, Visual Studio's Output window or DebugView; it writes
+    // nothing on other platforms
+    ASWLog::TASWDebuggerLog debuggerLogger;
+    if (!debuggerLogger.Initialize(consoleConfig))
+        std::cout << "Debugger logger failed to initialize!\n";
+
+    // Example of fanning a single call out to multiple sinks at once. The multi-log doesn't own its loggers, so they
+    // are declared before it and outlive it.
+    std::cout << "Testing multi-sink logger (file + console + debugger fan-out)...\n";
     ASWLog::TASWMultiLog multiLogger;
-    multiLogger.AddLogger(globalLogger);  // Reuses the already-initialized file singleton
-    multiLogger.AddLogger(consoleLogger); // Reuses the already-initialized console logger
+    multiLogger.AddLogger(globalLogger);   // Reuses the already-initialized file singleton
+    multiLogger.AddLogger(consoleLogger);  // Reuses the already-initialized console logger
+    multiLogger.AddLogger(debuggerLogger); // Reuses the already-initialized debugger logger
 
     // One call reaches every registered sink; each sink still applies its own level and formatting
-    multiLogger.LogInfo("This single call is written to both the log file and the console.");
+    multiLogger.LogInfo("This single call is written to the log file, the console and the debugger output.");
 
     // The composite's own level is an optional pre-filter, independent of each sink's own level
     multiLogger.SetMinimumLevel(ASWLog::Level::Error);
-    multiLogger.LogWarn("This Warn is suppressed by the composite gate before reaching either sink.");
-    multiLogger.LogError("This Error clears the composite gate and reaches both sinks.");
+    multiLogger.LogWarn("This Warn is suppressed by the composite gate before reaching any sink.");
+    multiLogger.LogError("This Error clears the composite gate and reaches every sink.");
 
     // Example of categories: each entry shows its category after the level, e.g. "[Db]", and a category with a level
     // of its own uses it instead of the wrapped logger's (Trace here)

From f094d20e501bdc7607edb42d1a8cf38fad57f902 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 19:00:32 -0700
Subject: [PATCH 26/38] Write the ASWLog version in the startup lines

---
 ASWLog/ASWLog_Config.h                      |  3 +++
 ASWLog/ASWLog_TextLogBase.cpp               | 10 ++++++++
 ASWLog/ASWLog_TextLogBase.h                 |  1 +
 CHANGELOG.md                                |  5 ++++
 README.md                                   |  6 +++--
 docs/Configuration.md                       |  1 +
 tests/tests/Test_ASWLog_CategoryLog.cpp     |  1 +
 tests/tests/Test_ASWLog_Config.cpp          |  2 ++
 tests/tests/Test_ASWLog_ConsoleLog.cpp      |  1 +
 tests/tests/Test_ASWLog_CrashHandler.cpp    |  1 +
 tests/tests/Test_ASWLog_DebuggerLog.cpp     |  1 +
 tests/tests/Test_ASWLog_Fields.cpp          |  1 +
 tests/tests/Test_ASWLog_FileLog.cpp         |  2 ++
 tests/tests/Test_ASWLog_Formatter.cpp       |  1 +
 tests/tests/Test_ASWLog_Limiter.cpp         |  1 +
 tests/tests/Test_ASWLog_MemoryLog.cpp       |  1 +
 tests/tests/Test_ASWLog_MultiLog.cpp        |  1 +
 tests/tests/Test_ASWLog_SyslogLog.cpp       |  1 +
 tests/tests/Test_ASWLog_TextLogBase.cpp     | 28 +++++++++++++++++++++
 tests/tests/Test_ASWLog_TextLogBase.h       |  1 +
 tests/tests/Test_ASWLog_Unicode.cpp         |  1 +
 tests/tests/Test_ASWLog_WindowsEventLog.cpp |  1 +
 22 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index f3b08bd..ffdb7d5 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -305,6 +305,9 @@ struct TASWStartupConfig
     bool WriteApplicationInfo  = true;
     bool WriteCommandLine      = false; // Added to the application info line
     bool WriteDriveInfo        = true;
+    // "ASWLog: version=<ASWLOG_VERSION_STRING>, logger=<class>", the first line after the banner, so a log says which
+    // ASWLog wrote it
+    bool WriteLoggerVersion    = true;
     bool WriteMemoryUsage      = true;
     bool WriteOSInfo           = true;
     bool WriteSystemMemoryInfo = true;
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index 1e23e66..dbdeef4 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -31,6 +31,7 @@ limitations under the License.
 //---------------------------------------------------------------------------
 #include "ASWLog_CrashHandler.h"
 #include "ASWLog_Utils.h"
+#include "ASWLog_Version.h"
 //---------------------------------------------------------------------------
 
 namespace ASWLog
@@ -977,6 +978,9 @@ void TASWTextLogBase::WriteInfoLine(std::string_view message, std::source_locati
 //---------------------------------------------------------------------------
 void TASWTextLogBase::WriteInitializationInfo()
 {
+    if (GetConfigUnlocked().Startup.WriteLoggerVersion)
+        WriteLoggerVersionInfo();
+
     if (GetConfigUnlocked().Startup.WriteTimeInfo)
         WriteTimeInfo();
 
@@ -1019,6 +1023,12 @@ std::string TASWTextLogBase::WriteLogEntry(const TASWLogRecord& record)
     return line;
 }
 
+//---------------------------------------------------------------------------
+void TASWTextLogBase::WriteLoggerVersionInfo()
+{
+    WriteInfoLine(std::format("ASWLog: version={}, logger={}", Version, GetLoggerClassName()));
+}
+
 //---------------------------------------------------------------------------
 void TASWTextLogBase::WriteMemoryUsageInfo()
 {
diff --git a/ASWLog/ASWLog_TextLogBase.h b/ASWLog/ASWLog_TextLogBase.h
index bbcc4cb..5cf6a89 100644
--- a/ASWLog/ASWLog_TextLogBase.h
+++ b/ASWLog/ASWLog_TextLogBase.h
@@ -209,6 +209,7 @@ class TASWTextLogBase : public TASWLogBase
     void WriteInfoLine(std::string_view message, std::source_location loc = std::source_location::current());
     void WriteInitializationInfo();
     std::string WriteLogEntry(const TASWLogRecord& record);
+    void WriteLoggerVersionInfo();
     void WriteMemoryUsageInfo();
     void WriteOSInfo();
     void WriteQueuedEntries(std::deque<TQueuedEntry>& entries, std::size_t droppedCount) noexcept;
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d171850..bc44842 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -254,6 +254,11 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   the library is now named `ASWLogd` (e.g. `ASWLogd.lib`), so Debug and
   Release can share an install prefix; nothing changes for code that links to
   the `ASWLog::ASWLog` target.
+- The ASWLog version in the startup lines: right after the banner, a text
+  logger writes e.g. `ASWLog: version=1.0.0, logger=TASWFileLog`, so a log
+  from the field says which ASWLog (and which logger) wrote it. On by
+  default; `Startup.WriteLoggerVersion = false` leaves it out, which code that
+  turns off every startup line one by one must now add.
 
 ### Changed
 
diff --git a/README.md b/README.md
index 766fd92..f307b23 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,8 @@ pattern formatters, crash handlers, and the other extras below) is opt-in.
   against their arguments at compile time; wrap one built at run time in `ASWLog::RuntimeFormat()`.
 - Runtime `Open()`, `Close()`, `Flush()` and log rotation controls, and `Reconfigure()` to change settings safely
   while other threads log.
-- Optional application and system memory, OS, drive, time, and command-line diagnostics.
+- Optional startup diagnostics: the ASWLog version, application and system memory, OS, drive, time, and the command
+  line.
 - Retry handling for temporary file access conflicts and Windows reader-sharing support.
 - Crash durability: every entry is flushed by default, and with buffered flushing Error and Critical entries still
   are (`File.FlushImmediatelyAtLevel`). Entries at a chosen level can also be synced to disk to survive a power loss
@@ -116,7 +117,8 @@ int main()
 }
 ```
 
-writes `logs/myapp.txt`, after the startup lines (time, OS, drive, memory, application; see `TASWLogConfig::Startup`):
+writes `logs/myapp.txt`, after the startup lines (ASWLog version, time, OS, drive, memory, application; see
+`TASWLogConfig::Startup`):
 
 ```text
 [2026-10-11T00:24:25.089Z][INFO][P:6180][T:6648]: Started
diff --git a/docs/Configuration.md b/docs/Configuration.md
index de42c30..baf40c8 100644
--- a/docs/Configuration.md
+++ b/docs/Configuration.md
@@ -85,6 +85,7 @@ The `Show*` settings are read by the built-in layout and by `TASWJSONFormatter`;
 | Setting | Default | What it does |
 |---|---|---|
 | `Banner` | empty | A line written first, if set. |
+| `WriteLoggerVersion` | `true` | The ASWLog version and the logger's class, right after the banner, e.g. `ASWLog: version=1.0.0, logger=TASWFileLog`, so a log says which ASWLog wrote it. |
 | `WriteApplicationInfo` | `true` | The executable's path and build target, e.g. `App: app_exe='C:\MyApp\MyApp.exe', app_target=Win64`. |
 | `WriteCommandLine` | `false` | The command line, added to the application line. |
 | `WriteDriveInfo` | `true` | The disk's total, free and used space. |
diff --git a/tests/tests/Test_ASWLog_CategoryLog.cpp b/tests/tests/Test_ASWLog_CategoryLog.cpp
index d8a7be3..5f53668 100644
--- a/tests/tests/Test_ASWLog_CategoryLog.cpp
+++ b/tests/tests/Test_ASWLog_CategoryLog.cpp
@@ -185,6 +185,7 @@ ASWLog::TASWLogConfig MakeFileConfig(const std::filesystem::path& file)
     config.Line.ShowProcessId = false;
     config.Line.ShowThreadId = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 7acea5a..305dcc1 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -341,6 +341,7 @@ void TTest_ASWLog_Config::Test_ApplyEnvironment_SeedsTheLevelAtInitialize()
     config.Startup.WriteMemoryUsage = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Shutdown.WriteLine = false;
     ASWLog::TASWMemoryLog log;
@@ -555,6 +556,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     CheckTrue(config.Startup.WriteApplicationInfo, "Startup.WriteApplicationInfo should default to true");
     CheckFalse(config.Startup.WriteCommandLine, "Startup.WriteCommandLine should default to false");
     CheckTrue(config.Startup.WriteDriveInfo, "Startup.WriteDriveInfo should default to true");
+    CheckTrue(config.Startup.WriteLoggerVersion, "Startup.WriteLoggerVersion should default to true");
     CheckTrue(config.Startup.WriteMemoryUsage, "Startup.WriteMemoryUsage should default to true");
     CheckTrue(config.Startup.WriteOSInfo, "Startup.WriteOSInfo should default to true");
     CheckTrue(config.Startup.WriteSystemMemoryInfo, "Startup.WriteSystemMemoryInfo should default to true");
diff --git a/tests/tests/Test_ASWLog_ConsoleLog.cpp b/tests/tests/Test_ASWLog_ConsoleLog.cpp
index d158eda..bb6418d 100644
--- a/tests/tests/Test_ASWLog_ConsoleLog.cpp
+++ b/tests/tests/Test_ASWLog_ConsoleLog.cpp
@@ -191,6 +191,7 @@ ASWLog::TASWLogConfig MakeQuietConfig()
     config.Line.ShowFunctionName = false;
     config.Line.ShowSourceLine = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_CrashHandler.cpp b/tests/tests/Test_ASWLog_CrashHandler.cpp
index 26e251b..66ee3c4 100644
--- a/tests/tests/Test_ASWLog_CrashHandler.cpp
+++ b/tests/tests/Test_ASWLog_CrashHandler.cpp
@@ -270,6 +270,7 @@ ASWLog::TASWLogConfig MakeCrashTestConfig(const std::filesystem::path& fileName)
     config.Line.ShowFunctionName = false;
     config.Line.ShowSourceLine = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_DebuggerLog.cpp b/tests/tests/Test_ASWLog_DebuggerLog.cpp
index c91ec50..b8c6b02 100644
--- a/tests/tests/Test_ASWLog_DebuggerLog.cpp
+++ b/tests/tests/Test_ASWLog_DebuggerLog.cpp
@@ -84,6 +84,7 @@ ASWLog::TASWLogConfig MakeDebuggerConfig()
     config.Line.ShowProcessId = false;
     config.Line.ShowThreadId = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_Fields.cpp b/tests/tests/Test_ASWLog_Fields.cpp
index 3ccce80..62bcf31 100644
--- a/tests/tests/Test_ASWLog_Fields.cpp
+++ b/tests/tests/Test_ASWLog_Fields.cpp
@@ -256,6 +256,7 @@ void TTest_ASWLog_Fields::Test_Async_OnLogEntryGetsTheFieldsAfterTheScopeEnds()
     config.File.FilePath = "async.log";
     config.File.OpenRetryCount = 1;
     config.Async.Enabled = true;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index 3a772b6..fd0ad67 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -293,6 +293,7 @@ ASWLog::TASWLogConfig MakeRotationTestConfig(const std::filesystem::path& logFil
     config.Line.ShowThreadId = false;
     config.Line.ShowFunctionName = false;
     config.Line.ShowSourceLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
@@ -1460,6 +1461,7 @@ void TTest_ASWLog_FileLog::Test_InitializeAndLogInfo_WritesText()
     config.Line.ShowPeakWorkingSet = false;
     config.Line.ShowFunctionName = false;
     config.Line.ShowSourceLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index 12ae67c..dd3f3a7 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -134,6 +134,7 @@ ASWLog::TASWLogConfig MakeConfigWithoutFields(const std::filesystem::path& file)
     config.Line.ShowSourceLine = false;
     config.File.OpenRetryCount = 1;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_Limiter.cpp b/tests/tests/Test_ASWLog_Limiter.cpp
index 2498066..3ef8207 100644
--- a/tests/tests/Test_ASWLog_Limiter.cpp
+++ b/tests/tests/Test_ASWLog_Limiter.cpp
@@ -84,6 +84,7 @@ ASWLog::TASWLogConfig MakeLimiterConfig()
     config.Line.ShowProcessId = false;
     config.Line.ShowThreadId = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_MemoryLog.cpp b/tests/tests/Test_ASWLog_MemoryLog.cpp
index 8a3f029..185bdc7 100644
--- a/tests/tests/Test_ASWLog_MemoryLog.cpp
+++ b/tests/tests/Test_ASWLog_MemoryLog.cpp
@@ -60,6 +60,7 @@ ASWLog::TASWLogConfig MakeMemoryConfig(std::size_t maxLines = 1000, std::size_t
     config.Line.ShowProcessId = false;
     config.Line.ShowThreadId = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_MultiLog.cpp b/tests/tests/Test_ASWLog_MultiLog.cpp
index 16523a0..e339dcb 100644
--- a/tests/tests/Test_ASWLog_MultiLog.cpp
+++ b/tests/tests/Test_ASWLog_MultiLog.cpp
@@ -248,6 +248,7 @@ ASWLog::TASWLogConfig MakeFileConfig(const std::filesystem::path& dir, const std
     config.Line.ShowSourceLine = false;
     config.File.OpenRetryCount = 1;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_SyslogLog.cpp b/tests/tests/Test_ASWLog_SyslogLog.cpp
index 60822ff..85f1ca9 100644
--- a/tests/tests/Test_ASWLog_SyslogLog.cpp
+++ b/tests/tests/Test_ASWLog_SyslogLog.cpp
@@ -89,6 +89,7 @@ ASWLog::TASWLogConfig MakeSyslogConfig()
     config.Line.ShowProcessId = false;
     config.Line.ShowThreadId = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
diff --git a/tests/tests/Test_ASWLog_TextLogBase.cpp b/tests/tests/Test_ASWLog_TextLogBase.cpp
index e160266..7dccc0c 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.cpp
+++ b/tests/tests/Test_ASWLog_TextLogBase.cpp
@@ -49,6 +49,7 @@ limitations under the License.
 #include "ASWLog_FileLog.h"
 #include "ASWLog_Formatter.h"
 #include "ASWLog_TextLogBase.h"
+#include "ASWLog_Version.h"
 //---------------------------------------------------------------------------
 
 namespace ASWUnitTests
@@ -342,6 +343,7 @@ ASWLog::TASWLogConfig MakeQuietConfig()
     config.Line.ShowSourceLine = false;
     config.File.OpenRetryCount = 1;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;
@@ -418,6 +420,7 @@ TTest_ASWLog_TextLogBase::TTest_ASWLog_TextLogBase()
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Flush_ThrowingHookDoesNotEscape, "Flush_ThrowingHookDoesNotEscape");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Formatter_FormatsEveryFileLine, "Formatter_FormatsEveryFileLine");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Initialize_ThrowingFormatterStillInitializes, "Initialize_ThrowingFormatterStillInitializes");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_Initialize_WritesLoggerVersionAfterTheBanner, "Initialize_WritesLoggerVersionAfterTheBanner");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Initialize_WritesStartupLinesThenCallsAfterEntry, "Initialize_WritesStartupLinesThenCallsAfterEntry");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Log_AtLevelOffIsNeverWritten, "Log_AtLevelOffIsNeverWritten");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Log_DroppedWhenNotReadyOrNotPrepared, "Log_DroppedWhenNotReadyOrNotPrepared");
@@ -1096,6 +1099,31 @@ void TTest_ASWLog_TextLogBase::Test_Initialize_ThrowingFormatterStillInitializes
         "The skipped startup lines and the dropped entry should be reported");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_Initialize_WritesLoggerVersionAfterTheBanner()
+{
+    // Arrange
+    TMemoryOutput output;
+    TMemoryTextLog log(output);
+    auto config = MakeQuietConfig();
+    config.Startup.Banner = "starting";
+    config.Startup.WriteLoggerVersion = true;
+    config.Startup.WriteTimeInfo = true;
+
+    // Act
+    const bool initialized = log.Initialize(config);
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(3, output.Lines.size(), "Initialize should write the banner, the version line and the time line");
+    if (output.Lines.size() == 3)
+    {
+        CheckEquals(std::string("[INFO]: starting\n"), output.Lines[0], "The banner should come first");
+        CheckEquals(std::format("[INFO]: ASWLog: version={}, logger=TMemoryTextLog\n", ASWLog::Version), output.Lines[1],
+            "The version line should follow the banner, with the version and the logger's class");
+        CheckStartsWith(output.Lines[2], "[INFO]: Time: ", "The other startup lines should follow: " + output.Lines[2]);
+    }
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_TextLogBase::Test_Initialize_WritesStartupLinesThenCallsAfterEntry()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_TextLogBase.h b/tests/tests/Test_ASWLog_TextLogBase.h
index f3b5e9a..e7b5819 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.h
+++ b/tests/tests/Test_ASWLog_TextLogBase.h
@@ -55,6 +55,7 @@ class TTest_ASWLog_TextLogBase : public TTestGroupBase
     void Test_Flush_ThrowingHookDoesNotEscape();
     void Test_Formatter_FormatsEveryFileLine();
     void Test_Initialize_ThrowingFormatterStillInitializes();
+    void Test_Initialize_WritesLoggerVersionAfterTheBanner();
     void Test_Initialize_WritesStartupLinesThenCallsAfterEntry();
     void Test_Log_AtLevelOffIsNeverWritten();
     void Test_Log_DroppedWhenNotReadyOrNotPrepared();
diff --git a/tests/tests/Test_ASWLog_Unicode.cpp b/tests/tests/Test_ASWLog_Unicode.cpp
index b8c3b39..e1612ad 100644
--- a/tests/tests/Test_ASWLog_Unicode.cpp
+++ b/tests/tests/Test_ASWLog_Unicode.cpp
@@ -254,6 +254,7 @@ ASWLog::TASWLogConfig MakeQuietConfig()
     config.Startup.WriteMemoryUsage = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteSystemMemoryInfo = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     return config;
 }
diff --git a/tests/tests/Test_ASWLog_WindowsEventLog.cpp b/tests/tests/Test_ASWLog_WindowsEventLog.cpp
index 400b6e6..4b9d3b8 100644
--- a/tests/tests/Test_ASWLog_WindowsEventLog.cpp
+++ b/tests/tests/Test_ASWLog_WindowsEventLog.cpp
@@ -88,6 +88,7 @@ ASWLog::TASWLogConfig MakeEventLogConfig()
     config.Line.ShowProcessId = false;
     config.Line.ShowThreadId = false;
     config.Shutdown.WriteLine = false;
+    config.Startup.WriteLoggerVersion = false;
     config.Startup.WriteTimeInfo = false;
     config.Startup.WriteOSInfo = false;
     config.Startup.WriteDriveInfo = false;

From 55c9e7e7bfcd54c6f6f0dc96c1d3db0a6b516be8 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 19:45:19 -0700
Subject: [PATCH 27/38] Write the application's version in the startup lines

---
 ASWLog/ASWLog_Config.h                  |  3 ++
 ASWLog/ASWLog_TextLogBase.cpp           | 13 ++++-
 ASWLog/ASWLog_Utils.cpp                 | 60 +++++++++++++++++++++
 ASWLog/ASWLog_Utils.h                   |  7 +++
 CHANGELOG.md                            |  8 +++
 README.md                               |  4 +-
 docs/Configuration.md                   |  3 +-
 tests/tests/Test_ASWLog_Config.cpp      |  1 +
 tests/tests/Test_ASWLog_TextLogBase.cpp | 56 ++++++++++++++++++++
 tests/tests/Test_ASWLog_TextLogBase.h   |  2 +
 tests/tests/Test_ASWLog_Utils.cpp       | 70 +++++++++++++++++++++++++
 tests/tests/Test_ASWLog_Utils.h         |  2 +
 12 files changed, 225 insertions(+), 4 deletions(-)

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index ffdb7d5..7159c2b 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -301,6 +301,9 @@ struct TASWShutdownConfig
 /////////////////////////////////////////////////////////////////////////////
 struct TASWStartupConfig
 {
+    // The application's version, written on the "App:" line as app_version='...' (see WriteApplicationInfo). Empty: on
+    // Windows, the executable's file version from its version resource, if it has one (see GetFileVersionString()).
+    std::string ApplicationVersion;
     std::string Banner; // Written first, if set
     bool WriteApplicationInfo  = true;
     bool WriteCommandLine      = false; // Added to the application info line
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index dbdeef4..20cadd2 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -863,7 +863,18 @@ void TASWTextLogBase::WaitForQueuedEntries()
 //---------------------------------------------------------------------------
 void TASWTextLogBase::WriteApplicationInfo()
 {
-    auto applicationInfo = std::format("app_exe='{}', app_target=", PathToUTF8String(GetExecutablePath()));
+    const auto executablePath = GetExecutablePath();
+    auto applicationInfo = std::format("app_exe='{}'", PathToUTF8String(executablePath));
+
+    // The configured version, or else the executable's file version (Windows)
+    auto applicationVersion = GetConfigUnlocked().Startup.ApplicationVersion;
+    if (applicationVersion.empty())
+        applicationVersion = GetFileVersionString(executablePath);
+
+    if (!applicationVersion.empty())
+        applicationInfo += std::format(", app_version='{}'", applicationVersion);
+
+    applicationInfo += ", app_target=";
 
 #if defined(_WIN64)
     applicationInfo += "Win64";
diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index ca1688b..47145c4 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -30,18 +30,22 @@ limitations under the License.
 #include <charconv>
 #include <chrono>
 #include <climits>
+#include <cstddef>
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
 #include <filesystem>
 #include <format>
 #include <fstream>
+#include <memory>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
 #if defined(_WIN32)
 #include <windows.h>
 #include <psapi.h>
+#include <winver.h>
 #else
 #include <sys/syscall.h>
 #include <sys/sysinfo.h>
@@ -206,6 +210,62 @@ std::filesystem::path GetExecutablePath()
     return std::filesystem::path("unknown");
 }
 
+//---------------------------------------------------------------------------
+std::string GetFileVersionString(const std::filesystem::path& file)
+{
+#if defined(_WIN32)
+    // version.dll is loaded only for this call, from the system folder, so that no project has to link it
+    using FreeLibraryFunction = BOOL(WINAPI*)(HMODULE);
+    using GetFileVersionInfoFunction = BOOL(WINAPI*)(LPCWSTR, DWORD, DWORD, LPVOID);
+    using GetFileVersionInfoSizeFunction = DWORD(WINAPI*)(LPCWSTR, LPDWORD);
+    using VerQueryValueFunction = BOOL(WINAPI*)(LPCVOID, LPCWSTR, LPVOID*, PUINT);
+
+    const HMODULE versionLibrary = LoadLibraryExW(L"version.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+    if (versionLibrary == nullptr)
+        return {};
+
+    const std::unique_ptr<std::remove_pointer_t<HMODULE>, FreeLibraryFunction> libraryOwner(versionLibrary, &FreeLibrary);
+
+    // Through void (*)() so that GCC doesn't warn about casting between function types
+    const auto getVersionInfoSize = reinterpret_cast<GetFileVersionInfoSizeFunction>(
+        reinterpret_cast<void (*)()>(GetProcAddress(versionLibrary, "GetFileVersionInfoSizeW")));
+    const auto getVersionInfo = reinterpret_cast<GetFileVersionInfoFunction>(
+        reinterpret_cast<void (*)()>(GetProcAddress(versionLibrary, "GetFileVersionInfoW")));
+    const auto queryVersionValue = reinterpret_cast<VerQueryValueFunction>(
+        reinterpret_cast<void (*)()>(GetProcAddress(versionLibrary, "VerQueryValueW")));
+    if (getVersionInfoSize == nullptr || getVersionInfo == nullptr || queryVersionValue == nullptr)
+        return {};
+
+    const std::wstring path = file.wstring();
+    DWORD handle = 0;
+    const DWORD size = getVersionInfoSize(path.c_str(), &handle);
+    if (size == 0)
+        return {};
+
+    std::vector<std::byte> versionInfo(size);
+    void* fixedInfo = nullptr;
+    UINT fixedInfoSize = 0;
+    if (!getVersionInfo(path.c_str(), 0, size, versionInfo.data()) ||
+        !queryVersionValue(versionInfo.data(), L"\\", &fixedInfo, &fixedInfoSize) || fixedInfo == nullptr ||
+        fixedInfoSize < sizeof(VS_FIXEDFILEINFO))
+    {
+        return {};
+    }
+
+    VS_FIXEDFILEINFO fileInfo{};
+    std::memcpy(&fileInfo, fixedInfo, sizeof(fileInfo));
+    if (fileInfo.dwSignature != VS_FFI_SIGNATURE)
+        return {};
+
+    return std::format("{}.{}.{}.{}", HIWORD(fileInfo.dwFileVersionMS), LOWORD(fileInfo.dwFileVersionMS),
+        HIWORD(fileInfo.dwFileVersionLS), LOWORD(fileInfo.dwFileVersionLS));
+#else
+    static_cast<void>(file);
+
+    return {};
+#endif
+}
+
 //---------------------------------------------------------------------------
 TMemoryUsage GetMemoryUsage()
 {
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index 0613531..c30d996 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -88,6 +88,13 @@ struct TSystemMemoryUsage
 
 [[nodiscard]] std::string GetDriveInfoString();
 [[nodiscard]] std::filesystem::path GetExecutablePath();
+
+// The file version in the version resource of 'file' (e.g. an executable or DLL), as four numbers, e.g. "2.3.1.45",
+// what Explorer shows as "File version". Empty if the file has no version resource or can't be read, and always on
+// Linux, which has no version resources. Windows may report its own system files' version differently (e.g. 6.2 for
+// 10.0) to an application without a compatibility manifest. Throws std::bad_alloc if out of memory.
+[[nodiscard]] std::string GetFileVersionString(const std::filesystem::path& file);
+
 [[nodiscard]] TMemoryUsage GetMemoryUsage();
 [[nodiscard]] std::string GetMemoryUsageString();
 [[nodiscard]] std::string GetOSInfoString();
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc44842..bbbc7df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -259,6 +259,14 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   from the field says which ASWLog (and which logger) wrote it. On by
   default; `Startup.WriteLoggerVersion = false` leaves it out, which code that
   turns off every startup line one by one must now add.
+- The application's version in the startup lines: the "App:" line now has
+  `app_version='...'` after the executable's path, from the new
+  `Startup.ApplicationVersion`, or, when that is empty, on Windows, from the
+  executable's file version in its version resource (e.g. `2.3.1.45`, as
+  RAD Studio's Version Info sets it). Without either, the line is as before.
+  The new `ASWLog::GetFileVersionString(path)` reads any file's version
+  (Windows; empty on Linux). It loads `version.dll` at run time, so no
+  project needs a new library to link.
 
 ### Changed
 
diff --git a/README.md b/README.md
index f307b23..0e80d7f 100644
--- a/README.md
+++ b/README.md
@@ -24,8 +24,8 @@ pattern formatters, crash handlers, and the other extras below) is opt-in.
   against their arguments at compile time; wrap one built at run time in `ASWLog::RuntimeFormat()`.
 - Runtime `Open()`, `Close()`, `Flush()` and log rotation controls, and `Reconfigure()` to change settings safely
   while other threads log.
-- Optional startup diagnostics: the ASWLog version, application and system memory, OS, drive, time, and the command
-  line.
+- Optional startup diagnostics: the ASWLog and application versions (on Windows, the application's is read from its
+  version resource unless set), application and system memory, OS, drive, time, and the command line.
 - Retry handling for temporary file access conflicts and Windows reader-sharing support.
 - Crash durability: every entry is flushed by default, and with buffered flushing Error and Critical entries still
   are (`File.FlushImmediatelyAtLevel`). Entries at a chosen level can also be synced to disk to survive a power loss
diff --git a/docs/Configuration.md b/docs/Configuration.md
index baf40c8..d689cb9 100644
--- a/docs/Configuration.md
+++ b/docs/Configuration.md
@@ -84,9 +84,10 @@ The `Show*` settings are read by the built-in layout and by `TASWJSONFormatter`;
 
 | Setting | Default | What it does |
 |---|---|---|
+| `ApplicationVersion` | empty | The application's version, written on the application line as `app_version='...'`. Empty: on Windows, the executable's file version from its version resource (e.g. `2.3.1.45`, set in RAD Studio under Project > Options > Application > Version Info), if it has one; nothing on Linux. |
 | `Banner` | empty | A line written first, if set. |
 | `WriteLoggerVersion` | `true` | The ASWLog version and the logger's class, right after the banner, e.g. `ASWLog: version=1.0.0, logger=TASWFileLog`, so a log says which ASWLog wrote it. |
-| `WriteApplicationInfo` | `true` | The executable's path and build target, e.g. `App: app_exe='C:\MyApp\MyApp.exe', app_target=Win64`. |
+| `WriteApplicationInfo` | `true` | The executable's path, the application's version (see `ApplicationVersion`) and the build target, e.g. `App: app_exe='C:\MyApp\MyApp.exe', app_version='2.3.1.45', app_target=Win64`. |
 | `WriteCommandLine` | `false` | The command line, added to the application line. |
 | `WriteDriveInfo` | `true` | The disk's total, free and used space. |
 | `WriteMemoryUsage` | `true` | The process's memory use (working set and peak). |
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 305dcc1..1564ac0 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -552,6 +552,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     CheckFalse(config.Line.ShowSourceLine, "Line.ShowSourceLine should default to false");
 
     // Assert: Startup
+    CheckEmpty(config.Startup.ApplicationVersion, "Startup.ApplicationVersion should default to empty");
     CheckEmpty(config.Startup.Banner, "Startup.Banner should default to empty");
     CheckTrue(config.Startup.WriteApplicationInfo, "Startup.WriteApplicationInfo should default to true");
     CheckFalse(config.Startup.WriteCommandLine, "Startup.WriteCommandLine should default to false");
diff --git a/tests/tests/Test_ASWLog_TextLogBase.cpp b/tests/tests/Test_ASWLog_TextLogBase.cpp
index 7dccc0c..4c16f55 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.cpp
+++ b/tests/tests/Test_ASWLog_TextLogBase.cpp
@@ -49,6 +49,7 @@ limitations under the License.
 #include "ASWLog_FileLog.h"
 #include "ASWLog_Formatter.h"
 #include "ASWLog_TextLogBase.h"
+#include "ASWLog_Utils.h"
 #include "ASWLog_Version.h"
 //---------------------------------------------------------------------------
 
@@ -401,6 +402,8 @@ bool WaitUntil(const std::function<bool()>& condition)
 TTest_ASWLog_TextLogBase::TTest_ASWLog_TextLogBase()
     : inherited("ASWLog_TextLogBase_Tests")
 {
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheConfiguredVersion, "ApplicationInfo_WritesTheConfiguredVersion");
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheExecutablesFileVersionByDefault, "ApplicationInfo_WritesTheExecutablesFileVersionByDefault");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Async_BacktraceIsTakenWhenTheTriggerIsLogged, "Async_BacktraceIsTakenWhenTheTriggerIsLogged");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Async_BlockWaitsForRoomInTheQueue, "Async_BlockWaitsForRoomInTheQueue");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Async_CallReturnsBeforeTheEntryIsWritten, "Async_CallReturnsBeforeTheEntryIsWritten");
@@ -474,6 +477,59 @@ void TTest_ASWLog_TextLogBase::TearDown_Test(ITestCase& testCase)
 
 // /////// Begin tests after this line ///////////////////////
 
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheConfiguredVersion()
+{
+    // Arrange
+    TMemoryOutput output;
+    TMemoryTextLog log(output);
+    auto config = MakeQuietConfig();
+    config.Startup.WriteApplicationInfo = true;
+    config.Startup.ApplicationVersion = "2.3.1 beta";
+
+    // Act
+    const bool initialized = log.Initialize(config);
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(1, output.Lines.size(), "Initialize should write the App line");
+    if (output.Lines.size() == 1)
+    {
+        CheckStartsWith(output.Lines[0], "[INFO]: App: app_exe='", "The App line should start with the executable's path");
+        CheckContains(output.Lines[0], "', app_version='2.3.1 beta', app_target=",
+            "The configured version should follow the executable's path: " + output.Lines[0]);
+    }
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheExecutablesFileVersionByDefault()
+{
+    // Arrange: no configured version. The test executable has a version resource in some builds (e.g. the VCL GUI
+    // runner's 1.0.0.0) and none in others (e.g. MinGW's), where no version is written.
+    TMemoryOutput output;
+    TMemoryTextLog log(output);
+    auto config = MakeQuietConfig();
+    config.Startup.WriteApplicationInfo = true;
+    const std::string fileVersion = ASWLog::GetFileVersionString(ASWLog::GetExecutablePath());
+
+    // Act
+    const bool initialized = log.Initialize(config);
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(1, output.Lines.size(), "Initialize should write the App line");
+    if (output.Lines.size() == 1)
+    {
+        if (fileVersion.empty())
+        {
+            CheckNotContains(output.Lines[0], "app_version=", "Without a version resource, no version should be written: " + output.Lines[0]);
+        }
+        else
+        {
+            CheckContains(output.Lines[0], std::format("', app_version='{}', app_target=", fileVersion),
+                "The executable's file version should follow its path: " + output.Lines[0]);
+        }
+    }
+}
 //---------------------------------------------------------------------------
 void TTest_ASWLog_TextLogBase::Test_Async_BlockWaitsForRoomInTheQueue()
 {
diff --git a/tests/tests/Test_ASWLog_TextLogBase.h b/tests/tests/Test_ASWLog_TextLogBase.h
index e7b5819..d99173c 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.h
+++ b/tests/tests/Test_ASWLog_TextLogBase.h
@@ -36,6 +36,8 @@ class TTest_ASWLog_TextLogBase : public TTestGroupBase
     typedef TTestGroupBase inherited;
 
 private: // Test methods
+    void Test_ApplicationInfo_WritesTheConfiguredVersion();
+    void Test_ApplicationInfo_WritesTheExecutablesFileVersionByDefault();
     void Test_Async_BacktraceIsTakenWhenTheTriggerIsLogged();
     void Test_Async_BlockWaitsForRoomInTheQueue();
     void Test_Async_CallReturnsBeforeTheEntryIsWritten();
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index b541ce5..ecff156 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -35,6 +35,7 @@ limitations under the License.
 #include <fstream>
 #include <iterator>
 #include <ratio>
+#include <regex>
 #include <string>
 #include <string_view>
 #include <system_error>
@@ -113,6 +114,8 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_GenerateLogFileName_PrefixAndPostfixAreOptional, "GenerateLogFileName_PrefixAndPostfixAreOptional");
     RegisterTest(&TTest_ASWLog_Utils::Test_GetCurrentOSProcessId_MatchesOS, "GetCurrentOSProcessId_MatchesOS");
     RegisterTest(&TTest_ASWLog_Utils::Test_GetCurrentOSThreadId_IdentifiesCallingThread, "GetCurrentOSThreadId_IdentifiesCallingThread");
+    RegisterTest(&TTest_ASWLog_Utils::Test_GetFileVersionString_IsEmptyWithoutAVersionResource, "GetFileVersionString_IsEmptyWithoutAVersionResource");
+    RegisterTest(&TTest_ASWLog_Utils::Test_GetFileVersionString_ReadsTheFileVersion, "GetFileVersionString_ReadsTheFileVersion");
     RegisterTest(&TTest_ASWLog_Utils::Test_GetOSInfoString_ContainsEdition, "GetOSInfoString_ContainsEdition");
     RegisterTest(&TTest_ASWLog_Utils::Test_GetTimeInfoString_ReportsCurrentOffset, "GetTimeInfoString_ReportsCurrentOffset");
     RegisterTest(&TTest_ASWLog_Utils::Test_GetWindowsEditionName_ProductTypes, "GetWindowsEditionName_ProductTypes");
@@ -370,6 +373,73 @@ void TTest_ASWLog_Utils::Test_GetCurrentOSThreadId_IdentifiesCallingThread()
 #endif
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_GetFileVersionString_IsEmptyWithoutAVersionResource()
+{
+    // Arrange: a text file, and a file that doesn't exist
+    const auto folder = std::filesystem::temp_directory_path() / "aswlog_utils_version_test";
+    std::filesystem::remove_all(folder);
+    std::filesystem::create_directories(folder);
+
+    const auto textFile = folder / "plain.txt";
+    {
+        std::ofstream stream(textFile);
+        stream << "no version resource";
+    }
+
+    // Act
+    const std::string textVersion = ASWLog::GetFileVersionString(textFile);
+    const std::string missingVersion = ASWLog::GetFileVersionString(folder / "missing.dll");
+
+    // Assert
+    CheckEmpty(textVersion, "A file without a version resource should have no version");
+    CheckEmpty(missingVersion, "A file that doesn't exist should have no version");
+
+    std::error_code errorCode;
+    std::filesystem::remove_all(folder, errorCode);
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_GetFileVersionString_ReadsTheFileVersion()
+{
+#if defined(_WIN32)
+    // Arrange: kernel32.dll, e.g. "10.0.19041.5794" on Windows 10. To an executable without a compatibility manifest,
+    // Windows reports its system files' version as 6.2 (e.g. "6.2.19041.5794"), so the exact version isn't known here.
+    wchar_t systemFolder[MAX_PATH]{};
+    const UINT folderLength = GetSystemDirectoryW(systemFolder, MAX_PATH);
+    // Not named "kernel32", which the VCL's Windows header declares
+    const auto kernel32Path = std::filesystem::path(std::wstring(systemFolder, folderLength)) / L"kernel32.dll";
+
+    // The Windows build, e.g. 19045, from the registry rather than an API that a compatibility shim could change
+    wchar_t osBuildText[16]{};
+    DWORD osBuildTextSize = sizeof(osBuildText);
+    const bool hasOSBuild = RegGetValueW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
+        L"CurrentBuildNumber", RRF_RT_REG_SZ, nullptr, osBuildText, &osBuildTextSize) == ERROR_SUCCESS;
+
+    // Act
+    const std::string version = ASWLog::GetFileVersionString(kernel32Path);
+
+    // Assert: four numbers in the right order: a Windows major version (6 or more) above its minor version (6.2, 10.0),
+    // then the build of the Windows release the file came from: at most the Windows build, and less than 1000 below it
+    // (an enablement update raises the Windows build, e.g. 19041 to 19045, or 26100 to 26200). The revision can be any
+    // number, also above the build (e.g. 6.2.26100.33438 on Windows Server 2025).
+    std::smatch parts;
+    const bool isFourNumbers = std::regex_match(version, parts, std::regex(R"((\d+)\.(\d+)\.(\d+)\.(\d+))"));
+    CheckTrue(isFourNumbers, "The file version should be four numbers: " + version);
+    CheckTrue(hasOSBuild, "The Windows build should be in the registry");
+    if (isFourNumbers && hasOSBuild)
+    {
+        const auto major = std::stoul(parts[1].str());
+        const auto build = std::stoul(parts[3].str());
+        const auto osBuild = std::stoul(std::wstring(osBuildText));
+        CheckGreaterThanOrEqual(major, 6ul, "The major version should be a Windows version: " + version);
+        CheckGreaterThan(major, std::stoul(parts[2].str()), "The major version should come before the minor: " + version);
+        CheckLessThanOrEqual(build, osBuild, "The third number should be a Windows build, at most this one: " + version);
+        CheckLessThan(osBuild - build, 1000ul, "The third number should be this Windows release's build: " + version);
+    }
+#else
+    Skip("Only Windows files have version resources");
+#endif
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_GetOSInfoString_ContainsEdition()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index e177b70..0e2af6f 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -45,6 +45,8 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_GenerateLogFileName_PrefixAndPostfixAreOptional();
     void Test_GetCurrentOSProcessId_MatchesOS();
     void Test_GetCurrentOSThreadId_IdentifiesCallingThread();
+    void Test_GetFileVersionString_IsEmptyWithoutAVersionResource();
+    void Test_GetFileVersionString_ReadsTheFileVersion();
     void Test_GetOSInfoString_ContainsEdition();
     void Test_GetTimeInfoString_ReportsCurrentOffset();
     void Test_GetWindowsEditionName_ProductTypes();

From 0a5369b1fa449f575f1fd292dea11135466ce279 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 22:19:06 -0700
Subject: [PATCH 28/38] Write the startup lines at the top of each new log file

---
 ASWLog/ASWLog_Config.h              |   7 +
 ASWLog/ASWLog_FileLog.cpp           |  79 ++++++-
 ASWLog/ASWLog_FileLog.h             |   9 +-
 ASWLog/ASWLog_TextLogBase.cpp       |  43 ++--
 ASWLog/ASWLog_TextLogBase.h         |  14 ++
 CHANGELOG.md                        |  13 ++
 README.md                           |   3 +-
 docs/Configuration.md               |   6 +-
 tests/tests/Test_ASWLog_Config.cpp  |   1 +
 tests/tests/Test_ASWLog_FileLog.cpp | 345 ++++++++++++++++++++++++++++
 tests/tests/Test_ASWLog_FileLog.h   |  11 +
 11 files changed, 499 insertions(+), 32 deletions(-)

diff --git a/ASWLog/ASWLog_Config.h b/ASWLog/ASWLog_Config.h
index 7159c2b..29d7e2e 100644
--- a/ASWLog/ASWLog_Config.h
+++ b/ASWLog/ASWLog_Config.h
@@ -177,6 +177,13 @@ struct TASWFileConfig
     // Rolls the file over at midnight, and at Initialize() if the file was last written on an earlier day, both in
     // Line.TimestampZone (UTC by default). The backup is named for the day it holds.
     bool EnableDailyRolling   = false;
+    // Starts each file the logger begins after Initialize() (by rotation, daily rolling or Reconfigure() to a new path)
+    // with a line saying where the log continues from, e.g. "Log continued from aswlog.size.2026-10-10_143005_123.bak
+    // (size)" or "Log continued from logs\old.txt (reconfigure)", followed by the startup lines as Initialize() writes
+    // them (see TASWStartupConfig, whose settings still apply), so each file says what wrote it. They are Info lines,
+    // written before the entry that started the file. Not after a failed rotation, and with AutoOpenClosePerWrite, only
+    // by the process that rotated the shared log.
+    bool WriteStartupLinesInNewFiles = true;
 
     // --- Backup Event ---
     // Called once for each backup that rotation makes, e.g. to compress it, upload it or move it elsewhere. Called
diff --git a/ASWLog/ASWLog_FileLog.cpp b/ASWLog/ASWLog_FileLog.cpp
index aa00487..d3a6103 100644
--- a/ASWLog/ASWLog_FileLog.cpp
+++ b/ASWLog/ASWLog_FileLog.cpp
@@ -482,8 +482,8 @@ TASWFileLog::~TASWFileLog()
 //---------------------------------------------------------------------------
 void TASWFileLog::AfterEntryUnlocked()
 {
-    // In this mode the file is only open while an entry (or Initialize()'s startup lines) is written. Unlike Close(),
-    // this leaves the logger initialized.
+    // In this mode the file is only open while an entry (or the startup lines) is written. Unlike Close(), this leaves
+    // the logger initialized.
     if (GetConfigUnlocked().File.AutoOpenClosePerWrite)
         CloseFileUnlocked();
 }
@@ -704,6 +704,9 @@ bool TASWFileLog::InitializeUnlocked()
     if (GetConfigUnlocked().File.EnableDailyRolling)
         RotateDailyLogFromEarlierDayUnlocked();
 
+    // Initialize() writes the startup lines itself, and Reconfigure() its own continuation line
+    m_PendingContinuationLine.clear();
+
     if (!OpenUnlocked())
     {
         return false;
@@ -792,6 +795,9 @@ bool TASWFileLog::OpenUnlocked()
 
     m_IsOpen.store(true, std::memory_order_release);
     m_IsInitialized.store(true, std::memory_order_release);
+
+    WriteNewFileStartupLinesUnlocked();
+
     return true;
 }
 
@@ -799,8 +805,9 @@ bool TASWFileLog::OpenUnlocked()
 /*
     TASWFileLog::PrepareWriteUnlocked
 
-    Rotates the log file if the day has changed or the file has reached its maximum size, as configured. Returns false
-    if the file isn't open (e.g. it couldn't be reopened after a rotation), which drops the line.
+    Rotates the log file if the day has changed or the file has reached its maximum size, as configured, but not while
+    the startup lines are written (the new file's own, or Initialize()'s): the next entry rotates it. Returns false if
+    the file isn't open (e.g. it couldn't be reopened after a rotation), which drops the line.
 */
 bool TASWFileLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point now)
 {
@@ -809,7 +816,7 @@ bool TASWFileLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point now
         // Only rolls forward (ISO dates compare as text): an entry stamped just before midnight can get the lock after
         // another thread's entry has rolled the log over, and then goes into the new day's log
         const auto currentDateStr = Time::ToDateString(now, GetConfigUnlocked().Line.TimestampZone);
-        if (currentDateStr > m_LastLogDateStr)
+        if (currentDateStr > m_LastLogDateStr && !IsWritingStartupLinesUnlocked())
         {
             // Name the backup for the day its content is from, not the day that just started. A log shared with other
             // processes may already have been rolled over by one of them, so there the file's last write decides.
@@ -825,7 +832,8 @@ bool TASWFileLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point now
     // Uses the size tracked by the stream, since on Windows the size read through the path isn't current while open.
     // After a failed rotation (e.g. another program holds the file), waits RotationRetryDelay before trying again.
     if (GetConfigUnlocked().File.EnableRotation && m_FileStream.IsOpen() && m_FileStream.GetSize() >= GetConfigUnlocked().File.MaxFileSizeBytes &&
-        IsRetryDue(m_LastRotationFailure, now, GetConfigUnlocked().File.RotationRetryDelay))
+        IsRetryDue(m_LastRotationFailure, now, GetConfigUnlocked().File.RotationRetryDelay) &&
+        !IsWritingStartupLinesUnlocked())
     {
         RotateLogFilesUnlocked("size", ToBackupTimeLabel(now, GetConfigUnlocked().Line.TimestampZone));
     }
@@ -838,9 +846,11 @@ bool TASWFileLog::PrepareWriteUnlocked(std::chrono::system_clock::time_point now
     TASWFileLog::ReconfigureUnlocked
 
     If the file path or AutoOpenClosePerWrite changed, closes the old file and starts on the new one as Initialize()
-    does (rolling over a file from an earlier day, if daily rolling is on, then opening it). With AutoOpenClosePerWrite
-    the new file is closed again until the next entry, but opening it here reports a file that can't be opened. A
-    failed open keeps the logger initialized, so later entries try again (see EnsureReadyUnlocked()).
+    does (rolling over a file from an earlier day, if daily rolling is on, then opening it). A new path starts with
+    the startup lines (see WriteNewFileStartupLinesUnlocked()). With AutoOpenClosePerWrite the new file is closed again
+    until the next entry, but opening it here reports a file that can't be opened. A failed open keeps the logger
+    initialized, so later entries try again (see EnsureReadyUnlocked()), and the first one that opens the file writes
+    the startup lines.
 
     Otherwise the file stays open: flushes what the previous flush mode may have buffered, and the other settings take
     effect with the next entry (a FlushMode::Periodic thread is started, stopped or given its new interval after the
@@ -853,8 +863,9 @@ bool TASWFileLog::ReconfigureUnlocked(const TASWLogConfig& previous)
     const auto& file = config.File;
     m_SyncsCrashLine.store(Level::Critical >= file.SyncToDiskAtLevel, std::memory_order_relaxed);
 
-    if (file.ResolvePath() == previous.File.ResolvePath() &&
-        file.AutoOpenClosePerWrite == previous.File.AutoOpenClosePerWrite)
+    const auto previousPath = previous.File.ResolvePath();
+    const bool isNewPath = file.ResolvePath() != previousPath;
+    if (!isNewPath && file.AutoOpenClosePerWrite == previous.File.AutoOpenClosePerWrite)
     {
         if (config.Line.TimestampZone != previous.Line.TimestampZone)
             m_LastLogDateStr = Time::ToDateString(NowUTC(), config.Line.TimestampZone);
@@ -867,6 +878,13 @@ bool TASWFileLog::ReconfigureUnlocked(const TASWLogConfig& previous)
 
     CloseFileUnlocked();
     const bool isOpen = InitializeUnlocked();
+
+    if (isNewPath && file.WriteStartupLinesInNewFiles)
+    {
+        m_PendingContinuationLine = std::format("Log continued from {} (reconfigure)", PathToUTF8String(previousPath));
+        WriteNewFileStartupLinesUnlocked();
+    }
+
     AfterEntryUnlocked();
 
     return isOpen;
@@ -913,7 +931,18 @@ bool TASWFileLog::RotateLogFiles(std::string_view reasonTag)
 {
     TDeferredWorkRunner deferredWorkRunner(*this);
     std::lock_guard<std::mutex> lock(m_Mutex);
-    return RotateLogFilesUnlocked(reasonTag, ToBackupTimeLabel(NowUTC(), GetConfigUnlocked().Line.TimestampZone));
+    const auto timeLabel = ToBackupTimeLabel(NowUTC(), GetConfigUnlocked().Line.TimestampZone);
+    const bool isRotated = RotateLogFilesUnlocked(reasonTag, timeLabel);
+
+    // A file that is closed between entries (AutoOpenClosePerWrite) is opened for its startup lines now, so they come
+    // first even if another process writes to it next
+    if (isRotated && !m_PendingContinuationLine.empty() && m_IsInitialized.load(std::memory_order_acquire) &&
+        EnsureReadyUnlocked())
+    {
+        AfterEntryUnlocked();
+    }
+
+    return isRotated;
 }
 
 //---------------------------------------------------------------------------
@@ -994,6 +1023,13 @@ bool TASWFileLog::RotateLogFilesUnlocked(std::string_view reasonTag, std::string
         return false;
     }
 
+    // The next file starts with the startup lines, written once it is open (see WriteNewFileStartupLinesUnlocked())
+    if (!backupPath.empty() && GetConfigUnlocked().File.WriteStartupLinesInNewFiles)
+    {
+        m_PendingContinuationLine = std::format("Log continued from {} ({})", PathToUTF8String(backupPath.filename()),
+            reasonTag);
+    }
+
     const bool isOpen = wasOpen ? OpenUnlocked() : true;
 
     // OnBackupCreated calls into the application and the cleanup scans the folder, so both run after the lock is
@@ -1060,6 +1096,25 @@ void TASWFileLog::WriteLineUnlocked(Level level, std::string_view line, bool end
     MaybeFlush(level, endsLine);
 }
 
+//---------------------------------------------------------------------------
+/*
+    TASWFileLog::WriteNewFileStartupLinesUnlocked
+
+    Starts a file the logger began after Initialize() (see TASWFileConfig::WriteStartupLinesInNewFiles), once it is
+    open: writes the line saying where the log continues from, then the startup lines. Called by OpenUnlocked(), so a
+    rotation writes them before the entry that triggered it, and a file that couldn't be opened right away gets them
+    from the open that succeeds. Does nothing if no new file is waiting for them.
+*/
+void TASWFileLog::WriteNewFileStartupLinesUnlocked()
+{
+    if (m_PendingContinuationLine.empty() || !m_FileStream.IsOpen())
+        return;
+
+    // Taken first, so that the lines are written once even if they fail
+    const auto continuationLine = std::exchange(m_PendingContinuationLine, std::string());
+    WriteStartupLinesUnlocked(continuationLine);
+}
+
 //---------------------------------------------------------------------------
 
 } // namespace ASWLog
diff --git a/ASWLog/ASWLog_FileLog.h b/ASWLog/ASWLog_FileLog.h
index 4746515..f2c0939 100644
--- a/ASWLog/ASWLog_FileLog.h
+++ b/ASWLog/ASWLog_FileLog.h
@@ -128,6 +128,9 @@ class TASWFileLog : public TASWTextLogBase
     std::string m_LastLogDateStr; // Stores YYYY-MM-DD state to detect structural calendar shifts
     std::chrono::system_clock::time_point m_LastOpenFailure{}; // NowUTC() when opening the file last failed
     std::chrono::system_clock::time_point m_LastRotationFailure{}; // NowUTC() when a rotation last failed
+    // The first line of a new file the logger started (see TASWFileConfig::WriteStartupLinesInNewFiles), waiting for
+    // the file to be open; empty if none
+    std::string m_PendingContinuationLine;
 
     // File.SyncToDiskAtLevel is Critical or lower, for WriteCrashLineDirect(), which may run without m_Mutex
     std::atomic<bool> m_SyncsCrashLine{ false };
@@ -142,6 +145,7 @@ class TASWFileLog : public TASWTextLogBase
     void RotateDailyLogFromEarlierDayUnlocked();
     bool RotateLogFilesUnlocked(std::string_view reasonTag, std::string_view timeLabel);
     void SyncToDiskUnlocked();
+    void WriteNewFileStartupLinesUnlocked();
 
 protected: // TASWTextLogBase hooks
     void AfterEntryUnlocked() override;
@@ -186,8 +190,9 @@ class TASWFileLog : public TASWTextLogBase
 
     // Renames the log file to "<stem>.<reasonTag>.<YYYY-MM-DD_HHMMSS_mmm>.bak" (the time in Line.TimestampZone, UTC by
     // default), adding "_1", "_2", ... to the time if that name is taken, so an existing backup is never replaced. Then
-    // reopens the log if it was open. A 'reasonTag' that contains '.' makes a backup that TASWFileConfig's backup
-    // cleanup doesn't recognize, so it is kept.
+    // reopens the log if it was open, and starts the new file with the startup lines (see
+    // TASWFileConfig::WriteStartupLinesInNewFiles; with AutoOpenClosePerWrite it is opened for them). A 'reasonTag'
+    // that contains '.' makes a backup that TASWFileConfig's backup cleanup doesn't recognize, so it is kept.
     bool RotateLogFiles(std::string_view reasonTag = "manual");
 };
 
diff --git a/ASWLog/ASWLog_TextLogBase.cpp b/ASWLog/ASWLog_TextLogBase.cpp
index 20cadd2..cd4ffb0 100644
--- a/ASWLog/ASWLog_TextLogBase.cpp
+++ b/ASWLog/ASWLog_TextLogBase.cpp
@@ -261,22 +261,8 @@ bool TASWTextLogBase::Initialize(const TASWLogConfig& config) noexcept
 
         Detail::TCrashHandling::Register(*this);
 
-        // The output is ready, so the startup lines are best effort: if one throws (e.g. a formatter that throws, or
-        // out of memory while gathering the system info), the rest are skipped but the logger is still initialized
-        try
-        {
-            if (!GetConfigUnlocked().Startup.Banner.empty())
-            {
-                WriteInfoLine(GetConfigUnlocked().Startup.Banner);
-            }
-
-            WriteInitializationInfo();
-        }
-        catch (...)
-        {
-            ReportCurrentExceptionUnlocked("Skipped the startup lines");
-        }
-
+        // The output is ready, so the startup lines are best effort: a failed one doesn't fail Initialize()
+        WriteStartupLinesUnlocked();
         AfterEntryUnlocked();
 
         return true;
@@ -1188,6 +1174,31 @@ void TASWTextLogBase::WriteRecord(const TASWLogRecord& record)
         DispatchLogCallback(*callbackConfig, record, writtenLine);
 }
 
+//---------------------------------------------------------------------------
+void TASWTextLogBase::WriteStartupLinesUnlocked(std::string_view firstLine) noexcept
+{
+    m_IsWritingStartupLines = true;
+
+    // If a line throws (e.g. a formatter that throws, or out of memory while gathering the system info), the rest are
+    // skipped
+    try
+    {
+        if (!firstLine.empty())
+            WriteInfoLine(firstLine);
+
+        if (!GetConfigUnlocked().Startup.Banner.empty())
+            WriteInfoLine(GetConfigUnlocked().Startup.Banner);
+
+        WriteInitializationInfo();
+    }
+    catch (...)
+    {
+        ReportCurrentExceptionUnlocked("Skipped the startup lines");
+    }
+
+    m_IsWritingStartupLines = false;
+}
+
 //---------------------------------------------------------------------------
 void TASWTextLogBase::WriteSystemMemoryInfo()
 {
diff --git a/ASWLog/ASWLog_TextLogBase.h b/ASWLog/ASWLog_TextLogBase.h
index 5cf6a89..6b15d77 100644
--- a/ASWLog/ASWLog_TextLogBase.h
+++ b/ASWLog/ASWLog_TextLogBase.h
@@ -145,6 +145,7 @@ class TASWTextLogBase : public TASWLogBase
     std::atomic<bool> m_IsAsync{ false };
 
     bool m_IsWritingQueuedEntries = false; // Guarded by m_Mutex (see IsWritingQueuedEntriesUnlocked())
+    bool m_IsWritingStartupLines = false; // Guarded by m_Mutex (see IsWritingStartupLinesUnlocked())
 
     // This logger's place on the list of loggers a crash flushes, guarded by that list's lock (see
     // Detail::TCrashHandling)
@@ -295,6 +296,13 @@ class TASWTextLogBase : public TASWLogBase
         return m_IsWritingQueuedEntries;
     }
 
+    // True while the startup lines are written (see WriteStartupLinesUnlocked()), so that PrepareWriteUnlocked() can
+    // leave starting a new output (e.g. rotating a file) until after them.
+    bool IsWritingStartupLinesUnlocked() const noexcept
+    {
+        return m_IsWritingStartupLines;
+    }
+
     // Called on the worker thread, every GetWorkerIntervalUnlocked() (measured from the start of the previous call),
     // e.g. to flush the output. Reports a failure with ReportErrorUnlocked(): the worker passes it on to OnError after
     // the unlock, on its own thread. An exception is caught and reported. Does nothing by default.
@@ -333,6 +341,12 @@ class TASWTextLogBase : public TASWLogBase
     // as is; see IASWLogFormatter::FormatsRawEntries()).
     virtual void WriteLineUnlocked(Level level, std::string_view line, bool endsLine) = 0;
 
+    // Writes the startup lines as Initialize() does: 'firstLine' if it isn't empty, the banner, then the lines
+    // TASWStartupConfig turns on, each as an Info line through PrepareWriteUnlocked() and WriteLineUnlocked(). For a
+    // derived logger that starts a new output, e.g. a file logger's next file after a rotation. A line that fails (e.g.
+    // its formatter throws) is reported and the rest are skipped. Never throws.
+    void WriteStartupLinesUnlocked(std::string_view firstLine = {}) noexcept;
+
 protected: // TASWLogBase hook
     // Writes the entry under m_Mutex, through the hooks above, then calls OnLogEntry. An asynchronous logger formats the
     // entry and queues it instead (see TASWAsyncConfig).
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bbbc7df..f58d27a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -267,6 +267,19 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   The new `ASWLog::GetFileVersionString(path)` reads any file's version
   (Windows; empty on Linux). It loads `version.dll` at run time, so no
   project needs a new library to link.
+- The startup lines at the top of each new log file: a file logger now starts
+  every file it begins after `Initialize()` (size rotation, daily rolling,
+  `RotateLogFiles()`, `Reconfigure()` to a new path) with a line saying where
+  the log continues from, e.g. `Log continued from
+  myapp.size.2026-10-10_143005_123.bak (size)` or `Log continued from
+  logs\old.txt (reconfigure)`, followed by the startup lines as
+  `Initialize()` writes them (the banner and each line its `Startup` setting
+  turns on), so a rotated log still says which version and system wrote it.
+  They come before the entry that started the file. On by default; the new
+  `File.WriteStartupLinesInNewFiles = false` keeps the old output, in which a
+  new file starts with that entry. A rotation no longer happens in the middle
+  of the startup lines: if they reach `File.MaxFileSizeBytes`, the next entry
+  rotates the file.
 
 ### Changed
 
diff --git a/README.md b/README.md
index 0e80d7f..f1c919d 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,8 @@ pattern formatters, crash handlers, and the other extras below) is opt-in.
 - Runtime `Open()`, `Close()`, `Flush()` and log rotation controls, and `Reconfigure()` to change settings safely
   while other threads log.
 - Optional startup diagnostics: the ASWLog and application versions (on Windows, the application's is read from its
-  version resource unless set), application and system memory, OS, drive, time, and the command line.
+  version resource unless set), application and system memory, OS, drive, time, and the command line, written again
+  at the top of each new file after a rotation, saying which file the log continues from.
 - Retry handling for temporary file access conflicts and Windows reader-sharing support.
 - Crash durability: every entry is flushed by default, and with buffered flushing Error and Critical entries still
   are (`File.FlushImmediatelyAtLevel`). Entries at a chosen level can also be synced to disk to survive a power loss
diff --git a/docs/Configuration.md b/docs/Configuration.md
index d689cb9..0faf451 100644
--- a/docs/Configuration.md
+++ b/docs/Configuration.md
@@ -25,7 +25,8 @@ config.Line.ShowThreadId = false;
 log.Reconfigure(config);
 ```
 
-`Reconfigure()` doesn't change the minimum level (use `SetMinimumLevel()`) and doesn't write the startup lines again.
+`Reconfigure()` doesn't change the minimum level (use `SetMinimumLevel()`) and doesn't write the startup lines again,
+except in the new file of a file logger moved to a new path (see `File.WriteStartupLinesInNewFiles`).
 
 The header comments in `ASWLog_Config.h` have the full details of each setting; this page is the overview.
 
@@ -82,6 +83,8 @@ The `Show*` settings are read by the built-in layout and by `TASWJSONFormatter`;
 
 ## `Startup`: the lines `Initialize()` writes (`TASWStartupConfig`)
 
+A file logger also writes them at the top of each new file it starts (see `File.WriteStartupLinesInNewFiles`).
+
 | Setting | Default | What it does |
 |---|---|---|
 | `ApplicationVersion` | empty | The application's version, written on the application line as `app_version='...'`. Empty: on Windows, the executable's file version from its version resource (e.g. `2.3.1.45`, set in RAD Studio under Project > Options > Application > Version Info), if it has one; nothing on Linux. |
@@ -121,6 +124,7 @@ The `Show*` settings are read by the built-in layout and by `TASWJSONFormatter`;
 | `MaxFileSizeBytes` | 10 MB | The size that triggers a rotation. |
 | `RotationRetryDelay` | 500 ms | After a failed rotation, entries go on to the current file, and rotating isn't tried again until this long after the failure. |
 | `EnableDailyRolling` | `false` | Rotates the file at midnight (in `Line.TimestampZone`), and at `Initialize()` if the file was last written on an earlier day. |
+| `WriteStartupLinesInNewFiles` | `true` | Starts each file the logger begins after `Initialize()` (size rotation, daily rolling, `RotateLogFiles()`, `Reconfigure()` to a new path) with a line saying where the log continues from, e.g. `Log continued from myapp.size.2026-10-10_143005_123.bak (size)` or `Log continued from logs\old.txt (reconfigure)`, then the startup lines (see [`Startup`](#startup-the-lines-initialize-writes-taswstartupconfig), whose settings apply). They are Info lines, written before the entry that started the file. Not after a failed rotation; with `AutoOpenClosePerWrite`, only by the process that rotated the shared log. |
 | `OnBackupCreated` | empty | Called for each backup a rotation makes, with its path and reason, e.g. to compress, upload or move it. Runs outside the logger's lock, on the thread whose call rotated the log. |
 | `RetentionMaxAge` | 0 (off) | After each rotation, deletes this log's backups older than this. |
 | `MaxBackupFiles` | 0 (unlimited) | After each rotation, keeps only the newest this many backups. |
diff --git a/tests/tests/Test_ASWLog_Config.cpp b/tests/tests/Test_ASWLog_Config.cpp
index 1564ac0..942822a 100644
--- a/tests/tests/Test_ASWLog_Config.cpp
+++ b/tests/tests/Test_ASWLog_Config.cpp
@@ -590,6 +590,7 @@ void TTest_ASWLog_Config::Test_Defaults_MatchDocumentedValues()
     CheckTrue(config.File.RotationRetryDelay == std::chrono::milliseconds(500),
         "File.RotationRetryDelay should default to 500 ms");
     CheckFalse(config.File.EnableDailyRolling, "File.EnableDailyRolling should default to false");
+    CheckTrue(config.File.WriteStartupLinesInNewFiles, "File.WriteStartupLinesInNewFiles should default to true");
     CheckTrue(config.File.RetentionMaxAge == std::chrono::hours(0), "File.RetentionMaxAge should default to 0 (disabled)");
     CheckNull(config.File.OnBackupCreated, "File.OnBackupCreated should default to unset");
     CheckEquals(0, config.File.MaxBackupFiles, "File.MaxBackupFiles should default to 0 (unlimited)");
diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index fd0ad67..1e64720 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -56,6 +56,7 @@ limitations under the License.
 //---------------------------------------------------------------------------
 #include "ASWLog_FileLog.h"
 #include "ASWLog_Utils.h"
+#include "ASWLog_Version.h"
 //---------------------------------------------------------------------------
 #include "UT_Helper_DateTime.h"
 //---------------------------------------------------------------------------
@@ -280,6 +281,18 @@ void IgnoreError(const ASWLog::TASWLogError& /*error*/)
 {
 }
 
+ASWLog::TASWLogConfig MakeRotationTestConfig(const std::filesystem::path& logFile); // See below
+
+// A config for the tests of the startup lines in a new file (File.WriteStartupLinesInNewFiles): the rotation tests'
+// config with only the banner on, so a new file starts with ": Log continued from <file> (<reason>)" and ": banner"
+ASWLog::TASWLogConfig MakeNewFileTestConfig(const std::filesystem::path& logFile)
+{
+    auto config = MakeRotationTestConfig(logFile);
+    config.File.WriteStartupLinesInNewFiles = true;
+    config.Startup.Banner = "banner";
+    return config;
+}
+
 // A config for the rotation tests, with no line metadata or startup info, so each line is just its message
 ASWLog::TASWLogConfig MakeRotationTestConfig(const std::filesystem::path& logFile)
 {
@@ -301,6 +314,7 @@ ASWLog::TASWLogConfig MakeRotationTestConfig(const std::filesystem::path& logFil
     config.Startup.WriteApplicationInfo = false;
     config.Startup.WriteMemoryUsage = false;
     config.File.OpenRetryCount = 1;
+    config.File.WriteStartupLinesInNewFiles = false;
     config.Shutdown.WriteLine = false;
     return config;
 }
@@ -391,6 +405,17 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_LogRawOptions, "LogRawOptions");
     RegisterTest(&TTest_ASWLog_FileLog::Test_MultiThreadedStress_WritesAllMessagesToDisk, "MultiThreadedStress_WritesAllMessagesToDisk");
     RegisterTest(&TTest_ASWLog_FileLog::Test_MultiThreadedStress_WritesAllMessagesToDisk_OpenClose, "MultiThreadedStress_WritesAllMessagesToDisk_OpenClose");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_AsyncWorkerWritesTheStartupLinesBeforeTheEntry, "NewFile_AsyncWorkerWritesTheStartupLinesBeforeTheEntry");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_DailyRollingStartsWithTheStartupLines, "NewFile_DailyRollingStartsWithTheStartupLines");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_FailedRotationWritesNoStartupLines, "NewFile_FailedRotationWritesNoStartupLines");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_InitializeWritesItsStartupLinesOnce, "NewFile_InitializeWritesItsStartupLinesOnce");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_ManualRotationOpensASharedLogForTheStartupLines, "NewFile_ManualRotationOpensASharedLogForTheStartupLines");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_MinimumLevelAboveInfoLeavesOutTheStartupLines, "NewFile_MinimumLevelAboveInfoLeavesOutTheStartupLines");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_ReconfigureToANewPathStartsWithTheStartupLines, "NewFile_ReconfigureToANewPathStartsWithTheStartupLines");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_RotationWaitsUntilTheStartupLinesAreWritten, "NewFile_RotationWaitsUntilTheStartupLinesAreWritten");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_SharedLogGetsTheStartupLinesOnce, "NewFile_SharedLogGetsTheStartupLinesOnce");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_SizeRotationStartsWithTheStartupLines, "NewFile_SizeRotationStartsWithTheStartupLines");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_NewFile_UnopenedFileGetsTheStartupLinesWhenItOpens, "NewFile_UnopenedFileGetsTheStartupLinesWhenItOpens");
     RegisterTest(&TTest_ASWLog_FileLog::Test_OnBackupCreated_IsNotCalledWhenRotationFails, "OnBackupCreated_IsNotCalledWhenRotationFails");
     RegisterTest(&TTest_ASWLog_FileLog::Test_OnBackupCreated_LeavesARenamedBackupToTheApp, "OnBackupCreated_LeavesARenamedBackupToTheApp");
     RegisterTest(&TTest_ASWLog_FileLog::Test_OnBackupCreated_ReportsDailyBackupAtInitialize, "OnBackupCreated_ReportsDailyBackupAtInitialize");
@@ -1858,6 +1883,326 @@ void TTest_ASWLog_FileLog::Test_MultiThreadedStress_WritesAllMessagesToDisk_Open
     }
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_AsyncWorkerWritesTheStartupLinesBeforeTheEntry()
+{
+    // Arrange: the first entry reaches the 50-byte limit, so the logger's thread rotates the log for the second one
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_async.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.Async.Enabled = true;
+    config.File.EnableRotation = true;
+    config.File.MaxFileSizeBytes = 50;
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 15 } + 10h + 30min + 5s + 250ms;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("first_entry_long_enough_to_reach_the_size_limit");
+    logger.LogInfo("second_entry");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(std::string(": Log continued from new_async.size.2026-01-15_103005_250.bak (size)\n: banner\n: second_entry\n"),
+        ReadFileText(logFile), "The logger's thread should write the startup lines at the top of the new file, before the entry");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_DailyRollingStartsWithTheStartupLines()
+{
+    // Arrange
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_daily.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.EnableDailyRolling = true;
+
+    const auto dayOne = std::chrono::sys_days{ 2026y / 1 / 15 };
+    TFixedClockFileLog logger;
+    logger.CurrentTime = dayOne + 23h + 59min;
+
+    // Act: log just before and just after UTC midnight
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("day_one_entry");
+    logger.CurrentTime = dayOne + 24h + 30s;
+    logger.LogInfo("day_two_entry");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(std::string(": banner\n: day_one_entry\n"), ReadFileText(TestTempDir / "new_daily.daily.2026-01-15.bak"),
+        "The daily backup should hold the first day's file as it was");
+    CheckEquals(std::string(": Log continued from new_daily.daily.2026-01-15.bak (daily)\n: banner\n: day_two_entry\n"),
+        ReadFileText(logFile), "The new day's file should start with the startup lines, before the entry that rolled it over");
+    CheckEquals(1, CountFilesStartingWith("new_daily.daily."), "Writing the startup lines should not roll the log over again");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_FailedRotationWritesNoStartupLines()
+{
+    // Arrange
+    if (!CanBlockFiles())
+        Skip("File permissions don't stop the root user, so the failure can't be simulated");
+
+    const auto logFile = TestTempDir / "new_failed.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.EnableRotation = true;
+    config.File.MaxFileSizeBytes = 50;
+    config.OnError = IgnoreError;
+
+    ASWLog::TASWFileLog logger;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("line_one_long_enough_to_reach_the_size_limit_alone");
+    {
+        // The size rotation's rename fails, but the log reopens, so the entry is still written
+        TFileBlocker blocker(logFile, false);
+        logger.LogInfo("line_two");
+    }
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(0, CountFilesStartingWith("new_failed.size."), "The rotation should have failed");
+    CheckEquals(std::string(": banner\n: line_one_long_enough_to_reach_the_size_limit_alone\n: line_two\n"),
+        ReadFileText(logFile), "A failed rotation starts no new file, so it should write no startup lines");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_InitializeWritesItsStartupLinesOnce()
+{
+    // Arrange: a log last written 30 hours before the logger starts, which Initialize() rolls over
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_initialize.log";
+    std::ofstream(logFile) << "yesterday_entry\n";
+    std::filesystem::last_write_time(logFile, std::chrono::file_clock::now() - 30h);
+
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.EnableDailyRolling = true;
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 15 } + 10h;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("today_entry");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(std::filesystem::exists(TestTempDir / "new_initialize.daily.2026-01-14.bak"), "Initialize() should roll the earlier day's log over");
+    CheckEquals(std::string(": banner\n: today_entry\n"), ReadFileText(logFile),
+        "The file Initialize() starts should get its startup lines once, without a continuation line");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_ManualRotationOpensASharedLogForTheStartupLines()
+{
+    // Arrange
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_manual.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.AutoOpenClosePerWrite = true;
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 15 } + 10h + 30min + 5s + 250ms;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("before_rotation");
+    const bool rotated = logger.RotateLogFiles("deploy");
+    const auto contentsAfterRotation = ReadFileText(logFile);
+    const bool openAfterRotation = logger.IsOpen();
+    logger.LogInfo("after_rotation");
+    logger.Close();
+
+    // Assert
+    constexpr std::string_view startupLines = ": Log continued from new_manual.deploy.2026-01-15_103005_250.bak (deploy)\n: banner\n";
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(rotated, "RotateLogFiles should succeed");
+    CheckEquals(std::string(startupLines), contentsAfterRotation,
+        "With File.AutoOpenClosePerWrite, RotateLogFiles() should open the new file for its startup lines at once, naming the reason tag");
+    CheckFalse(openAfterRotation, "The file should be closed again after its startup lines");
+    CheckEquals(std::string(startupLines) + ": after_rotation\n", ReadFileText(logFile), "The next entry should follow the startup lines");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_MinimumLevelAboveInfoLeavesOutTheStartupLines()
+{
+    // Arrange
+    const auto logFile = TestTempDir / "new_level.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.InitialMinimumLevel = ASWLog::Level::Warn;
+
+    ASWLog::TASWFileLog logger;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogWarn("before_rotation");
+    const bool rotated = logger.RotateLogFiles("manual");
+    logger.LogWarn("after_rotation");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(rotated, "RotateLogFiles should succeed");
+    CheckEquals(std::string(": after_rotation\n"), ReadFileText(logFile),
+        "The startup lines are Info lines, so a minimum level above Info should leave them out of a new file too");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_ReconfigureToANewPathStartsWithTheStartupLines()
+{
+    // Arrange
+    const auto firstFile = TestTempDir / "new_reconfigure_first.log";
+    const auto secondFile = TestTempDir / "new_reconfigure_second.log";
+    auto config = MakeNewFileTestConfig(firstFile);
+    const auto firstPath = ASWLog::PathToUTF8String(config.File.ResolvePath());
+
+    ASWLog::TASWFileLog logger;
+    const bool initialized = logger.Initialize(config);
+
+    // Act: a new path, then only File.AutoOpenClosePerWrite, which keeps the file
+    logger.LogInfo("to_first");
+    config.File.FilePath = secondFile;
+    const bool movedToSecond = logger.Reconfigure(config);
+    logger.LogInfo("to_second");
+    config.File.AutoOpenClosePerWrite = true;
+    const bool switchedToAutoOpenClose = logger.Reconfigure(config);
+    logger.LogInfo("auto_open_close");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(movedToSecond, "Reconfigure() to a new file path should succeed");
+    CheckTrue(switchedToAutoOpenClose, "Reconfigure() to File.AutoOpenClosePerWrite should succeed");
+    CheckEquals(std::string(": banner\n: to_first\n"), ReadFileText(firstFile), "The first file should end as it was");
+    CheckEquals(std::format(": Log continued from {} (reconfigure)\n: banner\n: to_second\n: auto_open_close\n", firstPath),
+        ReadFileText(secondFile), "The new file should start with the startup lines, naming the previous file's path, and only once");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_RotationWaitsUntilTheStartupLinesAreWritten()
+{
+    // Arrange: the banner alone reaches the 50-byte limit, so each block of startup lines is longer than the limit
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_guard.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.EnableRotation = true;
+    config.File.MaxFileSizeBytes = 50;
+    config.Startup.Banner = "banner_long_enough_to_reach_the_size_limit_on_its_own";
+    config.Startup.WriteLoggerVersion = true;
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 15 } + 10h + 30min + 5s + 250ms;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("entry");
+    logger.Close();
+
+    // Assert
+    const auto startupLines = std::format(": {}\n: ASWLog: version={}, logger=TASWFileLog\n", config.Startup.Banner, ASWLog::Version);
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(1, CountFilesStartingWith("new_guard.size."), "Only the entry should rotate the log, not a startup line");
+    CheckEquals(startupLines, ReadFileText(TestTempDir / "new_guard.size.2026-01-15_103005_250.bak"),
+        "Initialize()'s startup lines should stay together in the first file");
+    CheckEquals(": Log continued from new_guard.size.2026-01-15_103005_250.bak (size)\n" + startupLines + ": entry\n",
+        ReadFileText(logFile), "The new file's startup lines should stay together, followed by the entry");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_SharedLogGetsTheStartupLinesOnce()
+{
+    // Arrange: two loggers sharing one log, as two processes would (File.AutoOpenClosePerWrite), both logging at 23:59 UTC
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_shared.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.EnableDailyRolling = true;
+    config.File.AutoOpenClosePerWrite = true;
+
+    const auto dayOne = std::chrono::sys_days{ 2026y / 1 / 15 };
+    TFixedClockFileLog firstLogger;
+    TFixedClockFileLog secondLogger;
+    firstLogger.CurrentTime = dayOne + 23h + 59min;
+    secondLogger.CurrentTime = dayOne + 23h + 59min;
+
+    const bool firstInitialized = firstLogger.Initialize(config);
+    const bool secondInitialized = secondLogger.Initialize(config);
+    firstLogger.LogInfo("first_day_one_entry");
+    secondLogger.LogInfo("second_day_one_entry");
+
+    // The file was written at 23:59; make its age match the clocks' jump past midnight below
+    std::filesystem::last_write_time(logFile, std::chrono::file_clock::now() - 2min);
+    firstLogger.CurrentTime = dayOne + 24h + 30s;
+    secondLogger.CurrentTime = dayOne + 24h + 40s;
+
+    // Act: the first logger rolls the log over; the second then finds a log from today
+    firstLogger.LogInfo("first_day_two_entry");
+    secondLogger.LogInfo("second_day_two_entry");
+    firstLogger.Close();
+    secondLogger.Close();
+
+    // Assert
+    CheckTrue(firstInitialized && secondInitialized, "Initialize should succeed");
+    CheckEquals(std::string(": Log continued from new_shared.daily.2026-01-15.bak (daily)\n: banner\n: first_day_two_entry\n: second_day_two_entry\n"),
+        ReadFileText(logFile), "Only the logger that rolled the shared log over should write the startup lines");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_SizeRotationStartsWithTheStartupLines()
+{
+    // Arrange: Initialize()'s lines and the first entry reach the 100-byte limit, so the second entry rotates the log
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_size.log";
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.EnableRotation = true;
+    config.File.MaxFileSizeBytes = 100;
+    config.Startup.WriteLoggerVersion = true;
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 15 } + 10h + 30min + 5s + 250ms;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("first_entry_long_enough_to_reach_the_size_limit");
+    logger.LogInfo("second_entry");
+    logger.Close();
+
+    // Assert
+    const auto startupLines = std::format(": banner\n: ASWLog: version={}, logger=TASWFileLog\n", ASWLog::Version);
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckEquals(startupLines + ": first_entry_long_enough_to_reach_the_size_limit\n",
+        ReadFileText(TestTempDir / "new_size.size.2026-01-15_103005_250.bak"), "The backup should hold the first file as it was");
+    CheckEquals(": Log continued from new_size.size.2026-01-15_103005_250.bak (size)\n" + startupLines + ": second_entry\n",
+        ReadFileText(logFile), "The new file should start with the continuation line and the startup lines, before the entry that rotated the log");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_NewFile_UnopenedFileGetsTheStartupLinesWhenItOpens()
+{
+    // Arrange: a "folder" that is a file can't hold the new log, on any OS and for any user
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "new_unopened.log";
+    const auto laterFolder = TestTempDir / "later_folder";
+    std::ofstream(laterFolder) << "file";
+
+    auto config = MakeNewFileTestConfig(logFile);
+    config.File.CircuitBreakerResetDelay = 0ms;
+    config.OnError = IgnoreError;
+    const auto firstPath = ASWLog::PathToUTF8String(config.File.ResolvePath());
+
+    auto laterConfig = config;
+    laterConfig.File.FilePath = laterFolder / "later.log";
+
+    ASWLog::TASWFileLog logger;
+    const bool initialized = logger.Initialize(config);
+
+    // Act: the new file can't be opened at first; once its folder can be made, the next entry opens it
+    const bool reconfigured = logger.Reconfigure(laterConfig);
+    logger.LogInfo("dropped");
+    std::filesystem::remove(laterFolder);
+    logger.LogInfo("written");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckFalse(reconfigured, "Reconfigure() should fail while the new file can't be opened");
+    CheckEquals(std::format(": Log continued from {} (reconfigure)\n: banner\n: written\n", firstPath),
+        ReadFileText(laterFolder / "later.log"), "The open that succeeds should write the startup lines, before its entry");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_OnBackupCreated_IsNotCalledWhenRotationFails()
 {
     // Arrange
diff --git a/tests/tests/Test_ASWLog_FileLog.h b/tests/tests/Test_ASWLog_FileLog.h
index c18e7ba..d7d1d7e 100644
--- a/tests/tests/Test_ASWLog_FileLog.h
+++ b/tests/tests/Test_ASWLog_FileLog.h
@@ -77,6 +77,17 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_LogRawOptions();
     void Test_MultiThreadedStress_WritesAllMessagesToDisk();
     void Test_MultiThreadedStress_WritesAllMessagesToDisk_OpenClose();
+    void Test_NewFile_AsyncWorkerWritesTheStartupLinesBeforeTheEntry();
+    void Test_NewFile_DailyRollingStartsWithTheStartupLines();
+    void Test_NewFile_FailedRotationWritesNoStartupLines();
+    void Test_NewFile_InitializeWritesItsStartupLinesOnce();
+    void Test_NewFile_ManualRotationOpensASharedLogForTheStartupLines();
+    void Test_NewFile_MinimumLevelAboveInfoLeavesOutTheStartupLines();
+    void Test_NewFile_ReconfigureToANewPathStartsWithTheStartupLines();
+    void Test_NewFile_RotationWaitsUntilTheStartupLinesAreWritten();
+    void Test_NewFile_SharedLogGetsTheStartupLinesOnce();
+    void Test_NewFile_SizeRotationStartsWithTheStartupLines();
+    void Test_NewFile_UnopenedFileGetsTheStartupLinesWhenItOpens();
     void Test_OnBackupCreated_IsNotCalledWhenRotationFails();
     void Test_OnBackupCreated_LeavesARenamedBackupToTheApp();
     void Test_OnBackupCreated_ReportsDailyBackupAtInitialize();

From 86d2fa34e773089963d1f7c68f7e188e2bf987e0 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 23:18:44 -0700
Subject: [PATCH 29/38] Test that DeleteOldLogs deletes only matching files

---
 tests/tests/Test_ASWLog_FileLog.cpp | 22 ++++++++++++++++++++++
 tests/tests/Test_ASWLog_FileLog.h   |  1 +
 tests/tests/Test_ASWLog_Utils.cpp   |  5 +++++
 3 files changed, 28 insertions(+)

diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index 1e64720..6c5e6d2 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -385,6 +385,7 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_DailyRolling_SharedLogRollsOverOnce, "DailyRolling_SharedLogRollsOverOnce");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_AcceptsShortRelativeFolder, "DeleteOldLogs_AcceptsShortRelativeFolder");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_EmptyPatternDeletesNothing, "DeleteOldLogs_EmptyPatternDeletesNothing");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_KeepsNonMatchingFilesAndSubfolders, "DeleteOldLogs_KeepsNonMatchingFilesAndSubfolders");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_MatchesNonASCIIFileNames, "DeleteOldLogs_MatchesNonASCIIFileNames");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_RemovesOldFiles, "DeleteOldLogs_RemovesOldFiles");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FailedReopen_RetriesAndResumesLogging, "FailedReopen_RetriesAndResumesLogging");
@@ -1159,6 +1160,27 @@ void TTest_ASWLog_FileLog::Test_DeleteOldLogs_EmptyPatternDeletesNothing()
     CheckFalse(std::filesystem::exists(oldFile), "The \"*\" pattern should remove the old file");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_DeleteOldLogs_KeepsNonMatchingFilesAndSubfolders()
+{
+    // Arrange: an empty subfolder whose name matches the pattern, besides a matching and a non-matching file
+    const auto matchingFile = TestTempDir / "old_example.log";
+    const auto otherFile = TestTempDir / "old_example.txt";
+    const auto subfolder = TestTempDir / "sub_example.log";
+    std::ofstream(matchingFile) << "old";
+    std::ofstream(otherFile) << "old";
+    std::filesystem::create_directory(subfolder);
+
+    // Act: a negative age puts the cutoff an hour from now, so every entry counts as old, also the subfolder (Windows
+    // can't set a folder's last write time through std::filesystem)
+    const auto deletedCount = ASWLog::TASWFileLog::DeleteOldLogs(TestTempDir, "*example.log", std::chrono::hours(-1));
+
+    // Assert
+    CheckEquals(1, deletedCount, "DeleteOldLogs should delete only the old file matching the pattern");
+    CheckFalse(std::filesystem::exists(matchingFile), "The old file matching the pattern should be deleted");
+    CheckTrue(std::filesystem::exists(otherFile), "An old file that doesn't match the pattern should be kept");
+    CheckTrue(std::filesystem::is_directory(subfolder), "A subfolder should be kept, even if its name matches the pattern");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_DeleteOldLogs_MatchesNonASCIIFileNames()
 {
     // Arrange: a file name with a character outside the Windows ANSI code page (Greek small lambda, U+03BB, which is
diff --git a/tests/tests/Test_ASWLog_FileLog.h b/tests/tests/Test_ASWLog_FileLog.h
index d7d1d7e..fd7ca6a 100644
--- a/tests/tests/Test_ASWLog_FileLog.h
+++ b/tests/tests/Test_ASWLog_FileLog.h
@@ -57,6 +57,7 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_DailyRolling_SharedLogRollsOverOnce();
     void Test_DeleteOldLogs_AcceptsShortRelativeFolder();
     void Test_DeleteOldLogs_EmptyPatternDeletesNothing();
+    void Test_DeleteOldLogs_KeepsNonMatchingFilesAndSubfolders();
     void Test_DeleteOldLogs_MatchesNonASCIIFileNames();
     void Test_DeleteOldLogs_RemovesOldFiles();
     void Test_FailedReopen_RetriesAndResumesLogging();
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index ecff156..5f03940 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -686,6 +686,11 @@ void TTest_ASWLog_Utils::Test_MatchesWildcard_Patterns()
     CheckTrue(ASWLog::MatchesWildcard(fileName2, "n?tes.*"), "Question mark wildcard should match a single character");
     CheckFalse(ASWLog::MatchesWildcard(fileName, "*.txt"), "Wildcard should reject non-matching files");
     CheckTrue(ASWLog::MatchesWildcard("no_extension", "*"), "A lone '*' should match any name, with or without a dot");
+    CheckFalse(ASWLog::MatchesWildcard(fileName, "app_123.txt"), "A pattern without wildcards should reject a different name");
+    CheckFalse(ASWLog::MatchesWildcard(fileName, "app_123.lo"), "A pattern without wildcards should reject a name that goes on past it");
+    CheckFalse(ASWLog::MatchesWildcard(fileName, "app_123.log.bak"), "A pattern without wildcards should reject a name that ends before it");
+    CheckTrue(ASWLog::MatchesWildcard(fileName, "app_123.log**"), "Trailing '*'s should also match nothing");
+    CheckFalse(ASWLog::MatchesWildcard("", "?"), "'?' should need a character");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_ReadEnvironmentVariable_ReadsUTF8Values()

From dc95cf9055f5f73d77727a7f881bab56d6e03958 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 23:26:32 -0700
Subject: [PATCH 30/38] Test backup name exhaustion and open retries

---
 tests/tests/Test_ASWLog_FileLog.cpp | 95 +++++++++++++++++++++++++++++
 tests/tests/Test_ASWLog_FileLog.h   |  3 +
 2 files changed, 98 insertions(+)

diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index 6c5e6d2..1305dc9 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -388,6 +388,7 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_KeepsNonMatchingFilesAndSubfolders, "DeleteOldLogs_KeepsNonMatchingFilesAndSubfolders");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_MatchesNonASCIIFileNames, "DeleteOldLogs_MatchesNonASCIIFileNames");
     RegisterTest(&TTest_ASWLog_FileLog::Test_DeleteOldLogs_RemovesOldFiles, "DeleteOldLogs_RemovesOldFiles");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_FailedOpen_TriesOpenRetryCountTimes, "FailedOpen_TriesOpenRetryCountTimes");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FailedReopen_RetriesAndResumesLogging, "FailedReopen_RetriesAndResumesLogging");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FailedReopen_ZeroResetDelayRetriesOnNextWrite, "FailedReopen_ZeroResetDelayRetriesOnNextWrite");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FailedSizeRotation_WaitsBeforeRetrying, "FailedSizeRotation_WaitsBeforeRetrying");
@@ -430,6 +431,7 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_OnError_ReportsFullDisk, "OnError_ReportsFullDisk");
     RegisterTest(&TTest_ASWLog_FileLog::Test_OnLogEntry_FiresForQualifyingLevelsOnly, "OnLogEntry_FiresForQualifyingLevelsOnly");
     RegisterTest(&TTest_ASWLog_FileLog::Test_OnLogEntry_ReentrantCallbackDoesNotDeadlock, "OnLogEntry_ReentrantCallbackDoesNotDeadlock");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_Open_KeepsAnOpenFile, "Open_KeepsAnOpenFile");
     RegisterTest(&TTest_ASWLog_FileLog::Test_Periodic_CloseStopsAndOpenRestartsTheThread, "Periodic_CloseStopsAndOpenRestartsTheThread");
     RegisterTest(&TTest_ASWLog_FileLog::Test_Periodic_CloseStopsTheThreadWithoutWaitingForTheInterval, "Periodic_CloseStopsTheThreadWithoutWaitingForTheInterval");
     RegisterTest(&TTest_ASWLog_FileLog::Test_Periodic_ConcurrentLoggingAndReconfigure, "Periodic_ConcurrentLoggingAndReconfigure");
@@ -444,6 +446,7 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_Reconfigure_UnopenableFileFailsButLoggerStaysInitialized, "Reconfigure_UnopenableFileFailsButLoggerStaysInitialized");
     RegisterTest(&TTest_ASWLog_FileLog::Test_RetentionMaxAge_DefaultDisabledPreservesOldBackups, "RetentionMaxAge_DefaultDisabledPreservesOldBackups");
     RegisterTest(&TTest_ASWLog_FileLog::Test_RetentionMaxAge_DeletesExpiredBackupsAfterRotation, "RetentionMaxAge_DeletesExpiredBackupsAfterRotation");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_RotateLogFiles_FailsWhenEveryBackupNameIsTaken, "RotateLogFiles_FailsWhenEveryBackupNameIsTaken");
     RegisterTest(&TTest_ASWLog_FileLog::Test_RotateLogFiles_KeepsEveryBackup, "RotateLogFiles_KeepsEveryBackup");
     RegisterTest(&TTest_ASWLog_FileLog::Test_RotateLogFiles_NamesBackupInLocalTime, "RotateLogFiles_NamesBackupInLocalTime");
     RegisterTest(&TTest_ASWLog_FileLog::Test_SetEnabled_FalseStopsAutoOpenCloseLogging, "SetEnabled_FalseStopsAutoOpenCloseLogging");
@@ -1240,6 +1243,34 @@ void TTest_ASWLog_FileLog::Test_DeleteOldLogs_RemovesOldFiles()
     CheckTrue(std::filesystem::exists(newFile), "Recent log file should remain");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_FailedOpen_TriesOpenRetryCountTimes()
+{
+    // Arrange: a "folder" that is a file can't hold the log, on any OS and for any user
+    using namespace std::chrono_literals;
+    const auto notAFolder = TestTempDir / "retry_not_a_folder";
+    std::ofstream(notAFolder) << "file";
+
+    auto config = MakeRotationTestConfig(notAFolder / "unopenable.log");
+    config.File.OpenRetryCount = 3;
+    config.File.OpenRetryDelay = 50ms;
+    std::vector<ASWLog::TASWLogError> reports;
+    config.OnError = [&reports](const ASWLog::TASWLogError& error) {
+            reports.push_back(error);
+        };
+
+    ASWLog::TASWFileLog logger;
+
+    // Act
+    const auto start = std::chrono::steady_clock::now();
+    const bool initialized = logger.Initialize(config);
+    const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start);
+
+    // Assert: three tries, with File.OpenRetryDelay between them
+    CheckFalse(initialized, "Initialize should fail");
+    CheckGreaterThanOrEqual(elapsed.count(), 100, "Each try after the first should wait File.OpenRetryDelay");
+    CheckEquals(1, reports.size(), "The failed open should be reported once, after the last try");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_FailedReopen_RetriesAndResumesLogging()
 {
     // Arrange
@@ -2722,6 +2753,29 @@ void TTest_ASWLog_FileLog::Test_OnLogEntry_ReentrantCallbackDoesNotDeadlock()
     CheckContains(contents, "reentrant_message", "Re-entrant Log call from the callback should complete and be written");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_Open_KeepsAnOpenFile()
+{
+    // Arrange
+    const auto logFile = TestTempDir / "open_again.log";
+    const auto config = MakeRotationTestConfig(logFile);
+
+    ASWLog::TASWFileLog logger;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("before_open");
+    const bool opened = logger.Open();
+    const bool openAfterOpen = logger.IsOpen();
+    logger.LogInfo("after_open");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckTrue(opened, "Open() on an open logger should succeed");
+    CheckTrue(openAfterOpen, "The logger should still report open");
+    CheckEquals(std::string(": before_open\n: after_open\n"), ReadFileText(logFile), "The logger should go on writing to its file");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_Periodic_CloseStopsAndOpenRestartsTheThread()
 {
     // Arrange
@@ -3185,6 +3239,47 @@ void TTest_ASWLog_FileLog::Test_RetentionMaxAge_DeletesExpiredBackupsAfterRotati
     CheckTrue(std::filesystem::exists(logFile), "Log file should be recreated after rotation");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_RotateLogFiles_FailsWhenEveryBackupNameIsTaken()
+{
+    // Arrange: every name the rotation could use (the plain one, then "_1" to "_1000") is taken
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "taken.log";
+    auto config = MakeRotationTestConfig(logFile);
+    std::vector<ASWLog::TASWLogError> reports;
+    config.OnError = [&reports](const ASWLog::TASWLogError& error) {
+            reports.push_back(error);
+        };
+
+    const std::string backupName = "taken.manual.2026-01-15_103005_250";
+    std::ofstream(TestTempDir / (backupName + ".bak")) << "kept";
+    for (int suffix = 1; suffix <= 1000; ++suffix)
+        std::ofstream(TestTempDir / std::format("{}_{}.bak", backupName, suffix)) << "kept";
+
+    TFixedClockFileLog logger;
+    logger.CurrentTime = std::chrono::sys_days{ 2026y / 1 / 15 } + 10h + 30min + 5s + 250ms;
+
+    // Act
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("before_rotation");
+    const bool rotated = logger.RotateLogFiles("manual");
+    logger.LogInfo("after_rotation");
+    logger.Close();
+
+    // Assert
+    CheckTrue(initialized, "Initialize should succeed");
+    CheckFalse(rotated, "RotateLogFiles should fail when every backup name is taken");
+    CheckEquals(1, reports.size(), "The failed rotation should be reported");
+    if (reports.size() == 1)
+    {
+        CheckEquals(ASWLog::ErrorKind::RotationFailed, reports[0].Kind, "The failure should be reported as RotationFailed");
+        CheckTrue(reports[0].Code == std::errc::file_exists, "The report should say that the names are taken: " + reports[0].Code.message());
+    }
+
+    CheckEquals(std::string(": before_rotation\n: after_rotation\n"), ReadFileText(logFile), "The log should stay in place and take the next entries");
+    CheckEquals(std::string("kept"), ReadFileText(TestTempDir / (backupName + ".bak")), "The first backup name should not be replaced");
+    CheckEquals(std::string("kept"), ReadFileText(TestTempDir / (backupName + "_1000.bak")), "The last backup name should not be replaced");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_RotateLogFiles_KeepsEveryBackup()
 {
     // Arrange: a fixed clock makes both rotations want the same backup name
diff --git a/tests/tests/Test_ASWLog_FileLog.h b/tests/tests/Test_ASWLog_FileLog.h
index fd7ca6a..1cc715c 100644
--- a/tests/tests/Test_ASWLog_FileLog.h
+++ b/tests/tests/Test_ASWLog_FileLog.h
@@ -60,6 +60,7 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_DeleteOldLogs_KeepsNonMatchingFilesAndSubfolders();
     void Test_DeleteOldLogs_MatchesNonASCIIFileNames();
     void Test_DeleteOldLogs_RemovesOldFiles();
+    void Test_FailedOpen_TriesOpenRetryCountTimes();
     void Test_FailedReopen_RetriesAndResumesLogging();
     void Test_FailedReopen_ZeroResetDelayRetriesOnNextWrite();
     void Test_FailedSizeRotation_WaitsBeforeRetrying();
@@ -102,6 +103,7 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_OnError_ReportsFullDisk();
     void Test_OnLogEntry_FiresForQualifyingLevelsOnly();
     void Test_OnLogEntry_ReentrantCallbackDoesNotDeadlock();
+    void Test_Open_KeepsAnOpenFile();
     void Test_Periodic_CloseStopsAndOpenRestartsTheThread();
     void Test_Periodic_CloseStopsTheThreadWithoutWaitingForTheInterval();
     void Test_Periodic_ConcurrentLoggingAndReconfigure();
@@ -116,6 +118,7 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_Reconfigure_UnopenableFileFailsButLoggerStaysInitialized();
     void Test_RetentionMaxAge_DefaultDisabledPreservesOldBackups();
     void Test_RetentionMaxAge_DeletesExpiredBackupsAfterRotation();
+    void Test_RotateLogFiles_FailsWhenEveryBackupNameIsTaken();
     void Test_RotateLogFiles_KeepsEveryBackup();
     void Test_RotateLogFiles_NamesBackupInLocalTime();
     void Test_SetEnabled_FalseStopsAutoOpenCloseLogging();

From ce50957095696439b85b8903cd4f963ae3963f5c Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 23:33:41 -0700
Subject: [PATCH 31/38] Test TASWFileStream's stream insertion

---
 tests/tests/Test_ASWLog_FileLog.cpp | 41 +++++++++++++++++++++++++++++
 tests/tests/Test_ASWLog_FileLog.h   |  2 ++
 2 files changed, 43 insertions(+)

diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index 1305dc9..4bf6b53 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -393,6 +393,8 @@ TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     RegisterTest(&TTest_ASWLog_FileLog::Test_FailedReopen_ZeroResetDelayRetriesOnNextWrite, "FailedReopen_ZeroResetDelayRetriesOnNextWrite");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FailedSizeRotation_WaitsBeforeRetrying, "FailedSizeRotation_WaitsBeforeRetrying");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FileStream_FlushWorksAfterFailedWrite, "FileStream_FlushWorksAfterFailedWrite");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_FileStream_InsertionIntoAClosedStreamFails, "FileStream_InsertionIntoAClosedStreamFails");
+    RegisterTest(&TTest_ASWLog_FileLog::Test_FileStream_InsertionWritesAndCountsTheSize, "FileStream_InsertionWritesAndCountsTheSize");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FlushImmediatelyAtLevel_FlushesEntriesAtOrAboveTheLevel, "FlushImmediatelyAtLevel_FlushesEntriesAtOrAboveTheLevel");
     RegisterTest(&TTest_ASWLog_FileLog::Test_FlushImmediatelyAtLevel_OffLeavesFlushingToFlushMode, "FlushImmediatelyAtLevel_OffLeavesFlushingToFlushMode");
     RegisterTest(&TTest_ASWLog_FileLog::Test_Flush_WritesBufferedManualModeEntries, "Flush_WritesBufferedManualModeEntries");
@@ -1430,6 +1432,45 @@ void TTest_ASWLog_FileLog::Test_FileStream_FlushWorksAfterFailedWrite()
     CheckEquals(std::string("buffered"), contents, "Flush should write the buffered data to the file");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_FileStream_InsertionIntoAClosedStreamFails()
+{
+    // Arrange
+    ASWLog::TASWFileStream textStream;
+    ASWLog::TASWFileStream characterStream;
+
+    // Act: a text goes through xsputn(), a single character through overflow()
+    textStream << "text";
+    characterStream.put('x');
+
+    // Assert
+    CheckTrue(textStream.bad(), "Inserting a text into a stream that isn't open should fail");
+    CheckTrue(characterStream.bad(), "Inserting a character into a stream that isn't open should fail");
+    CheckEquals(0, textStream.GetSize() + characterStream.GetSize(), "Nothing should be counted");
+}
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_FileStream_InsertionWritesAndCountsTheSize()
+{
+    // Arrange: a file that already holds 4 bytes
+    const auto file = TestTempDir / "insertion.log";
+    std::ofstream(file, std::ios::binary) << "old\n";
+    ASWLog::TASWFileStream stream;
+    const bool opened = stream.Open(file);
+
+    // Act: a text goes through xsputn(), a single character through overflow()
+    stream << "count=" << 42;
+    stream.put('\n');
+    const bool flushed = stream.Flush();
+    const auto size = stream.GetSize();
+    stream.Close();
+
+    // Assert
+    CheckTrue(opened, "Open should succeed");
+    CheckFalse(stream.fail(), "The insertions should succeed");
+    CheckTrue(flushed, "Flush should succeed");
+    CheckEquals(std::string("old\ncount=42\n"), ReadFileText(file), "operator<< and put() should append to the file");
+    CheckEquals(13, size, "GetSize() should count the file's bytes and every inserted one");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_FlushImmediatelyAtLevel_FlushesEntriesAtOrAboveTheLevel()
 {
     // Arrange: FlushMode::Manual keeps the entries below the level in the file's buffer
diff --git a/tests/tests/Test_ASWLog_FileLog.h b/tests/tests/Test_ASWLog_FileLog.h
index 1cc715c..dcd9dde 100644
--- a/tests/tests/Test_ASWLog_FileLog.h
+++ b/tests/tests/Test_ASWLog_FileLog.h
@@ -65,6 +65,8 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     void Test_FailedReopen_ZeroResetDelayRetriesOnNextWrite();
     void Test_FailedSizeRotation_WaitsBeforeRetrying();
     void Test_FileStream_FlushWorksAfterFailedWrite();
+    void Test_FileStream_InsertionIntoAClosedStreamFails();
+    void Test_FileStream_InsertionWritesAndCountsTheSize();
     void Test_FlushImmediatelyAtLevel_FlushesEntriesAtOrAboveTheLevel();
     void Test_FlushImmediatelyAtLevel_OffLeavesFlushingToFlushMode();
     void Test_Flush_WritesBufferedManualModeEntries();

From 17c92721395126575a83db8036274013f3d6cf75 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 23:39:09 -0700
Subject: [PATCH 32/38] Remove GetApplicationInfoString()

---
 ASWLog/ASWLog_Utils.cpp | 7 -------
 ASWLog/ASWLog_Utils.h   | 1 -
 CHANGELOG.md            | 8 ++++++++
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/ASWLog/ASWLog_Utils.cpp b/ASWLog/ASWLog_Utils.cpp
index 47145c4..9f9ae6a 100644
--- a/ASWLog/ASWLog_Utils.cpp
+++ b/ASWLog/ASWLog_Utils.cpp
@@ -117,13 +117,6 @@ std::string GenerateLogFileName(std::string_view prefix, std::string_view custom
     return name;
 }
 
-//---------------------------------------------------------------------------
-std::string GetApplicationInfoString()
-{
-    auto exePath = GetExecutablePath();
-    return std::format("application_exe='{}', command_line='{}'", PathToUTF8String(exePath), GetCommandLineString());
-}
-
 //---------------------------------------------------------------------------
 std::string GetCommandLineString()
 {
diff --git a/ASWLog/ASWLog_Utils.h b/ASWLog/ASWLog_Utils.h
index c30d996..1a7dc25 100644
--- a/ASWLog/ASWLog_Utils.h
+++ b/ASWLog/ASWLog_Utils.h
@@ -76,7 +76,6 @@ struct TSystemMemoryUsage
 */
 [[nodiscard]] std::string GenerateLogFileName(std::string_view prefix, std::string_view customPostfix);
 
-[[nodiscard]] std::string GetApplicationInfoString();
 [[nodiscard]] std::string GetCommandLineString();
 
 // The operating system's id for the current process, as shown by Task Manager, ps, and debuggers.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f58d27a..9d63729 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -295,6 +295,14 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
   custom formatter. A time before 1970 is now written as the day and
   millisecond it falls in, instead of a malformed time.
 
+### Removed
+
+- `GetApplicationInfoString()` (from `ASWLog_Utils.h`). It was an older form
+  of the startup "App:" line and nothing in ASWLog used it. Breaking for code
+  that called it: build the text from `GetExecutablePath()` (with
+  `PathToUTF8String()`) and `GetCommandLineString()`, which it combined as
+  `application_exe='<path>', command_line='<command line>'`.
+
 ## [0.75.0] - 2026-10-06
 
 ### Added

From c5ce37d05531e03bef5c01d58766d96c82c51dc4 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sat, 10 Oct 2026 23:47:35 -0700
Subject: [PATCH 33/38] Test TASWMultiLog's Open() and failing loggers, and
 command line startup option

---
 tests/tests/Test_ASWLog_MultiLog.cpp    | 89 +++++++++++++++++++++++--
 tests/tests/Test_ASWLog_MultiLog.h      |  3 +
 tests/tests/Test_ASWLog_TextLogBase.cpp | 29 ++++++++
 tests/tests/Test_ASWLog_TextLogBase.h   |  1 +
 4 files changed, 118 insertions(+), 4 deletions(-)

diff --git a/tests/tests/Test_ASWLog_MultiLog.cpp b/tests/tests/Test_ASWLog_MultiLog.cpp
index e339dcb..b4b7d7c 100644
--- a/tests/tests/Test_ASWLog_MultiLog.cpp
+++ b/tests/tests/Test_ASWLog_MultiLog.cpp
@@ -103,8 +103,14 @@ class TRecordingLogger final : public ASWLog::TASWLogBase
 public:
     std::vector<std::string> Calls;
     std::vector<ASWLog::TASWLogRecord> Records; // Every field but Message
+    bool CloseResult = true; // Returned by Close()
     bool FlushResult = true; // Returned by Flush()
+    bool InitializeResult = true; // Returned by Initialize()
+    bool IsOpenResult = true; // Returned by IsOpen()
+    bool OpenResult = true; // Returned by Open()
     bool ReconfigureResult = true; // Returned by Reconfigure()
+    int CloseCount = 0; // How often Close() was called
+    int OpenCount = 0; // How often Open() was called
     bool WasInitialized = false; // Initialize() was called
     bool InitializeHadBeforeWrite = false; // The config passed to Initialize() had an OnBeforeWrite hook
 
@@ -112,7 +118,7 @@ class TRecordingLogger final : public ASWLog::TASWLogBase
     {
         WasInitialized = true;
         InitializeHadBeforeWrite = config.OnBeforeWrite != nullptr;
-        return true;
+        return InitializeResult;
     }
 
     bool Reconfigure(const ASWLog::TASWLogConfig& config) noexcept override
@@ -124,12 +130,14 @@ class TRecordingLogger final : public ASWLog::TASWLogBase
 
     bool Open() noexcept override
     {
-        return true;
+        ++OpenCount;
+        return OpenResult;
     }
 
     bool Close() noexcept override
     {
-        return true;
+        ++CloseCount;
+        return CloseResult;
     }
 
     bool Flush() noexcept override
@@ -140,7 +148,7 @@ class TRecordingLogger final : public ASWLog::TASWLogBase
 
     bool IsOpen() const noexcept override
     {
-        return true;
+        return IsOpenResult;
     }
 };
 
@@ -275,6 +283,7 @@ TTest_ASWLog_MultiLog::TTest_ASWLog_MultiLog()
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Backtrace_EachLoggerKeepsItsOwn, "Backtrace_EachLoggerKeepsItsOwn");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Backtrace_IsNotKeptByTheMultiLog, "Backtrace_IsNotKeptByTheMultiLog");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Close_AllowsInitializeAgain, "Close_AllowsInitializeAgain");
+    RegisterTest(&TTest_ASWLog_MultiLog::Test_Close_ReachesEverySinkEvenAfterAFailure, "Close_ReachesEverySinkEvenAfterAFailure");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Contains_ReflectsRegistrationState, "Contains_ReflectsRegistrationState");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_DumpBacktrace_ReachesEverySinkUnlessDisabled, "DumpBacktrace_ReachesEverySinkUnlessDisabled");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Flush_ReachesEverySinkEvenAfterAFailure, "Flush_ReachesEverySinkEvenAfterAFailure");
@@ -284,6 +293,7 @@ TTest_ASWLog_MultiLog::TTest_ASWLog_MultiLog()
     RegisterTest(&TTest_ASWLog_MultiLog::Test_GetLoggerCount_ReflectsAddAndRemove, "GetLoggerCount_ReflectsAddAndRemove");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_GetLoggers_ReturnsSnapshotOfRegisteredSinks, "GetLoggers_ReturnsSnapshotOfRegisteredSinks");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Initialize_ConcurrentCallsSucceedOnce, "Initialize_ConcurrentCallsSucceedOnce");
+    RegisterTest(&TTest_ASWLog_MultiLog::Test_Initialize_FailsOnlyForASinkThatIsNotOpen, "Initialize_FailsOnlyForASinkThatIsNotOpen");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_IsOpen_RequiresAllSinksOpen, "IsOpen_RequiresAllSinksOpen");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Log_AtLevelOffIsNotFannedOut, "Log_AtLevelOffIsNotFannedOut");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Log_FansOutToAllRegisteredSinks, "Log_FansOutToAllRegisteredSinks");
@@ -291,6 +301,7 @@ TTest_ASWLog_MultiLog::TTest_ASWLog_MultiLog()
     RegisterTest(&TTest_ASWLog_MultiLog::Test_LogFmt_FormatsOnceForAllSinks, "LogFmt_FormatsOnceForAllSinks");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_LogForce_BypassesCompositeGate, "LogForce_BypassesCompositeGate");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_OnBeforeWrite_RunsOnceBeforeTheFanOut, "OnBeforeWrite_RunsOnceBeforeTheFanOut");
+    RegisterTest(&TTest_ASWLog_MultiLog::Test_Open_ReachesEverySinkEvenAfterAFailure, "Open_ReachesEverySinkEvenAfterAFailure");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_Reconfigure_PassesConfigToEverySink, "Reconfigure_PassesConfigToEverySink");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_RemoveAllLoggers_ClearsRegistrationAndReturnsCount, "RemoveAllLoggers_ClearsRegistrationAndReturnsCount");
     RegisterTest(&TTest_ASWLog_MultiLog::Test_RemoveLogger_StopsReceivingEntries, "RemoveLogger_StopsReceivingEntries");
@@ -450,6 +461,29 @@ void TTest_ASWLog_MultiLog::Test_Close_AllowsInitializeAgain()
     CheckContains(ReadFileText(fileA), "after_reinitialize", "Initialize after Close should initialize the sinks again");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_MultiLog::Test_Close_ReachesEverySinkEvenAfterAFailure()
+{
+    // Arrange: the first sink's close fails
+    TRecordingLogger failingSink;
+    failingSink.CloseResult = false;
+    TRecordingLogger sink;
+
+    ASWLog::TASWMultiLog multiLog;
+    multiLog.AddLogger(failingSink);
+    multiLog.AddLogger(sink);
+
+    // Act
+    const bool closedWithFailure = multiLog.Close();
+    failingSink.CloseResult = true;
+    const bool closed = multiLog.Close();
+
+    // Assert
+    CheckFalse(closedWithFailure, "Close() should return false if any sink's close fails");
+    CheckTrue(closed, "Close() should return true once every sink's close succeeds");
+    CheckEquals(2, failingSink.CloseCount, "Each Close() should reach the failing sink");
+    CheckEquals(2, sink.CloseCount, "A sink's failed close should not stop the other sinks from being closed");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_MultiLog::Test_Contains_ReflectsRegistrationState()
 {
     // Arrange
@@ -695,6 +729,30 @@ void TTest_ASWLog_MultiLog::Test_Initialize_ConcurrentCallsSucceedOnce()
     CheckEquals(roundCount, roundsWithOneSuccess, "Exactly one of the concurrent Initialize calls should succeed");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_MultiLog::Test_Initialize_FailsOnlyForASinkThatIsNotOpen()
+{
+    // Arrange: the first sink's Initialize() fails, as it does for a logger that is already initialized
+    TRecordingLogger failingSink;
+    failingSink.InitializeResult = false;
+    failingSink.IsOpenResult = false;
+    TRecordingLogger sink;
+
+    ASWLog::TASWMultiLog multiLog;
+    multiLog.AddLogger(failingSink);
+    multiLog.AddLogger(sink);
+
+    // Act: first the sink isn't open, then it is (initialized earlier on its own)
+    const bool initializedWithClosedSink = multiLog.Initialize(ASWLog::TASWLogConfig());
+    multiLog.Close();
+    failingSink.IsOpenResult = true;
+    const bool initializedWithOpenSink = multiLog.Initialize(ASWLog::TASWLogConfig());
+
+    // Assert
+    CheckFalse(initializedWithClosedSink, "Initialize() should return false if a sink fails and isn't open");
+    CheckTrue(initializedWithOpenSink, "A sink that fails Initialize() but is open (initialized already) should count as ready");
+    CheckTrue(sink.WasInitialized, "A sink's failed Initialize() should not stop the other sinks from being initialized");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_MultiLog::Test_IsOpen_RequiresAllSinksOpen()
 {
     // Arrange
@@ -898,6 +956,29 @@ void TTest_ASWLog_MultiLog::Test_OnBeforeWrite_RunsOnceBeforeTheFanOut()
         "A sink's own hook should run after the multi-log's, until the multi-log's Reconfigure() replaces its config");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_MultiLog::Test_Open_ReachesEverySinkEvenAfterAFailure()
+{
+    // Arrange: the first sink's open fails
+    TRecordingLogger failingSink;
+    failingSink.OpenResult = false;
+    TRecordingLogger sink;
+
+    ASWLog::TASWMultiLog multiLog;
+    multiLog.AddLogger(failingSink);
+    multiLog.AddLogger(sink);
+
+    // Act
+    const bool openedWithFailure = multiLog.Open();
+    failingSink.OpenResult = true;
+    const bool opened = multiLog.Open();
+
+    // Assert
+    CheckFalse(openedWithFailure, "Open() should return false if any sink's open fails");
+    CheckTrue(opened, "Open() should return true once every sink's open succeeds");
+    CheckEquals(2, failingSink.OpenCount, "Each Open() should reach the failing sink");
+    CheckEquals(2, sink.OpenCount, "A sink's failed open should not stop the other sinks from being opened");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_MultiLog::Test_Reconfigure_PassesConfigToEverySink()
 {
     // Arrange: the first sink's Reconfigure() fails
diff --git a/tests/tests/Test_ASWLog_MultiLog.h b/tests/tests/Test_ASWLog_MultiLog.h
index 1330f30..f4311a6 100644
--- a/tests/tests/Test_ASWLog_MultiLog.h
+++ b/tests/tests/Test_ASWLog_MultiLog.h
@@ -41,6 +41,7 @@ class TTest_ASWLog_MultiLog : public TTestGroupBase
     void Test_Backtrace_EachLoggerKeepsItsOwn();
     void Test_Backtrace_IsNotKeptByTheMultiLog();
     void Test_Close_AllowsInitializeAgain();
+    void Test_Close_ReachesEverySinkEvenAfterAFailure();
     void Test_Contains_ReflectsRegistrationState();
     void Test_DumpBacktrace_ReachesEverySinkUnlessDisabled();
     void Test_Flush_ReachesEverySinkEvenAfterAFailure();
@@ -50,6 +51,7 @@ class TTest_ASWLog_MultiLog : public TTestGroupBase
     void Test_GetLoggerCount_ReflectsAddAndRemove();
     void Test_GetLoggers_ReturnsSnapshotOfRegisteredSinks();
     void Test_Initialize_ConcurrentCallsSucceedOnce();
+    void Test_Initialize_FailsOnlyForASinkThatIsNotOpen();
     void Test_IsOpen_RequiresAllSinksOpen();
     void Test_Log_AtLevelOffIsNotFannedOut();
     void Test_Log_FansOutToAllRegisteredSinks();
@@ -57,6 +59,7 @@ class TTest_ASWLog_MultiLog : public TTestGroupBase
     void Test_LogFmt_FormatsOnceForAllSinks();
     void Test_LogForce_BypassesCompositeGate();
     void Test_OnBeforeWrite_RunsOnceBeforeTheFanOut();
+    void Test_Open_ReachesEverySinkEvenAfterAFailure();
     void Test_Reconfigure_PassesConfigToEverySink();
     void Test_RemoveAllLoggers_ClearsRegistrationAndReturnsCount();
     void Test_RemoveLogger_StopsReceivingEntries();
diff --git a/tests/tests/Test_ASWLog_TextLogBase.cpp b/tests/tests/Test_ASWLog_TextLogBase.cpp
index 4c16f55..cbe15a7 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.cpp
+++ b/tests/tests/Test_ASWLog_TextLogBase.cpp
@@ -402,6 +402,7 @@ bool WaitUntil(const std::function<bool()>& condition)
 TTest_ASWLog_TextLogBase::TTest_ASWLog_TextLogBase()
     : inherited("ASWLog_TextLogBase_Tests")
 {
+    RegisterTest(&TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheCommandLineWhenAsked, "ApplicationInfo_WritesTheCommandLineWhenAsked");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheConfiguredVersion, "ApplicationInfo_WritesTheConfiguredVersion");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheExecutablesFileVersionByDefault, "ApplicationInfo_WritesTheExecutablesFileVersionByDefault");
     RegisterTest(&TTest_ASWLog_TextLogBase::Test_Async_BacktraceIsTakenWhenTheTriggerIsLogged, "Async_BacktraceIsTakenWhenTheTriggerIsLogged");
@@ -477,6 +478,34 @@ void TTest_ASWLog_TextLogBase::TearDown_Test(ITestCase& testCase)
 
 // /////// Begin tests after this line ///////////////////////
 
+//---------------------------------------------------------------------------
+void TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheCommandLineWhenAsked()
+{
+    // Arrange
+    TMemoryOutput defaultOutput;
+    TMemoryTextLog defaultLog(defaultOutput);
+    TMemoryOutput commandLineOutput;
+    TMemoryTextLog commandLineLog(commandLineOutput);
+    auto config = MakeQuietConfig();
+    config.Startup.WriteApplicationInfo = true;
+    auto commandLineConfig = config;
+    commandLineConfig.Startup.WriteCommandLine = true;
+
+    // Act
+    const bool defaultInitialized = defaultLog.Initialize(config);
+    const bool commandLineInitialized = commandLineLog.Initialize(commandLineConfig);
+
+    // Assert
+    CheckTrue(defaultInitialized && commandLineInitialized, "Initialize should succeed");
+    CheckEquals(1, defaultOutput.Lines.size(), "Initialize should write the App line");
+    CheckEquals(1, commandLineOutput.Lines.size(), "Initialize should write the App line");
+    if (defaultOutput.Lines.size() == 1 && commandLineOutput.Lines.size() == 1)
+    {
+        CheckNotContains(defaultOutput.Lines[0], "command_line=", "By default the App line should leave out the command line");
+        CheckEndsWith(commandLineOutput.Lines[0], std::format(", command_line='{}'\n", ASWLog::GetCommandLineString()),
+            "Startup.WriteCommandLine should add the command line at the end of the App line");
+    }
+}
 //---------------------------------------------------------------------------
 void TTest_ASWLog_TextLogBase::Test_ApplicationInfo_WritesTheConfiguredVersion()
 {
diff --git a/tests/tests/Test_ASWLog_TextLogBase.h b/tests/tests/Test_ASWLog_TextLogBase.h
index d99173c..9bd407c 100644
--- a/tests/tests/Test_ASWLog_TextLogBase.h
+++ b/tests/tests/Test_ASWLog_TextLogBase.h
@@ -36,6 +36,7 @@ class TTest_ASWLog_TextLogBase : public TTestGroupBase
     typedef TTestGroupBase inherited;
 
 private: // Test methods
+    void Test_ApplicationInfo_WritesTheCommandLineWhenAsked();
     void Test_ApplicationInfo_WritesTheConfiguredVersion();
     void Test_ApplicationInfo_WritesTheExecutablesFileVersionByDefault();
     void Test_Async_BacktraceIsTakenWhenTheTriggerIsLogged();

From cc735690902734afe966c8ff5df3ac41a039d537 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sun, 11 Oct 2026 00:06:32 -0700
Subject: [PATCH 34/38] Test the remaining small edge cases

---
 tests/tests/Test_ASWLog_FileLog.cpp   | 42 +++++++++++++++++++++++++++
 tests/tests/Test_ASWLog_FileLog.h     |  1 +
 tests/tests/Test_ASWLog_Formatter.cpp | 19 ++++++++++++
 tests/tests/Test_ASWLog_Formatter.h   |  1 +
 tests/tests/Test_ASWLog_Types.cpp     |  1 +
 tests/tests/Test_ASWLog_Utils.cpp     | 24 +++++++++++++++
 tests/tests/Test_ASWLog_Utils.h       |  1 +
 7 files changed, 89 insertions(+)

diff --git a/tests/tests/Test_ASWLog_FileLog.cpp b/tests/tests/Test_ASWLog_FileLog.cpp
index 4bf6b53..1fbe523 100644
--- a/tests/tests/Test_ASWLog_FileLog.cpp
+++ b/tests/tests/Test_ASWLog_FileLog.cpp
@@ -364,6 +364,7 @@ bool WaitUntil(const std::function<bool()>& condition)
 TTest_ASWLog_FileLog::TTest_ASWLog_FileLog()
     : inherited("ASWLog_FileLog_Tests")
 {
+    RegisterTest(&TTest_ASWLog_FileLog::Test_Async_DropsAnEntryWhileTheFileCantBeOpened, "Async_DropsAnEntryWhileTheFileCantBeOpened");
     RegisterTest(&TTest_ASWLog_FileLog::Test_Async_EntryAtWaitAtLevelIsInTheFileWhenTheCallReturns, "Async_EntryAtWaitAtLevelIsInTheFileWhenTheCallReturns");
     RegisterTest(&TTest_ASWLog_FileLog::Test_Async_EveryWriteFlushesEachBatch, "Async_EveryWriteFlushesEachBatch");
     RegisterTest(&TTest_ASWLog_FileLog::Test_Async_PeriodicFlushesOnTheSameThread, "Async_PeriodicFlushesOnTheSameThread");
@@ -491,6 +492,47 @@ void TTest_ASWLog_FileLog::TearDown_Test(ITestCase& testCase)
 
 // /////// Begin tests after this line ///////////////////////
 
+//---------------------------------------------------------------------------
+void TTest_ASWLog_FileLog::Test_Async_DropsAnEntryWhileTheFileCantBeOpened()
+{
+    // Arrange: a "folder" that is a file can't hold the log, on any OS and for any user
+    using namespace std::chrono_literals;
+    const auto logFile = TestTempDir / "async_dropped.log";
+    const auto notAFolder = TestTempDir / "async_not_a_folder";
+    std::ofstream(notAFolder) << "file";
+
+    // OnLogEntry runs on the logger's thread, which Close() joins before the checks read this
+    std::vector<std::string> callbackMessages;
+    auto config = MakeRotationTestConfig(logFile);
+    config.Async.Enabled = true;
+    config.File.CircuitBreakerResetDelay = 1h; // The logger's thread doesn't try the file again for the entry
+    config.OnError = IgnoreError;
+    config.OnLogEntryMinimumLevel = ASWLog::Level::Info;
+    config.OnLogEntry = [&callbackMessages](const ASWLog::TASWLogRecord& record, std::string_view /*formattedLine*/) {
+            callbackMessages.emplace_back(record.Message);
+        };
+
+    auto unopenableConfig = config;
+    unopenableConfig.File.FilePath = notAFolder / "unopenable.log";
+
+    ASWLog::TASWFileLog logger;
+
+    // Act: Reconfigure() first writes what is queued, so each entry meets the file it was logged for
+    const bool initialized = logger.Initialize(config);
+    logger.LogInfo("before");
+    const bool reconfiguredToUnopenable = logger.Reconfigure(unopenableConfig);
+    logger.LogInfo("dropped");
+    const bool reconfiguredBack = logger.Reconfigure(config);
+    logger.LogInfo("after");
+    logger.Close();
+
+    // Assert
+    const std::vector<std::string> expectedMessages{ "before", "after" };
+    CheckTrue(initialized && reconfiguredBack, "Initialize and the Reconfigure() back should succeed");
+    CheckFalse(reconfiguredToUnopenable, "Reconfigure() to an unopenable file should fail");
+    CheckEquals(std::string(": before\n: after\n"), ReadFileText(logFile), "The queued entry should be dropped while the file can't be opened");
+    CheckTrue(callbackMessages == expectedMessages, "OnLogEntry should be called only for the entries written");
+}
 //---------------------------------------------------------------------------
 void TTest_ASWLog_FileLog::Test_Async_EntryAtWaitAtLevelIsInTheFileWhenTheCallReturns()
 {
diff --git a/tests/tests/Test_ASWLog_FileLog.h b/tests/tests/Test_ASWLog_FileLog.h
index dcd9dde..2bb9021 100644
--- a/tests/tests/Test_ASWLog_FileLog.h
+++ b/tests/tests/Test_ASWLog_FileLog.h
@@ -36,6 +36,7 @@ class TTest_ASWLog_FileLog : public TTestGroupBase
     typedef TTestGroupBase inherited;
 
 private: // Test methods
+    void Test_Async_DropsAnEntryWhileTheFileCantBeOpened();
     void Test_Async_EntryAtWaitAtLevelIsInTheFileWhenTheCallReturns();
     void Test_Async_EveryWriteFlushesEachBatch();
     void Test_Async_PeriodicFlushesOnTheSameThread();
diff --git a/tests/tests/Test_ASWLog_Formatter.cpp b/tests/tests/Test_ASWLog_Formatter.cpp
index dd3f3a7..2d06343 100644
--- a/tests/tests/Test_ASWLog_Formatter.cpp
+++ b/tests/tests/Test_ASWLog_Formatter.cpp
@@ -190,6 +190,7 @@ TTest_ASWLog_Formatter::TTest_ASWLog_Formatter()
     RegisterTest(&TTest_ASWLog_Formatter::Test_Formatter_SharedByTwoLoggers, "Formatter_SharedByTwoLoggers");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_DefaultFields, "JSONFormatter_DefaultFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EachShowOption, "JSONFormatter_EachShowOption");
+    RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EmptyScopeLeavesOutTheFields, "JSONFormatter_EmptyScopeLeavesOutTheFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EntryFields, "JSONFormatter_EntryFields");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_EscapesTheTexts, "JSONFormatter_EscapesTheTexts");
     RegisterTest(&TTest_ASWLog_Formatter::Test_JSONFormatter_FileLoggerWritesJSONLines, "JSONFormatter_FileLoggerWritesJSONLines");
@@ -555,6 +556,24 @@ void TTest_ASWLog_Formatter::Test_JSONFormatter_EachShowOption()
     CheckTrue(IsJSONObjectLine(allLine) && IsJSONObjectLine(memoryLine) && IsJSONObjectLine(noFieldsLine), "Each line should be one JSON object");
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Formatter::Test_JSONFormatter_EmptyScopeLeavesOutTheFields()
+{
+    // Arrange: an entry in a scope without fields
+    const auto config = MakeConfigWithoutFields("unused.log");
+    const ASWLog::TASWLogScope scope{};
+
+    auto record = MakeRecord("msg");
+    record.Scope = &scope;
+
+    const ASWLog::TASWJSONFormatter formatter;
+
+    // Act
+    const auto line = formatter.Format(record, config);
+
+    // Assert
+    CheckEquals(std::string(R"({"message":"msg"})"), line, "A scope without fields should add no \"fields\" object");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Formatter::Test_JSONFormatter_EntryFields()
 {
     // Arrange: a scope and the entry's own fields, which replace the scope's n; a value of each kind, and the doubles
diff --git a/tests/tests/Test_ASWLog_Formatter.h b/tests/tests/Test_ASWLog_Formatter.h
index dcd24f4..5d5c19e 100644
--- a/tests/tests/Test_ASWLog_Formatter.h
+++ b/tests/tests/Test_ASWLog_Formatter.h
@@ -49,6 +49,7 @@ class TTest_ASWLog_Formatter : public TTestGroupBase
     void Test_Formatter_SharedByTwoLoggers();
     void Test_JSONFormatter_DefaultFields();
     void Test_JSONFormatter_EachShowOption();
+    void Test_JSONFormatter_EmptyScopeLeavesOutTheFields();
     void Test_JSONFormatter_EntryFields();
     void Test_JSONFormatter_EscapesTheTexts();
     void Test_JSONFormatter_FileLoggerWritesJSONLines();
diff --git a/tests/tests/Test_ASWLog_Types.cpp b/tests/tests/Test_ASWLog_Types.cpp
index d3950fd..a4bb888 100644
--- a/tests/tests/Test_ASWLog_Types.cpp
+++ b/tests/tests/Test_ASWLog_Types.cpp
@@ -311,6 +311,7 @@ void TTest_ASWLog_Types::Test_LineEnding_FromString()
     CheckEquals(ASWLog::LineEnding::LF, *lf_lower, "lf should map to LF");
     CheckEquals(ASWLog::LineEnding::CRLF, *crlf, "CRLF should map to CRLF");
     CheckEquals(ASWLog::LineEnding::CRLF, *crlfAlias, "WINDOWS should map to CRLF");
+    CheckFalse(ASWLog::LineEnding_FromString("CR").has_value(), "An unknown name should not parse");
 }
 //---------------------------------------------------------------------------
 void TTest_ASWLog_Types::Test_LineEnding_ToString()
diff --git a/tests/tests/Test_ASWLog_Utils.cpp b/tests/tests/Test_ASWLog_Utils.cpp
index 5f03940..dc1229a 100644
--- a/tests/tests/Test_ASWLog_Utils.cpp
+++ b/tests/tests/Test_ASWLog_Utils.cpp
@@ -44,6 +44,8 @@ limitations under the License.
 
 #if defined(_WIN32)
 #include <windows.h>
+#undef min
+#undef max
 #endif
 //---------------------------------------------------------------------------
 #include "ASWUnitTests_Registry.h"
@@ -136,6 +138,7 @@ TTest_ASWLog_Utils::TTest_ASWLog_Utils()
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_CalendarEdges, "Time_WriteISO8601_CalendarEdges");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_LocalTimeWithEachPrecision, "Time_WriteISO8601_LocalTimeWithEachPrecision");
     RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision, "Time_WriteISO8601_UTCWithEachPrecision");
+    RegisterTest(&TTest_ASWLog_Utils::Test_Time_WriteISO8601_YearPast9999IsWrittenInFull, "Time_WriteISO8601_YearPast9999IsWrittenInFull");
     RegisterTest(&TTest_ASWLog_Utils::Test_TrimSpaces_RemovesOuterSpacesAndTabs, "TrimSpaces_RemovesOuterSpacesAndTabs");
 }
 //---------------------------------------------------------------------------
@@ -938,6 +941,27 @@ void TTest_ASWLog_Utils::Test_Time_WriteISO8601_UTCWithEachPrecision()
     }
 }
 //---------------------------------------------------------------------------
+void TTest_ASWLog_Utils::Test_Time_WriteISO8601_YearPast9999IsWrittenInFull()
+{
+    // Arrange: libstdc++'s system_clock counts nanoseconds, which end in 2262; libc++'s microseconds and MSVC's 100 ns
+    // ticks reach far past 9999. Compared in days, since converting the year to the clock's ticks could overflow.
+    using namespace std::chrono;
+    using namespace std::chrono_literals;
+    const sys_days firstDay{ 10000y / 1 / 1 };
+    if (floor<days>(system_clock::time_point::max()) <= firstDay)
+        Skip("This standard library's system_clock ends before the year 10000");
+
+    // Cast first: libc++ on Windows keeps minutes in a 32-bit long, so firstDay + 2min would overflow
+    const auto time = time_point_cast<system_clock::duration>(firstDay) + 1h + 2min + 3s + 4ms;
+
+    // Act
+    char buffer[ASWLog::Time::ISO8601BufferSize];
+    const auto size = ASWLog::Time::WriteISO8601(buffer, time);
+
+    // Assert
+    CheckEquals(std::string("10000-01-01T01:02:03.004Z"), std::string(buffer, size), "A year past 9999 should be written in full");
+}
+//---------------------------------------------------------------------------
 void TTest_ASWLog_Utils::Test_TrimSpaces_RemovesOuterSpacesAndTabs()
 {
     // Arrange / Act / Assert
diff --git a/tests/tests/Test_ASWLog_Utils.h b/tests/tests/Test_ASWLog_Utils.h
index 0e2af6f..0b9b2ad 100644
--- a/tests/tests/Test_ASWLog_Utils.h
+++ b/tests/tests/Test_ASWLog_Utils.h
@@ -67,6 +67,7 @@ class TTest_ASWLog_Utils : public TTestGroupBase
     void Test_Time_WriteISO8601_CalendarEdges();
     void Test_Time_WriteISO8601_LocalTimeWithEachPrecision();
     void Test_Time_WriteISO8601_UTCWithEachPrecision();
+    void Test_Time_WriteISO8601_YearPast9999IsWrittenInFull();
     void Test_TrimSpaces_RemovesOuterSpacesAndTabs();
 
 public:

From f17a469a1166fb9d0a1c5784dc8667770c27c933 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sun, 11 Oct 2026 00:18:01 -0700
Subject: [PATCH 35/38] Add a coverage job to CI

---
 .github/workflows/ci.yml | 54 ++++++++++++++++++++++++++++++++++++++++
 AGENTS.md                |  2 +-
 README.md                |  4 +++
 3 files changed, 59 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 44a97dd..d59c7d9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -202,3 +202,57 @@ jobs:
             cmake --build build-package --config "$config"
             ctest --test-dir build-package -C "$config" --output-on-failure
           done
+
+  coverage:
+    # Which lines of the library (ASWLog/) the tests run, on Linux: a table on this job's summary page, and an HTML
+    # report (each source line marked) as an artifact. Informational: continue-on-error keeps it from failing the run;
+    # the jobs above are the ones that must pass.
+    name: Linux (GCC, coverage)
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    continue-on-error: true
+    env:
+      CMAKE_BUILD_PARALLEL_LEVEL: 4
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v7
+        with:
+          submodules: true
+
+      - name: Configure
+        # Debug (no optimization), so each line is counted as written. -fprofile-update=atomic keeps the counts right
+        # in the tests that log from several threads at once; without it the threads' updates race and get lost.
+        env:
+          CC: gcc
+          CXX: g++
+          CXXFLAGS: "--coverage -fprofile-update=atomic"
+        run: cmake -S tests/cmake -B build -DCMAKE_BUILD_TYPE=Debug
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Run unit tests
+        # A failing test fails the jobs above; the coverage of this run is still worth reporting
+        continue-on-error: true
+        run: ./build/bin/ASWLogTests --test-timeout-seconds 120 --catch-crashes
+
+      - name: Install gcovr
+        # 8.4 added the Markdown report. pipx installs it in an environment of its own (the runner's system Python
+        # refuses pip installs).
+        run: pipx install "gcovr>=8.4"
+
+      - name: Coverage report
+        # The crash handlers' tests crash child processes, which end before they can write their counts, so the crash
+        # paths show as not run.
+        run: |
+          mkdir -p coverage-html
+          gcovr --root . --filter 'ASWLog/' --print-summary --markdown coverage.md \
+            --html-details coverage-html/index.html
+          cat coverage.md >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v7
+        with:
+          name: coverage-report
+          path: coverage-html/
+          if-no-files-found: error
diff --git a/AGENTS.md b/AGENTS.md
index 670ad39..e219277 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -12,7 +12,7 @@ ASWLog is a thread-safe, dependency-free C++20 logging library for Windows and L
 - `tests/` contains the unit tests: test modules (`Test_ASWLog_<Unit>`, the tests of `ASWLog_<Unit>`) and shared test helpers (`UT_Helper_<Topic>`, e.g. `UT_Helper_DateTime`) in `tests/tests/`, their CMake project in `tests/cmake/`, their RAD Studio console project in `tests/rad370/`, and their RAD Studio VCL GUI runner project in `tests/vcl/gui/rad370/` (built from the submodule's `vcl/gui/src`). `tests/compile_checks/` holds "must not compile" checks, which `tests/cmake/CMakeLists.txt` runs with `try_compile` when configuring (a failed check stops the configure). `tests/package/` is a project that builds against an installed ASWLog with `find_package` (CI installs the library and runs it).
 - `CMakeLists.txt` (the root) defines the `ASWLog::ASWLog` library target and its install rules; `cmake/ASWLogConfig.cmake.in` is the template of the installed package file. The project version is read from `ASWLog/ASWLog_Version.h`.
 - `third_party/asw-unit-tests/` is the ASWUnitTests framework, a git submodule pinned to a release tag. Never edit files in it; test modules self-register with `ASW_REGISTER_TEST_GROUP`, so adding a test only touches `tests/` and its build files.
-- `.github/workflows/ci.yml` builds and runs the unit tests on Windows (MSVC, MinGW) and Linux (GCC, Clang), plus Linux Clang builds with ThreadSanitizer and with AddressSanitizer + UBSan (`ASWLOG_SANITIZE`); the non-sanitizer jobs also check the installed CMake package (`tests/package/`).
+- `.github/workflows/ci.yml` builds and runs the unit tests on Windows (MSVC, MinGW) and Linux (GCC, Clang), plus Linux Clang builds with ThreadSanitizer and with AddressSanitizer + UBSan (`ASWLOG_SANITIZE`); the non-sanitizer jobs also check the installed CMake package (`tests/package/`). A Linux GCC coverage job (informational, it never fails the run) shows the library's line coverage on its summary page and uploads an HTML report.
 - `example/` contains example app that uses the logger.
 - `example/rad370/` contains the RAD Studio 13.1 project and Windows build scripts.
 - `README.md` contains repo details: features, quick start, project setup, API overview, versions and tests.
diff --git a/README.md b/README.md
index f1c919d..2bfd6bc 100644
--- a/README.md
+++ b/README.md
@@ -323,6 +323,10 @@ cmake --build tests/cmake/build-tsan
 
 CI runs both with Clang. `ASWLOG_SANITIZE` applies to the library and everything that links to it.
 
+CI also measures which lines of the library the tests run (a Linux GCC build with `--coverage`, read by gcovr): the
+"Linux (GCC, coverage)" job shows a table on its summary page and keeps an HTML report as the `coverage-report`
+artifact. It is informational and never fails the run.
+
 On Windows with RAD Studio, the tests can also run in the ASWUnitTests VCL GUI runner, a window for choosing tests and
 reading their results: build `tests/vcl/gui/rad370/ASWLogTests_VCL_GUI.cbproj` (or its `Build_Win64x_*.bat` scripts),
 which writes `ASWLogTests_VCL_GUI.exe` to `tests/build/bin/<Config>`. `ASWLogTests_Group.groupproj` in the same folder

From 5d9f8ce0dde3c04e9b16dcbfec435ecaee877fb9 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sun, 11 Oct 2026 00:59:36 -0700
Subject: [PATCH 36/38] Bump version to 1.0.0-dev.1

---
 ASWLog/ASWLog_Version.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/ASWLog/ASWLog_Version.h b/ASWLog/ASWLog_Version.h
index cb787d0..14f7a6f 100644
--- a/ASWLog/ASWLog_Version.h
+++ b/ASWLog/ASWLog_Version.h
@@ -36,11 +36,11 @@ limitations under the License.
 // pre-release such as "dev.1", which comes before that release in version order (e.g. 1.1.0-dev.1 < 1.1.0).
 // ASWLOG_VERSION_STRING is "MAJOR.MINOR.PATCH", followed by "-PRERELEASE" if the pre-release isn't empty; change
 // them together (a unit test checks that they match).
-#define ASWLOG_VERSION_MAJOR 0
-#define ASWLOG_VERSION_MINOR 85
+#define ASWLOG_VERSION_MAJOR 1
+#define ASWLOG_VERSION_MINOR 0
 #define ASWLOG_VERSION_PATCH 0
-#define ASWLOG_VERSION_PRERELEASE "dev.3"
-#define ASWLOG_VERSION_STRING "0.85.0-dev.3"
+#define ASWLOG_VERSION_PRERELEASE "dev.1"
+#define ASWLOG_VERSION_STRING "1.0.0-dev.1"
 
 namespace ASWLog
 {

From 42fb41efc4b5fe2e48a9760b6573b8268b4bc9f5 Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sun, 11 Oct 2026 01:01:18 -0700
Subject: [PATCH 37/38] Bump version to 1.0.0

---
 ASWLog/ASWLog_Version.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ASWLog/ASWLog_Version.h b/ASWLog/ASWLog_Version.h
index 14f7a6f..85bfb19 100644
--- a/ASWLog/ASWLog_Version.h
+++ b/ASWLog/ASWLog_Version.h
@@ -39,8 +39,8 @@ limitations under the License.
 #define ASWLOG_VERSION_MAJOR 1
 #define ASWLOG_VERSION_MINOR 0
 #define ASWLOG_VERSION_PATCH 0
-#define ASWLOG_VERSION_PRERELEASE "dev.1"
-#define ASWLOG_VERSION_STRING "1.0.0-dev.1"
+#define ASWLOG_VERSION_PRERELEASE ""
+#define ASWLOG_VERSION_STRING "1.0.0"
 
 namespace ASWLog
 {

From c545074a7d254db5a196d6b7aeb7d190d6c1341b Mon Sep 17 00:00:00 2001
From: Anthony West <anthony.s.west@gmail.com>
Date: Sun, 11 Oct 2026 01:05:02 -0700
Subject: [PATCH 38/38] Roll up the CHANGELOG for 1.0.0 and update README

---
 CHANGELOG.md | 5 ++++-
 README.md    | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9d63729..8b1b5a9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,8 @@ see [0.26.1](#0261---2026-09-17) for the initial versioned baseline.
 
 ## [Unreleased]
 
+## [1.0.0] - 2026-10-11
+
 ### Added
 
 - Local-time and finer timestamps: `Line.TimestampZone` (`TimeZone::UTC`,
@@ -929,7 +931,8 @@ Everything already present in the logger at this point (`TASWFileLog`,
 and CMake example projects, unit tests, `Deploy.bat`, etc.) is treated as the
 baseline and is not itemized commit-by-commit.
 
-[Unreleased]: https://github.com/ASWSoftware/asw-log/compare/v0.75.0...HEAD
+[Unreleased]: https://github.com/ASWSoftware/asw-log/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/ASWSoftware/asw-log/compare/v0.75.0...v1.0.0
 [0.75.0]: https://github.com/ASWSoftware/asw-log/compare/v0.66.0...v0.75.0
 [0.66.0]: https://github.com/ASWSoftware/asw-log/compare/v0.65.0...v0.66.0
 [0.65.0]: https://github.com/ASWSoftware/asw-log/compare/v0.45.0...v0.65.0
diff --git a/README.md b/README.md
index 2bfd6bc..b978718 100644
--- a/README.md
+++ b/README.md
@@ -162,7 +162,7 @@ or let CMake download it with `FetchContent`:
 include(FetchContent)
 FetchContent_Declare(ASWLog
     GIT_REPOSITORY https://github.com/ASWSoftware/asw-log.git
-    GIT_TAG v0.75.0     # A release tag, 0.45.0 or later
+    GIT_TAG v1.0.0      # A release tag
     GIT_SUBMODULES ""   # Skip the unit-test framework submodule
 )
 FetchContent_MakeAvailable(ASWLog)