diff --git a/.github/workflows/ci-build-windows.yml b/.github/workflows/ci-build-windows.yml
index 31e8b9e44..a00f75925 100644
--- a/.github/workflows/ci-build-windows.yml
+++ b/.github/workflows/ci-build-windows.yml
@@ -34,6 +34,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Setup .NET
         uses: actions/setup-dotnet@v5
@@ -73,6 +74,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Setup .NET
         uses: actions/setup-dotnet@v5
@@ -116,6 +118,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Setup .NET
         uses: actions/setup-dotnet@v5
diff --git a/.github/workflows/ci-linux-dev.yml b/.github/workflows/ci-linux-dev.yml
index 649e3166d..057ed08a5 100644
--- a/.github/workflows/ci-linux-dev.yml
+++ b/.github/workflows/ci-linux-dev.yml
@@ -27,6 +27,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
@@ -60,6 +61,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
@@ -89,6 +91,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
diff --git a/.github/workflows/ci-linux-main.yml b/.github/workflows/ci-linux-main.yml
index 8ee8a23e6..8eae0a8ee 100644
--- a/.github/workflows/ci-linux-main.yml
+++ b/.github/workflows/ci-linux-main.yml
@@ -47,6 +47,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
@@ -81,6 +82,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
@@ -100,29 +102,6 @@ jobs:
           bash ./tools/ci/clang_tidy.sh build
           "
 
-  cargo-log-server:
-    name: Cargo log_server (${{ matrix.build_type }})
-    runs-on: [self-hosted, Linux, X64]
-    strategy:
-      matrix:
-        build_type: [debug, release]
-      fail-fast: false
-    steps:
-      - name: Checkout PR branch
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          ref: ${{ github.head_ref }}
-          fetch-depth: 1
-
-      - name: Install Nix
-        uses: cachix/install-nix-action@v31.10.6
-
-      - name: Cargo build
-        env:
-          RELEASE_FLAG: ${{ matrix.build_type == 'release' && '--release' || '' }}
-        run: nix develop --command bash -c "rustup toolchain install stable --no-self-update && rustup default stable && cargo build --manifest-path tools/log_server/Cargo.toml $RELEASE_FLAG"
-
   cargo-reflection-generator:
     name: Cargo reflection_generator (${{ matrix.build_type }})
     runs-on: [self-hosted, Linux, X64]
@@ -137,6 +116,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
@@ -146,29 +126,6 @@ jobs:
           RELEASE_FLAG: ${{ matrix.build_type == 'release' && '--release' || '' }}
         run: nix develop --command bash -c "rustup toolchain install stable --no-self-update && rustup default stable && cargo build --manifest-path tools/reflection_generator/Cargo.toml $RELEASE_FLAG"
 
-  cargo-kenzo:
-    name: Cargo kenzo (${{ matrix.build_type }})
-    runs-on: [self-hosted, Linux, X64]
-    strategy:
-      matrix:
-        build_type: [debug, release]
-      fail-fast: false
-    steps:
-      - name: Checkout PR branch
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          ref: ${{ github.head_ref }}
-          fetch-depth: 1
-
-      - name: Install Nix
-        uses: cachix/install-nix-action@v31.10.6
-
-      - name: Cargo build
-        env:
-          RELEASE_FLAG: ${{ matrix.build_type == 'release' && '--release' || '' }}
-        run: nix develop --command bash -c "rustup toolchain install stable --no-self-update && rustup default stable && cargo build --manifest-path tools/kenzo/Cargo.toml $RELEASE_FLAG"
-
   dotnet-editor:
     name: Dotnet editor (${{ matrix.build_type }})
     runs-on: [self-hosted, Linux, X64]
@@ -183,6 +140,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
@@ -204,6 +162,7 @@ jobs:
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           ref: ${{ github.head_ref }}
           fetch-depth: 1
+          submodules: true
 
       - name: Install Nix
         uses: cachix/install-nix-action@v31.10.6
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 000000000..79cea7045
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "tools/kenzo"]
+	path = tools/kenzo
+	url = https://github.com/ynks/kenzo
diff --git a/docs/logging_system.md b/docs/logging_system.md
index 7b3d5e6f0..b5ca0b5ba 100644
--- a/docs/logging_system.md
+++ b/docs/logging_system.md
@@ -6,8 +6,8 @@
 >
 
 The logging system provides an easy way to write logs and visualize them after the program
-execution has finished. It contains a C++ implementation for producing messages, a Rust
-server for receiving, processing and storing messages, and a Rust TUI for easily reading
+execution has finished. It contains a C++ implementation for producing messages, a C++
+server for receiving, processing and storing messages, and a TUI for easily reading
 and searching for information after reading.
 
 To use this system you can simply just include `<Toast/Log.hpp>` and call any of the toast
diff --git a/editor/Engine/Log.cs b/editor/Engine/Log.cs
index 4e681df31..95ef66bda 100644
--- a/editor/Engine/Log.cs
+++ b/editor/Engine/Log.cs
@@ -31,6 +31,14 @@ public static void Critical(
 		Dispatch(toast_critical, message, Path.GetFileName(fileName), (uint)lineNumber);
 	}
 
+	public static void InvalidateBacktraceCache() {
+		try {
+			toast_log_invalidate_backtraces();
+		} catch (DllNotFoundException) {
+			// Nothing was resolved without the engine
+		}
+	}
+
 	// Fallback to the console if toast-engine is not loaded
 	private static void Dispatch(
 		Action<string, string, string, uint> sink, string message, string fileName, uint lineNumber) {
@@ -56,4 +64,7 @@ private static void Dispatch(
 
 	[LibraryImport("toast_engine", StringMarshalling = StringMarshalling.Utf8)]
 	private static partial void toast_critical(string sink, string message, string fileName, uint lineNumber);
+
+	[LibraryImport("toast_engine")]
+	private static partial void toast_log_invalidate_backtraces();
 }
diff --git a/editor/Engine/ToastEngine.cs b/editor/Engine/ToastEngine.cs
index 0321729cc..f9c8b871f 100644
--- a/editor/Engine/ToastEngine.cs
+++ b/editor/Engine/ToastEngine.cs
@@ -326,6 +326,7 @@ public void ReloadGame() {
 			Log.Info($"Reloading game library: {gameDll}");
 			File.Copy(gameDll, newTempPath);
 			newHandle = NativeLibrary.Load(newTempPath);
+			Log.InvalidateBacktraceCache();
 			var newCreate =
 				Marshal.GetDelegateForFunctionPointer<GameCreate>(NativeLibrary.GetExport(newHandle, "game_create"));
 			var newDestroy =
@@ -347,7 +348,10 @@ public void ReloadGame() {
 			toast_begin_application();
 		} catch (Exception ex) {
 			if (!adopted) {
-				if (newHandle != IntPtr.Zero) NativeLibrary.Free(newHandle);
+				if (newHandle != IntPtr.Zero) {
+					NativeLibrary.Free(newHandle);
+					Log.InvalidateBacktraceCache();
+				}
 				TryDeleteGameTemp(newTempPath);
 			}
 
@@ -451,6 +455,7 @@ private string FindGameDll() {
 
 	private void LoadFrom(string dllPath) {
 		m_gameHandle = NativeLibrary.Load(dllPath);
+		Log.InvalidateBacktraceCache();
 		m_gameTempPath = dllPath;
 		m_gameCreate =
 			Marshal.GetDelegateForFunctionPointer<GameCreate>(NativeLibrary.GetExport(m_gameHandle, "game_create"));
@@ -472,6 +477,7 @@ private void ReleaseGameLibraries() {
 		}
 
 		m_retiredGameLibraries.Clear();
+		Log.InvalidateBacktraceCache();
 	}
 
 	private static void TryDeleteGameTemp(string path) {
diff --git a/editor/Logger/LogCsv.cs b/editor/Logger/LogCsv.cs
index a34e967fd..0fd8c5473 100644
--- a/editor/Logger/LogCsv.cs
+++ b/editor/Logger/LogCsv.cs
@@ -12,6 +12,8 @@ namespace editor.Logger;
 
 // Mirrors the CSV format written by the log_server
 internal static class LogCsv {
+	public const string Header = "Timestamp,Severity,Filepath,Line,Sink,Message,Details,Backtrace";
+
 	private static readonly string[] s_severityNames = ["TRACE", "INFO", "WARNING", "ERROR", "CRITICAL"];
 
 	private static readonly SearchValues<char> s_mustQuote = SearchValues.Create(",\"\r\n");
@@ -33,6 +35,10 @@ public static string ToCsvLine(LogEntry entry) {
 		AppendField(sb, entry.Sink);
 		sb.Append(',');
 		AppendField(sb, entry.Message);
+		sb.Append(',');
+		AppendField(sb, entry.Details);
+		sb.Append(',');
+		AppendField(sb, entry.Backtrace);
 		return sb.ToString();
 	}
 
diff --git a/editor/Logger/LogDetailWindow.axaml b/editor/Logger/LogDetailWindow.axaml
index c893fb921..2abf4a6ba 100644
--- a/editor/Logger/LogDetailWindow.axaml
+++ b/editor/Logger/LogDetailWindow.axaml
@@ -10,7 +10,7 @@
         x:DataType="vm:LogEntry"
         Width="700"
         MinHeight="260"
-        MaxHeight="640"
+        MaxHeight="900"
         SizeToContent="Height"
         CanResize="False"
         CanMaximize="False"
@@ -39,7 +39,8 @@
 			<Border Background="{Binding Severity, Converter={StaticResource SeverityBarColorConverter}}"
 			        Width="6"
 			        Height="28"
-			        CornerRadius="3" />
+			        CornerRadius="3"
+			        VerticalAlignment="Center"/>
 			<TextBlock Text="{Binding SeverityName}"
 			           FontFamily="FiraCode Nerd Font,Consolas,monospace"
 			           FontWeight="Bold"
@@ -61,18 +62,22 @@
 			<TextBlock Grid.Row="0"
 			           Grid.Column="0"
 			           Text="Timestamp"
+			           VerticalAlignment="Center"
 			           Foreground="{StaticResource TextMuted}" />
 			<TextBlock Grid.Row="0"
 			           Grid.Column="1"
 			           Text="{Binding AbsoluteTimestamp}"
+			           VerticalAlignment="Center"
 			           FontFamily="FiraCode Nerd Font,Consolas,monospace" />
 			<TextBlock Grid.Row="1"
 			           Grid.Column="0"
 			           Text="File"
+			           VerticalAlignment="Center"
 			           Foreground="{StaticResource TextMuted}" />
 			<TextBlock Grid.Row="1"
 			           Grid.Column="1"
 			           Text="{Binding FileLine}"
+			           VerticalAlignment="Center"
 			           FontFamily="FiraCode Nerd Font,Consolas,monospace"
 			           TextWrapping="Wrap" />
 		</Grid>
@@ -81,17 +86,56 @@
 		        CornerRadius="8"
 		        Padding="8"
 		        MaxHeight="300">
+				<ScrollViewer VerticalScrollBarVisibility="Auto">
+					<StackPanel>
+						<SelectableTextBlock Text="{Binding Message}"
+						                     TextWrapping="Wrap"
+						                     FontFamily="FiraCode Nerd Font,Consolas,monospace"
+						                     Foreground="{StaticResource Text}" />
+						<Border Background="{StaticResource Bg2}"
+						        Height="3"
+						        Width="150"
+						        CornerRadius="100"
+						        IsVisible="{Binding HasDetails}"
+						        Margin="0, 8, 0, 4"/>
+						<SelectableTextBlock Text="{Binding Details}"
+						                     IsVisible="{Binding HasDetails}"
+						                     TextWrapping="Wrap"
+						                     FontFamily="FiraCode Nerd Font,Consolas,monospace"
+						                     Foreground="{StaticResource TextMuted}" />
+					</StackPanel>
+				</ScrollViewer>
+		</Border>
+
+		<Border Background="{StaticResource Bg1}"
+		        CornerRadius="8"
+		        Padding="8"
+		        MaxHeight="240"
+		        IsVisible="{Binding HasBacktrace}">
 			<ScrollViewer VerticalScrollBarVisibility="Auto">
-				<SelectableTextBlock Text="{Binding Message}"
+				<SelectableTextBlock Text="{Binding Backtrace}"
 				                     TextWrapping="Wrap"
 				                     FontFamily="FiraCode Nerd Font,Consolas,monospace"
 				                     Foreground="{StaticResource Text}" />
 			</ScrollViewer>
 		</Border>
-
-		<Grid ColumnDefinitions="*,Auto,Auto,Auto"
+		<Grid ColumnDefinitions="*,Auto,Auto,Auto,Auto"
 		      ColumnSpacing="8">
 			<Button Grid.Column="1"
+			        Click="OnCopyBacktrace"
+			        IsVisible="{Binding HasBacktrace}"
+			        CornerRadius="6"
+			        Background="{StaticResource Bg4}"
+			        HorizontalContentAlignment="Center">
+				<StackPanel Orientation="Horizontal"
+				            Spacing="4">
+					<LucideIcon Kind="Layers"
+					            Size="16"
+					            StrokeWidth="2.5" />
+					<TextBlock Text="Copy backtrace" />
+				</StackPanel>
+			</Button>
+			<Button Grid.Column="2"
 			        Click="OnCopyMessage"
 			        CornerRadius="6"
 			        Background="{StaticResource Bg4}"
@@ -104,7 +148,7 @@
 					<TextBlock Text="Copy message" />
 				</StackPanel>
 			</Button>
-			<Button Grid.Column="2"
+			<Button Grid.Column="3"
 			        Click="OnCopy"
 			        CornerRadius="6"
 			        Background="{StaticResource Bg4}"
@@ -117,7 +161,7 @@
 					<TextBlock Text="Copy" />
 				</StackPanel>
 			</Button>
-			<Button Grid.Column="3"
+			<Button Grid.Column="4"
 			        Classes="primary"
 			        Click="OnClose"
 			        CornerRadius="6"
diff --git a/editor/Logger/LogDetailWindow.axaml.cs b/editor/Logger/LogDetailWindow.axaml.cs
index 3e4ad0826..82f5eb79a 100644
--- a/editor/Logger/LogDetailWindow.axaml.cs
+++ b/editor/Logger/LogDetailWindow.axaml.cs
@@ -30,6 +30,11 @@ private async void OnCopyMessage(object? sender, RoutedEventArgs e) {
 			await clipboard.SetTextAsync(entry.Message);
 	}
 
+	private async void OnCopyBacktrace(object? sender, RoutedEventArgs e) {
+		if (Entry is { } entry && Clipboard is { } clipboard)
+			await clipboard.SetTextAsync(entry.Backtrace);
+	}
+
 	private void OnClose(object? sender, RoutedEventArgs e) {
 		Close();
 	}
diff --git a/editor/Logger/LogEntry.cs b/editor/Logger/LogEntry.cs
index cbbd72e86..67c82f7ff 100644
--- a/editor/Logger/LogEntry.cs
+++ b/editor/Logger/LogEntry.cs
@@ -13,13 +13,16 @@ public sealed class LogEntry {
 	private const char FieldSeparator = '';
 	private const int MaxDisplayMessageLength = 500;
 
-	public LogEntry(ulong timestampNanos, uint severity, string filepath, uint line, string sink, string message) {
+	public LogEntry(ulong timestampNanos, uint severity, string filepath, uint line, string sink, string message,
+		string details = "", string backtrace = "") {
 		TimestampNanos = timestampNanos;
 		Severity = severity;
 		Filepath = filepath;
 		Line = line;
 		Sink = sink;
 		Message = message;
+		Details = details;
+		Backtrace = backtrace;
 
 		SeverityName = LogCsv.SeverityName(severity);
 		SeverityShortName = severity switch {
@@ -38,7 +41,7 @@ public LogEntry(ulong timestampNanos, uint severity, string filepath, uint line,
 		DisplayFileLine = line > 0 ? $"{filename}:{line}" : filename;
 
 		DisplayMessage = TrimForTable(message);
-		SearchBlob = string.Join(FieldSeparator, SeverityName, sink, FileLine, message);
+		SearchBlob = string.Join(FieldSeparator, SeverityName, sink, FileLine, message, details);
 	}
 
 	public ulong TimestampNanos { get; }
@@ -47,6 +50,10 @@ public LogEntry(ulong timestampNanos, uint severity, string filepath, uint line,
 	public uint Line { get; }
 	public string Sink { get; }
 	public string Message { get; }
+	public string Details { get; }
+	public string Backtrace { get; }
+	public bool HasDetails => Details.Length > 0;
+	public bool HasBacktrace => Backtrace.Length > 0;
 
 	public string SeverityName { get; }
 	public string SeverityShortName { get; }
diff --git a/editor/Logger/Logger.cs b/editor/Logger/Logger.cs
index c6cc88ae3..c4c3dd586 100644
--- a/editor/Logger/Logger.cs
+++ b/editor/Logger/Logger.cs
@@ -18,6 +18,7 @@ namespace editor.Logger;
 public class LogClient {
 	private TcpClient? m_client;
 	private CancellationTokenSource? m_cts;
+	private readonly Dictionary<string, string> m_backtraces = []; // listenLoop only
 	public event Action<List<LogEntry>>? OnLogReceived;
 
 	public void start() {
@@ -61,7 +62,9 @@ private async Task listenLoop(CancellationToken token) {
 						log_data.Filepath,
 						log_data.LineNumber,
 						log_data.Sink,
-						log_data.Message);
+						log_data.Message,
+						log_data.Details,
+						internBacktrace(log_data.Backtrace));
 					batch.Add(entry);
 				}
 
@@ -76,6 +79,13 @@ private async Task listenLoop(CancellationToken token) {
 		}
 	}
 
+	private string internBacktrace(string backtrace) {
+		if (backtrace.Length == 0) return backtrace;
+		if (m_backtraces.TryGetValue(backtrace, out var existing)) return existing;
+		m_backtraces.Add(backtrace, backtrace);
+		return backtrace;
+	}
+
 	private static async Task readExactlyAsync(
 		NetworkStream stream, byte[] buffer, int bytesToRead, CancellationToken token) {
 		var total_bytes_read = 0;
diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt
index e31fbaeac..65b3bad7d 100644
--- a/engine/CMakeLists.txt
+++ b/engine/CMakeLists.txt
@@ -41,6 +41,7 @@ find_package(tomlplusplus CONFIG REQUIRED)
 find_package(RmlUi CONFIG REQUIRED)
 find_package(Lua REQUIRED)
 find_package(imgui CONFIG REQUIRED)
+find_package(cpptrace CONFIG REQUIRED)
 find_path(LUABRIDGE3_INCLUDE_DIRS "luabridge3/LuaBridge/Array.h")
 
 # External paths
@@ -107,6 +108,7 @@ target_link_libraries(toast_engine
         LZ4::lz4
         imgui::imgui
         RmlUi::RmlUi
+        cpptrace::cpptrace
         $<$<CONFIG:Debug>:${EXTERNAL_LIBS_DEBUG}>
         $<$<NOT:$<CONFIG:Debug>>:${EXTERNAL_LIBS_RELEASE}>
         ${LUA_LIBRARIES}
@@ -138,7 +140,9 @@ set_source_files_properties(src/toast/renderer/vma.cpp PROPERTIES SKIP_PRECOMPIL
 set_source_files_properties(src/toast/assets/hdr_image.cpp PROPERTIES SKIP_PRECOMPILE_HEADERS ON SKIP_UNITY_BUILD_INCLUSION ON)
 set_source_files_properties(src/toast/renderer/shared_texture_output_target.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 set_source_files_properties(src/toast/input/trackpad.cpp PROPERTIES SKIP_PRECOMPILE_HEADERS ON SKIP_UNITY_BUILD_INCLUSION ON)
-set_source_files_properties(src/toast/crash_handler.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
+set_source_files_properties(src/toast/crash_handler.cpp src/toast/crash_handler_posix.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
+set_source_files_properties(src/toast/backtrace.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
+set_source_files_properties(src/toast/debugger.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 
 # protoc output uses file local symbol names
 file(GLOB _TOAST_PROTO_SOURCES "generated/*.pb.cc")
@@ -157,6 +161,7 @@ target_compile_definitions(toast_engine PUBLIC
         $<$<AND:$<CONFIG:Debug>,$<BOOL:${TOAST_SYNC_VALIDATION}>>:TOAST_SYNC_VALIDATION>
         $<$<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>>:NDEBUG>
         $<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:TRACY_ENABLE>
+        $<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:TOAST_BREAK_ON_ERROR>
         $<$<CONFIG:RelWithDebInfo>:TOAST_LUA_OWNERSHIP_CHECKS>
         GLM_FORCE_INTRINSICS
 )
@@ -284,4 +289,13 @@ add_custom_command(TARGET toast_engine POST_BUILD
         VERBATIM
 )
 
+if (WIN32)
+    add_custom_command(TARGET toast_engine POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:log_server> "${TOAST_ENGINE_BIN_DIR}"
+            COMMENT "Copying log server runtime DLLs"
+            COMMAND_EXPAND_LISTS
+            VERBATIM
+    )
+endif ()
+
 install(TARGETS toast_engine RUNTIME DESTINATION bin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
diff --git a/engine/ffi/log.h b/engine/ffi/log.h
index 75f190119..5fe82be1a 100644
--- a/engine/ffi/log.h
+++ b/engine/ffi/log.h
@@ -17,6 +17,7 @@ TOAST_C_API void toast_info(const char* sink, const char* message, const char* f
 TOAST_C_API void toast_warn(const char* sink, const char* message, const char* file_name, unsigned line_number) NOEXCEPT;
 TOAST_C_API void toast_error(const char* sink, const char* message, const char* file_name, unsigned line_number) NOEXCEPT;
 TOAST_C_API void toast_critical(const char* sink, const char* message, const char* file_name, unsigned line_number) NOEXCEPT;
+TOAST_C_API void toast_log_invalidate_backtraces(void) NOEXCEPT;
 
 #ifdef __cplusplus
 }
diff --git a/engine/src/toast/audio/audio_system.cpp b/engine/src/toast/audio/audio_system.cpp
index 5f13d73a0..b61d14030 100644
--- a/engine/src/toast/audio/audio_system.cpp
+++ b/engine/src/toast/audio/audio_system.cpp
@@ -30,7 +30,11 @@ auto fmodLogCallback(FMOD_DEBUG_FLAGS flags, const char* file, int line, const c
 	size_t pos = std::max(path.find_last_of('/'), path.find_last_of('\\'));
 	std::string name = pos == std::string::npos ? path : path.substr(pos + 1);
 
-	::logging::_detail::log(severity, path, line, "Audio", msg);
+	const auto [summary, body] = ::logging::splitFirstLine(msg);
+	::logging::_detail::log(severity, path, line, "Audio", summary, body);
+	if (severity >= 3) {
+		TOAST_BREAK_IF_ATTACHED();
+	}
 
 	constexpr uint32_t red = 0xFF0000;
 	constexpr uint32_t yellow = 0x00FFFF;
diff --git a/engine/src/toast/backtrace.cpp b/engine/src/toast/backtrace.cpp
new file mode 100644
index 000000000..2feccce38
--- /dev/null
+++ b/engine/src/toast/backtrace.cpp
@@ -0,0 +1,208 @@
+#include "backtrace.hpp"
+
+#include "log.hpp"
+
+#include <algorithm>
+#include <cpptrace/basic.hpp>
+#include <cpptrace/utils.hpp>
+#include <format>
+#include <mutex>
+#include <string_view>
+#include <unordered_map>
+
+#ifdef _WIN32
+#include <unordered_set>
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#include <execinfo.h>
+#endif
+
+namespace logging {
+
+namespace {
+
+constexpr std::size_t k_kept_frames = 16;
+
+std::mutex g_cache_mutex;
+std::unordered_map<std::uintptr_t, std::string> g_cache;
+std::uint64_t g_cache_generation = 0;
+#ifdef _WIN32
+std::unordered_set<std::uintptr_t> g_symbol_loaded_modules;
+#endif
+
+struct Module {
+	std::string path;
+	std::uintptr_t base = 0;
+};
+
+auto moduleOf(std::uintptr_t address) -> Module {
+#ifdef _WIN32
+	HMODULE handle = nullptr;
+	if (!GetModuleHandleExA(
+	        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+	        reinterpret_cast<LPCSTR>(address),
+	        &handle
+	    )) {
+		return {};
+	}
+	std::array<char, MAX_PATH> path {};
+	const DWORD length = GetModuleFileNameA(handle, path.data(), MAX_PATH);
+	if (length == 0) {
+		return {};
+	}
+	return {.path = std::string(path.data(), length), .base = reinterpret_cast<std::uintptr_t>(handle)};
+#else
+	Dl_info info {};
+	if (dladdr(reinterpret_cast<const void*>(address), &info) == 0 || info.dli_fname == nullptr) {
+		return {};
+	}
+	return {.path = info.dli_fname, .base = reinterpret_cast<std::uintptr_t>(info.dli_fbase)};
+#endif
+}
+
+#ifdef _WIN32
+auto loadSymbolsOnce(const Module& module) -> bool {
+	{
+		std::lock_guard lock(g_cache_mutex);
+		if (!g_symbol_loaded_modules.insert(module.base).second) {
+			return false;
+		}
+	}
+	try {
+		cpptrace::load_symbols_for_file(module.path);
+		return true;
+	} catch (...) { return false; }
+}
+#endif
+
+auto resolveFrame(std::uintptr_t address) -> cpptrace::stacktrace_frame {
+	cpptrace::stacktrace resolved = cpptrace::raw_trace {{address}}.resolve();
+	if (resolved.frames.empty()) {
+		return {};
+	}
+	return std::move(resolved.frames.front());
+}
+
+auto resolveLine(std::uintptr_t address) -> std::string {
+	const Module module = moduleOf(address);
+	if (module.path.empty()) {
+		return std::format("{:#x}", address);
+	}
+	std::string module_location = std::format("{}+{:#x}", _detail::getOnlyName(module.path), address - module.base);
+
+	cpptrace::stacktrace_frame frame = resolveFrame(address);
+#ifdef _WIN32
+	if (frame.symbol.empty() && loadSymbolsOnce(module)) {
+		frame = resolveFrame(address);
+	}
+#endif
+	if (frame.symbol.empty()) {
+		return module_location;
+	}
+
+	const std::string function = cpptrace::prune_symbol(frame.symbol);
+	if (frame.filename.empty() || !frame.line.has_value()) {
+		return std::format("{} ({})", function, module_location);
+	}
+	return std::format("{} ({}:{})", function, _detail::getOnlyName(frame.filename), frame.line.value());
+}
+
+auto cachedLine(std::uintptr_t address) -> std::string {
+	std::uint64_t generation = 0;
+	{
+		std::lock_guard lock(g_cache_mutex);
+		if (auto it = g_cache.find(address); it != g_cache.end()) {
+			return it->second;
+		}
+		generation = g_cache_generation;
+	}
+
+	std::string line = resolveLine(address);
+
+	std::lock_guard lock(g_cache_mutex);
+	if (generation == g_cache_generation) {
+		g_cache.emplace(address, line);
+	}
+	return line;
+}
+
+auto isLoggerFrame(std::string_view line) -> bool {
+	const std::string_view function = line.substr(0, line.find(' '));
+	if (function.starts_with("logging::") || function.starts_with("Logger::")) {
+		return true;
+	}
+	return function.starts_with("toast_") && function.find_first_of(".+") == std::string_view::npos;
+}
+
+}
+
+CPPTRACE_FORCE_NO_INLINE
+auto captureBacktrace(std::size_t skip) noexcept -> RawBacktrace {
+	RawBacktrace trace;
+#ifdef _WIN32
+	std::array<void*, RawBacktrace::k_capture_depth> addresses {};
+	const USHORT count =
+	    RtlCaptureStackBackTrace(static_cast<DWORD>(skip + 1), static_cast<DWORD>(addresses.size()), addresses.data(), nullptr);
+	for (USHORT i = 0; i < count; ++i) {
+		trace.frames[i] = reinterpret_cast<std::uintptr_t>(addresses[i]) - 1;
+	}
+	trace.count = static_cast<std::uint8_t>(count);
+#else
+	trace.count = static_cast<std::uint8_t>(cpptrace::safe_generate_raw_trace(trace.frames.data(), trace.frames.size(), skip + 1));
+	if (trace.count == 0) {
+		constexpr std::size_t k_max_skip = 8;
+		const std::size_t skipped = std::min(skip, k_max_skip) + 1;    // + this function
+		std::array<void*, k_max_skip + 1 + RawBacktrace::k_capture_depth> addresses {};
+		const int captured = backtrace(addresses.data(), static_cast<int>(skipped + RawBacktrace::k_capture_depth));
+		for (int i = static_cast<int>(skipped); i < captured; ++i) {
+			// Return addresses point past the call, one back lands inside it as cpptrace's own capture does
+			trace.frames[trace.count++] = reinterpret_cast<std::uintptr_t>(addresses[static_cast<std::size_t>(i)]) - 1;
+		}
+	}
+#endif
+	return trace;
+}
+
+auto formatBacktrace(const RawBacktrace& trace) -> std::string {
+	std::string text;
+	try {
+		const std::size_t count = std::min<std::size_t>(trace.count, trace.frames.size());
+		std::size_t kept = 0;
+		bool leading = true;
+		for (std::size_t i = 0; i < count && kept < k_kept_frames; ++i) {
+			const std::string line = cachedLine(trace.frames[i]);
+			if (leading && isLoggerFrame(line)) {
+				continue;
+			}
+			leading = false;
+			if (kept > 0) {
+				text += '\n';
+			}
+			text += line;
+			++kept;
+		}
+	} catch (...) { (void)0; }    // keep whatever resolved
+	return text;
+}
+
+void warmUpBacktrace() noexcept {
+	try {
+		const RawBacktrace trace = captureBacktrace();
+		if (trace.count > 0) {
+			[[maybe_unused]]
+			auto line = cachedLine(trace.frames[0]);
+		}
+	} catch (...) { (void)0; }
+}
+
+void invalidateBacktraceCache() noexcept {
+	std::lock_guard lock(g_cache_mutex);
+	g_cache.clear();
+	++g_cache_generation;
+#ifdef _WIN32
+	g_symbol_loaded_modules.clear();
+#endif
+}
+
+}
diff --git a/engine/src/toast/backtrace.hpp b/engine/src/toast/backtrace.hpp
new file mode 100644
index 000000000..8aa7506dc
--- /dev/null
+++ b/engine/src/toast/backtrace.hpp
@@ -0,0 +1,29 @@
+/**
+ * @file backtrace.hpp
+ * @author Xein
+ * @date 24 Oct 2026
+ * @brief Call stacks attached to log records
+ */
+
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace logging {
+
+struct RawBacktrace {
+	static constexpr std::size_t k_capture_depth = 20;
+	std::array<std::uintptr_t, k_capture_depth> frames {};
+	std::uint8_t count = 0;
+};
+
+auto captureBacktrace(std::size_t skip = 0) noexcept -> RawBacktrace;
+
+auto formatBacktrace(const RawBacktrace& trace) -> std::string;
+
+void warmUpBacktrace() noexcept;
+
+}
diff --git a/engine/src/toast/crash_handler.cpp b/engine/src/toast/crash_handler.cpp
index ded31cbe2..9f93acad0 100644
--- a/engine/src/toast/crash_handler.cpp
+++ b/engine/src/toast/crash_handler.cpp
@@ -1,5 +1,8 @@
 #include "crash_handler.hpp"
 
+#include "backtrace.hpp"
+#include "logger.hpp"
+
 #include <array>
 #include <cstdint>
 #include <cstdio>
@@ -56,6 +59,11 @@ std::array<char, 4096> g_scratch_message {};
 
 std::atomic_bool g_installed {false};
 std::atomic<DWORD> g_reporting_thread {0};
+bool g_reporter_ready = false;
+std::atomic_bool g_logs_flushed {false};
+std::array<char, 320> g_flush_reason {};
+logging::RawBacktrace g_flush_trace {};
+LPTOP_LEVEL_EXCEPTION_FILTER g_previous_filter = nullptr;
 
 auto enabled() noexcept -> bool {
 	std::array<wchar_t, 4> value {};
@@ -141,6 +149,37 @@ auto WINAPI launchReporter(LPVOID) -> DWORD {
 	return 0;
 }
 
+auto WINAPI flushLogsThread(LPVOID) -> DWORD {
+	logging::Logger::crashFlush(g_flush_reason.data(), g_flush_trace);
+	return 0;
+}
+
+void flushLogs(const EXCEPTION_POINTERS* pointers, const char* message) noexcept {
+	if (g_logs_flushed.exchange(true)) {
+		return;
+	}
+
+	g_flush_trace = logging::captureBacktrace();
+	if (message != nullptr) {
+		std::snprintf(g_flush_reason.data(), g_flush_reason.size(), "Engine crashed: %s", message);
+	} else if (pointers != nullptr) {
+		std::snprintf(
+		    g_flush_reason.data(),
+		    g_flush_reason.size(),
+		    "Engine crashed: exception 0x%08lX at 0x%p",
+		    pointers->ExceptionRecord->ExceptionCode,
+		    pointers->ExceptionRecord->ExceptionAddress
+		);
+	} else {
+		std::snprintf(g_flush_reason.data(), g_flush_reason.size(), "Engine crashed");
+	}
+
+	if (HANDLE thread = CreateThread(nullptr, 256 * 1024, flushLogsThread, nullptr, 0, nullptr)) {
+		WaitForSingleObject(thread, 1500);
+		CloseHandle(thread);
+	}
+}
+
 [[noreturn]]
 void report(Kind kind, const EXCEPTION_POINTERS* pointers, const char* message) noexcept {
 	const DWORD self = GetCurrentThreadId();
@@ -175,6 +214,8 @@ void report(Kind kind, const EXCEPTION_POINTERS* pointers, const char* message)
 	g_shared.pointers.ExceptionRecord = &g_shared.record;
 	g_shared.pointers.ContextRecord = &g_shared.context;
 
+	flushLogs(pointers, message);
+
 	// Fresh thread since after a stack overflow this one has too little stack to start a process
 	if (HANDLE thread = CreateThread(nullptr, 256 * 1024, launchReporter, nullptr, 0, nullptr)) {
 		WaitForSingleObject(thread, INFINITE);
@@ -274,11 +315,19 @@ void onTerminate() noexcept {
 	if (IsDebuggerPresent()) {
 		std::abort();
 	}
+	if (!g_reporter_ready) {
+		flushLogs(nullptr, message);
+		std::abort();
+	}
 	report(Kind::terminate, nullptr, message);
 }
 
 void __cdecl onPureCall() {
 	if (!IsDebuggerPresent()) {
+		if (!g_reporter_ready) {
+			flushLogs(nullptr, "A pure virtual function was called");
+			std::abort();
+		}
 		report(Kind::pure_call, nullptr, "A pure virtual function was called");
 	}
 	std::abort();
@@ -307,16 +356,33 @@ void __cdecl onInvalidParameter(
 	WideCharToMultiByte(
 	    CP_UTF8, 0, text.data(), -1, g_scratch_message.data(), static_cast<int>(g_scratch_message.size() - 1), nullptr, nullptr
 	);
+	if (!g_reporter_ready) {
+		flushLogs(nullptr, g_scratch_message.data());
+		std::abort();
+	}
 	report(Kind::invalid_parameter, nullptr, g_scratch_message.data());
 }
 
 void __cdecl onAbortSignal(int signal) {
 	(void)signal;
 	if (!IsDebuggerPresent()) {
+		if (!g_reporter_ready) {
+			flushLogs(nullptr, "abort() was called");
+			// abort() raises SIGABRT again, the default action ends the process
+			std::signal(SIGABRT, SIG_DFL);
+			std::abort();
+		}
 		report(Kind::abort, nullptr, "abort() was called");
 	}
 }
 
+auto CALLBACK onUnhandledException(EXCEPTION_POINTERS* pointers) -> LONG {
+	if (!isFaultSomeoneElseHandles(pointers->ExceptionRecord->ExceptionAddress)) {
+		flushLogs(pointers, nullptr);
+	}
+	return g_previous_filter != nullptr ? g_previous_filter(pointers) : EXCEPTION_CONTINUE_SEARCH;
+}
+
 }
 #endif
 
@@ -340,16 +406,22 @@ void overflowStack(volatile std::uint64_t depth) {
 
 void install() noexcept {
 #ifdef _WIN32
-	if (g_installed.exchange(true) || !enabled()) {
+	if (g_installed.exchange(true)) {
 		return;
 	}
-	if (!resolveReporter()) {
+
+	const bool wanted = enabled();
+	g_reporter_ready = wanted && resolveReporter();
+	if (wanted && !g_reporter_ready) {
 		std::println(stderr, "[Crash] crash_reporter.exe was not found next to the engine; native crashes will not be reported");
-		return;
 	}
 
-	// First in the chain so managed faults pass through untouched
-	AddVectoredExceptionHandler(1, onVectoredException);
+	if (g_reporter_ready) {
+		// First in the chain so managed faults pass through untouched
+		AddVectoredExceptionHandler(1, onVectoredException);
+	} else {
+		g_previous_filter = SetUnhandledExceptionFilter(onUnhandledException);
+	}
 	std::set_terminate(onTerminate);
 	_set_purecall_handler(onPureCall);
 	_set_invalid_parameter_handler(onInvalidParameter);
@@ -358,6 +430,8 @@ void install() noexcept {
 	_CrtSetReportHook2(_CRT_RPTHOOK_INSTALL, onCrtReport);
 	_CrtSetReportHookW2(_CRT_RPTHOOK_INSTALL, onCrtReportWide);
 #endif
+#else
+	installPosix();
 #endif
 }
 
diff --git a/engine/src/toast/crash_handler.hpp b/engine/src/toast/crash_handler.hpp
index 13f8dfa70..590d435ef 100644
--- a/engine/src/toast/crash_handler.hpp
+++ b/engine/src/toast/crash_handler.hpp
@@ -12,9 +12,12 @@
 
 namespace toast::crash {
 
-/// @brief No-op off Windows when disabled or when the reporter executable is missing
 TOAST_API void install() noexcept;
 
+#ifndef _WIN32
+void installPosix() noexcept;
+#endif
+
 TOAST_API void setDumpDirectory(const std::filesystem::path& directory) noexcept;
 
 TOAST_API void triggerTestCrash(int kind) noexcept;
diff --git a/engine/src/toast/crash_handler_posix.cpp b/engine/src/toast/crash_handler_posix.cpp
new file mode 100644
index 000000000..862d596b8
--- /dev/null
+++ b/engine/src/toast/crash_handler_posix.cpp
@@ -0,0 +1,256 @@
+#ifndef _WIN32
+
+#include "backtrace.hpp"
+#include "crash_handler.hpp"
+#include "log.hpp"
+#include "logger.hpp"
+
+#include <array>
+#include <atomic>
+#include <cerrno>
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <dlfcn.h>
+#include <exception>
+#include <fcntl.h>
+#include <string_view>
+#include <thread>
+#include <unistd.h>
+
+// flushes the logs when the process dies on a fatal signal or terminate
+namespace toast::crash {
+
+namespace {
+
+constexpr std::array<int, 5> k_signals {SIGABRT, SIGSEGV, SIGBUS, SIGILL, SIGFPE};
+constexpr std::size_t k_alt_stack_size = 128 * 1024;
+constexpr int k_wait_milliseconds = 1000;
+
+struct CrashInfo {
+	int signal = 0;    ///< 0 for terminate
+	void* address = nullptr;
+	logging::RawBacktrace trace;
+};
+
+CrashInfo g_info;
+std::array<char, 320> g_terminate_message {};
+std::array<struct sigaction, k_signals.size()> g_previous {};
+std::array<char, k_alt_stack_size> g_alt_stack {};
+std::array<int, 2> g_wake_pipe {-1, -1};
+std::atomic_bool g_installed {false};
+std::atomic_bool g_claimed {false};    ///< the first crash owns the report
+std::atomic_bool g_done {false};
+
+auto slotOf(int signal) noexcept -> int {
+	for (std::size_t i = 0; i < k_signals.size(); ++i) {
+		if (k_signals[i] == signal) {
+			return static_cast<int>(i);
+		}
+	}
+	return -1;
+}
+
+auto signalName(int signal) noexcept -> const char* {
+	switch (signal) {
+		case SIGABRT: return "SIGABRT";
+		case SIGSEGV: return "SIGSEGV";
+		case SIGBUS: return "SIGBUS";
+		case SIGILL: return "SIGILL";
+		case SIGFPE: return "SIGFPE";
+		default: return "signal";
+	}
+}
+
+/// faults in managed images belong to the host
+auto isForeignImage(const char* path) noexcept -> bool {
+	constexpr std::array<const char*, 7> needles {
+	  "libcoreclr", "libclrjit", "libclrgc", "libhostfxr", "libhostpolicy", "libSystem.", ".dll"
+	};
+	for (const char* needle : needles) {
+		if (std::strstr(path, needle) != nullptr) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/// true when the interrupted code is native
+auto faultIsNative(const logging::RawBacktrace& trace) noexcept -> bool {
+	for (std::size_t i = 1; i <= 2 && i < trace.count; ++i) {
+		Dl_info module {};
+		if (dladdr(reinterpret_cast<void*>(trace.frames[i]), &module) != 0 && module.dli_fname != nullptr) {
+			return !isForeignImage(module.dli_fname);
+		}
+	}
+	return false;
+}
+
+auto hasPreviousHandler(int slot) noexcept -> bool {
+	const struct sigaction& previous = g_previous[static_cast<std::size_t>(slot)];
+	if ((previous.sa_flags & SA_SIGINFO) != 0) {
+		return previous.sa_sigaction != nullptr;
+	}
+	return previous.sa_handler != SIG_DFL && previous.sa_handler != SIG_IGN;
+}
+
+void callPrevious(int slot, int signal, siginfo_t* info, void* context) noexcept {
+	const struct sigaction& previous = g_previous[static_cast<std::size_t>(slot)];
+	if ((previous.sa_flags & SA_SIGINFO) != 0) {
+		previous.sa_sigaction(signal, info, context);
+	} else {
+		previous.sa_handler(signal);
+	}
+}
+
+void waitForFlush() noexcept {
+	timespec pause {};
+	pause.tv_sec = 0;
+	pause.tv_nsec = 1'000'000;
+	for (int waited = 0; waited < k_wait_milliseconds && !g_done.load(std::memory_order_acquire); ++waited) {
+		nanosleep(&pause, nullptr);
+	}
+}
+
+/// hands the crash to the helper thread and waits
+void requestFlush(int signal, void* address, const logging::RawBacktrace& trace) noexcept {
+	if (!g_claimed.exchange(true)) {
+		g_info.signal = signal;
+		g_info.address = address;
+		g_info.trace = trace;
+		const char byte = 1;
+		[[maybe_unused]]
+		const ssize_t written = write(g_wake_pipe[1], &byte, 1);
+	}
+	waitForFlush();
+}
+
+/// blocks until a crash wakes it
+void helperMain() noexcept {
+	char byte = 0;
+	ssize_t got = 0;
+	do {
+		got = read(g_wake_pipe[0], &byte, 1);
+	} while (got < 0 && errno == EINTR);
+	if (got != 1) {
+		return;
+	}
+
+	std::array<char, 320> reason {};
+	if (g_info.signal == 0) {
+		std::snprintf(reason.data(), reason.size(), "%s", g_terminate_message.data());
+	} else if (g_info.signal == SIGABRT) {
+		std::snprintf(reason.data(), reason.size(), "Engine crashed: SIGABRT (abort() was called)");
+	} else {
+		std::snprintf(reason.data(), reason.size(), "Engine crashed: %s at %p", signalName(g_info.signal), g_info.address);
+	}
+	logging::Logger::crashFlush(reason.data(), g_info.trace);
+	g_done.store(true, std::memory_order_release);
+}
+
+/// restores the default action and raises the signal again
+void dieWithSignal(int signal) noexcept {
+	std::signal(signal, SIG_DFL);
+	raise(signal);
+}
+
+void onFatalSignal(int signal, siginfo_t* info, void* context) {
+	const int saved_errno = errno;
+	const int slot = slotOf(signal);
+
+	// the debugger has the original fault
+	if (logging::_detail::debuggerAttached()) {
+		if (slot >= 0 && hasPreviousHandler(slot)) {
+			callPrevious(slot, signal, info, context);
+		} else {
+			dieWithSignal(signal);
+		}
+		errno = saved_errno;
+		return;
+	}
+
+	const logging::RawBacktrace trace = logging::captureBacktrace();
+	if (signal != SIGABRT && slot >= 0 && hasPreviousHandler(slot) && !faultIsNative(trace)) {
+		callPrevious(slot, signal, info, context);
+		errno = saved_errno;
+		return;
+	}
+
+	requestFlush(signal, info != nullptr ? info->si_addr : nullptr, trace);
+	dieWithSignal(signal);
+	errno = saved_errno;
+}
+
+[[noreturn]]
+void onTerminate() noexcept {
+	// not a signal context so this may allocate
+	if (const std::exception_ptr current = std::current_exception()) {
+		try {
+			std::rethrow_exception(current);
+		} catch (const std::exception& e) {
+			std::snprintf(
+			    g_terminate_message.data(), g_terminate_message.size(), "Engine crashed: unhandled C++ exception: %s", e.what()
+			);
+		} catch (...) {
+			std::snprintf(
+			    g_terminate_message.data(), g_terminate_message.size(), "Engine crashed: unhandled C++ exception of an unknown type"
+			);
+		}
+	} else {
+		std::snprintf(
+		    g_terminate_message.data(),
+		    g_terminate_message.size(),
+		    "Engine crashed: std::terminate() was called without an active exception"
+		);
+	}
+
+	requestFlush(0, nullptr, logging::captureBacktrace());
+	// abort raises SIGABRT and the handler finds the crash reported
+	std::abort();
+}
+
+}
+
+void installPosix() noexcept {
+	if (g_installed.exchange(true)) {
+		return;
+	}
+
+	// first use allocates so do it outside a handler
+	[[maybe_unused]]
+	const logging::RawBacktrace warm = logging::captureBacktrace();
+	[[maybe_unused]]
+	const bool attached = logging::_detail::debuggerAttached();
+
+	if (pipe(g_wake_pipe.data()) != 0) {
+		return;
+	}
+	for (const int descriptor : g_wake_pipe) {
+		fcntl(descriptor, F_SETFD, FD_CLOEXEC);
+	}
+
+	try {
+		std::thread(helperMain).detach();
+	} catch (...) { return; }
+
+	// per thread so this one survives a stack overflow
+	stack_t alt_stack {};
+	alt_stack.ss_sp = g_alt_stack.data();
+	alt_stack.ss_size = g_alt_stack.size();
+	sigaltstack(&alt_stack, nullptr);
+
+	for (std::size_t i = 0; i < k_signals.size(); ++i) {
+		struct sigaction action {};
+		action.sa_sigaction = onFatalSignal;
+		sigemptyset(&action.sa_mask);
+		action.sa_flags = SA_SIGINFO | SA_ONSTACK;
+		sigaction(k_signals[i], &action, &g_previous[i]);
+	}
+	std::set_terminate(onTerminate);
+}
+
+}
+
+#endif
diff --git a/engine/src/toast/debugger.cpp b/engine/src/toast/debugger.cpp
new file mode 100644
index 000000000..0360d32ca
--- /dev/null
+++ b/engine/src/toast/debugger.cpp
@@ -0,0 +1,140 @@
+#include "log.hpp"
+
+#include <array>
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <string_view>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <cerrno>
+#include <ctime>
+#include <unistd.h>
+#ifdef __linux__
+#include <fcntl.h>
+#elif defined(__APPLE__)
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#endif
+#endif
+
+namespace logging {
+
+namespace {
+
+/// how long an answer is reused
+constexpr int64_t k_cache_milliseconds = 250;
+
+/// 0 until read then 1 allows breaking and 2 does not
+std::atomic<uint8_t> g_opt_out_state {0};
+std::atomic<bool> g_cached_attached {false};
+std::atomic<int64_t> g_cache_expires_ms {0};
+
+auto readOptOut() noexcept -> bool {
+#ifdef _WIN32
+	std::array<char, 4> value {};
+	const DWORD length = GetEnvironmentVariableA("TOAST_NO_BREAK", value.data(), static_cast<DWORD>(value.size()));
+	return length == 1 && value[0] == '1';
+#else
+	const char* value = std::getenv("TOAST_NO_BREAK");
+	return value != nullptr && value[0] == '1' && value[1] == '\0';
+#endif
+}
+
+auto breakingDisabled() noexcept -> bool {
+	uint8_t state = g_opt_out_state.load(std::memory_order_relaxed);
+	if (state == 0) {
+		state = readOptOut() ? 2 : 1;
+		g_opt_out_state.store(state, std::memory_order_relaxed);
+	}
+	return state == 2;
+}
+
+/// reads the environment on load so handlers never call getenv
+[[maybe_unused]]
+const bool g_opt_out_primed = breakingDisabled();
+
+auto monotonicMilliseconds() noexcept -> int64_t {
+#ifdef _WIN32
+	return static_cast<int64_t>(GetTickCount64());
+#else
+	timespec now {};
+	clock_gettime(CLOCK_MONOTONIC, &now);
+	return (static_cast<int64_t>(now.tv_sec) * 1000) + (static_cast<int64_t>(now.tv_nsec) / 1'000'000);
+#endif
+}
+
+#ifdef __linux__
+/// @param status start of /proc/self/status
+auto hasTracer(std::string_view status) noexcept -> bool {
+	constexpr std::string_view key = "\nTracerPid:";
+	const std::size_t at = status.find(key);
+	if (at == std::string_view::npos) {
+		return false;
+	}
+	for (std::size_t i = at + key.size(); i < status.size(); ++i) {
+		const char c = status[i];
+		if (c == ' ' || c == '\t') {
+			continue;
+		}
+		return c >= '1' && c <= '9';
+	}
+	return false;
+}
+#endif
+
+/// asks the OS and is safe to call from a signal handler
+auto queryDebugger() noexcept -> bool {
+#if defined(_WIN32)
+	return IsDebuggerPresent() != FALSE;
+#elif defined(__linux__)
+	const int saved_errno = errno;
+	bool attached = false;
+	const int fd = open("/proc/self/status", O_RDONLY | O_CLOEXEC);
+	if (fd >= 0) {
+		// TracerPid is in the first few lines
+		std::array<char, 512> buffer;
+		ssize_t length = 0;
+		do {
+			length = read(fd, buffer.data(), buffer.size());
+		} while (length < 0 && errno == EINTR);
+		close(fd);
+		attached = length > 0 && hasTracer({buffer.data(), static_cast<std::size_t>(length)});
+	}
+	errno = saved_errno;
+	return attached;
+#elif defined(__APPLE__)
+	const int saved_errno = errno;
+	std::array<int, 4> mib = {CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()};
+	kinfo_proc info {};
+	std::size_t size = sizeof(info);
+	const bool queried = sysctl(mib.data(), static_cast<u_int>(mib.size()), &info, &size, nullptr, 0) == 0;
+	const bool attached = queried && (info.kp_proc.p_flag & P_TRACED) != 0;
+	errno = saved_errno;
+	return attached;
+#else
+	return false;
+#endif
+}
+}
+
+auto _detail::debuggerAttached() noexcept -> bool {
+	if (breakingDisabled()) {
+		return false;
+	}
+
+	const int64_t now = monotonicMilliseconds();
+	if (now < g_cache_expires_ms.load(std::memory_order_relaxed)) {
+		return g_cached_attached.load(std::memory_order_relaxed);
+	}
+
+	const bool attached = queryDebugger();
+	g_cached_attached.store(attached, std::memory_order_relaxed);
+	g_cache_expires_ms.store(now + k_cache_milliseconds, std::memory_order_relaxed);
+	return attached;
+}
+
+}
diff --git a/engine/src/toast/engine.cpp b/engine/src/toast/engine.cpp
index 6ab7dc87b..95998e8d8 100644
--- a/engine/src/toast/engine.cpp
+++ b/engine/src/toast/engine.cpp
@@ -403,7 +403,7 @@ static void updateProfilerSections(EnginePimpl& pimpl) {
 	pimpl.profiler_sections.update(mode, world);
 }
 
-static void assertOnTickThread([[maybe_unused]] const std::atomic<size_t>& tick_thread, [[maybe_unused]] std::string_view what) {
+static void assertOnTickThread(const std::atomic<size_t>& tick_thread, std::string_view what) {
 	TOAST_ASSERT(
 	    tick_thread.load() == 0 || tick_thread.load() == std::hash<std::thread::id> {}(std::this_thread::get_id()),
 	    "Engine",
diff --git a/engine/src/toast/log.hpp b/engine/src/toast/log.hpp
index 68649885c..e28cc70fc 100644
--- a/engine/src/toast/log.hpp
+++ b/engine/src/toast/log.hpp
@@ -12,8 +12,10 @@
 #include <cstdint>
 #include <cstdlib>
 #include <format>
+#include <string>
 #include <string_view>
 #include <tracy/Tracy.hpp>
+#include <utility>
 
 /// @internal
 namespace logging::_detail {
@@ -27,38 +29,130 @@ constexpr auto getOnlyName(std::string_view path) -> std::string_view {
 
 void TOAST_API
     log(uint8_t severity, std::string_view file_name, unsigned line_number, std::string_view sink, std::string_view message);
+
+/// details is the long body of a log
+TOAST_API void
+    log(uint8_t severity, std::string_view file_name, unsigned line_number, std::string_view sink, std::string_view message,
+		    std::string_view details);
+
+/// true while a debugger is attached
+TOAST_API auto debuggerAttached() noexcept -> bool;
 }
 
 namespace logging {
+/// same values as the proto severity
+enum class Severity : uint8_t {
+	trace = 0,
+	info = 1,
+	warning = 2,
+	error = 3,
+	critical = 4,
+};
+
+/// first line and the rest of a text
+constexpr auto splitFirstLine(std::string_view text) -> std::pair<std::string_view, std::string_view> {
+	const size_t newline = text.find('\n');
+	if (newline == std::string_view::npos) {
+		return {text, {}};
+	}
+	std::string_view first = text.substr(0, newline);
+	if (!first.empty() && first.back() == '\r') {
+		first.remove_suffix(1);
+	}
+	return {first, text.substr(newline + 1)};
+}
+
 /// Sends every queued log now for paths about to abort the process
 TOAST_API void flush() noexcept;
+
+/// call after loading or freeing a library
+TOAST_API void invalidateBacktraceCache() noexcept;
 }
 
 #define TOAST_FILE_NAME ::logging::_detail::getOnlyName(__FILE__)
 
-#ifdef DEBUG
-#define TOAST_LOG_IMPL(severity, sink, ...)                                                                  \
-	do {                                                                                                       \
-		std::string toast_log_impl_message_ = std::format(__VA_ARGS__);                                          \
-		::logging::_detail::log(severity, TOAST_FILE_NAME, __LINE__, sink, toast_log_impl_message_);             \
-		constexpr uint32_t red = 0xFF0000;                                                                       \
-		constexpr uint32_t green = 0x00FF00;                                                                     \
-		constexpr uint32_t yellow = red | green; /* i love this so much -x */                                    \
-		switch (severity) {                                                                                      \
-			case 4:                                                                                                \
-			case 3: TracyMessageC(toast_log_impl_message_.c_str(), toast_log_impl_message_.size(), red); break;    \
-			case 2: TracyMessageC(toast_log_impl_message_.c_str(), toast_log_impl_message_.size(), yellow); break; \
-			case 1: TracyMessageC(toast_log_impl_message_.c_str(), toast_log_impl_message_.size(), green); break;  \
-			default: break;                                                                                        \
-		}                                                                                                        \
+/// breaks on the line that expands it
+#if defined(_MSC_VER)
+#define TOAST_DEBUG_BREAK() __debugbreak()
+#elif defined(__clang__)
+#define TOAST_DEBUG_BREAK() __builtin_debugtrap()
+#elif defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
+#define TOAST_DEBUG_BREAK() __asm__ volatile("int3")
+#elif defined(__GNUC__) && defined(__aarch64__)
+#define TOAST_DEBUG_BREAK() __asm__ volatile("brk #0xf000")
+#else
+#include <csignal>
+#define TOAST_DEBUG_BREAK() std::raise(SIGTRAP)
+#endif
+
+/// does nothing without TOAST_BREAK_ON_ERROR
+#ifdef TOAST_BREAK_ON_ERROR
+#define TOAST_BREAK_IF_ATTACHED()                 \
+	do {                                            \
+		if (::logging::_detail::debuggerAttached()) { \
+			TOAST_DEBUG_BREAK();                        \
+		}                                             \
 	} while (0)
 #else
-#define TOAST_LOG_IMPL(severity, sink, ...)                                                       \
-	do {                                                                                            \
-		::logging::_detail::log(severity, TOAST_FILE_NAME, __LINE__, sink, std::format(__VA_ARGS__)); \
+#define TOAST_BREAK_IF_ATTACHED() ((void)0)
+#endif
+
+#ifdef DEBUG
+/// tracy only gets the summary
+#define TOAST_LOG_TRACY(severity, message)                                                                             \
+	do {                                                                                                                 \
+		constexpr uint32_t red = 0xFF0000;                                                                                 \
+		constexpr uint32_t green = 0x00FF00;                                                                               \
+		constexpr uint32_t yellow = red | green; /* i love this so much -x */                                              \
+		const std::string_view toast_log_text_ = (message);                                                                \
+		switch (severity) {                                                                                                \
+			case ::logging::Severity::critical:                                                                              \
+			case ::logging::Severity::error: TracyMessageC(toast_log_text_.data(), toast_log_text_.size(), red); break;      \
+			case ::logging::Severity::warning: TracyMessageC(toast_log_text_.data(), toast_log_text_.size(), yellow); break; \
+			case ::logging::Severity::info: TracyMessageC(toast_log_text_.data(), toast_log_text_.size(), green); break;     \
+			default: break;                                                                                                  \
+		}                                                                                                                  \
 	} while (0)
+#else
+#define TOAST_LOG_TRACY(severity, message) ((void)0)
 #endif
 
+/// every log macro ends up here
+#define TOAST_LOG_CORE(severity, sink, message, details)                                                        \
+	do {                                                                                                          \
+		const ::logging::Severity toast_log_severity_ = (severity);                                                 \
+		const auto& toast_log_message_ = (message);                                                                 \
+		::logging::_detail::log(                                                                                    \
+		    static_cast<uint8_t>(toast_log_severity_), TOAST_FILE_NAME, __LINE__, sink, toast_log_message_, details \
+		);                                                                                                          \
+		TOAST_LOG_TRACY(toast_log_severity_, toast_log_message_);                                                   \
+		if (toast_log_severity_ >= ::logging::Severity::error) {                                                    \
+			TOAST_BREAK_IF_ATTACHED();                                                                                \
+		}                                                                                                           \
+	} while (0)
+
+#define TOAST_LOG_IMPL(severity, sink, ...)                                       \
+	do {                                                                            \
+		const std::string toast_log_impl_message_ = std::format(__VA_ARGS__);         \
+		TOAST_LOG_CORE(severity, sink, toast_log_impl_message_, std::string_view {}); \
+	} while (0)
+
+/**
+ * @param severity can be decided at runtime
+ * @param sink class logging the message
+ * @param message short summary
+ * @param details long body
+ * @brief Writes a log with a body
+ */
+#define TOAST_MESSAGE(severity, sink, message, details)              \
+	do {                                                               \
+		const ::logging::Severity toast_message_severity_ = (severity);  \
+		TOAST_LOG_CORE(toast_message_severity_, sink, message, details); \
+		if (toast_message_severity_ == ::logging::Severity::critical) {  \
+			std::abort();                                                  \
+		}                                                                \
+	} while (0)
+
 /**
  * @param sink class logging the message
  * @param ... fmt formatted message
@@ -73,7 +167,7 @@ TOAST_API void flush() noexcept;
  * If you will stop caring about this log as soon as you finish working on your task, then
  * it is a trace
  */
-#define TOAST_TRACE(sink, ...) TOAST_LOG_IMPL(0, sink, __VA_ARGS__)
+#define TOAST_TRACE(sink, ...) TOAST_LOG_IMPL(::logging::Severity::trace, sink, __VA_ARGS__)
 
 /**
  * @brief logs an information message
@@ -85,7 +179,7 @@ TOAST_API void flush() noexcept;
  * if you are not sure if your message is important enough, then it's probably
  * not an info log
  */
-#define TOAST_INFO(sink, ...) TOAST_LOG_IMPL(1, sink, __VA_ARGS__)
+#define TOAST_INFO(sink, ...) TOAST_LOG_IMPL(::logging::Severity::info, sink, __VA_ARGS__)
 
 /**
  * @param sink class logging the message
@@ -96,7 +190,7 @@ TOAST_API void flush() noexcept;
  * It can potentially lead to bugs and errors so a warning shouldn't be
  * ignored
  */
-#define TOAST_WARN(sink, ...) TOAST_LOG_IMPL(2, sink, __VA_ARGS__)
+#define TOAST_WARN(sink, ...) TOAST_LOG_IMPL(::logging::Severity::warning, sink, __VA_ARGS__)
 
 /**
  * @param sink class logging the message
@@ -106,7 +200,7 @@ TOAST_API void flush() noexcept;
  * The engine will be considered as an undefined behaviour from the moment
  * an error happens since an "unrecoverable-in-runtime" problem has ocurred
  */
-#define TOAST_ERROR(sink, ...) TOAST_LOG_IMPL(3, sink, __VA_ARGS__)
+#define TOAST_ERROR(sink, ...) TOAST_LOG_IMPL(::logging::Severity::error, sink, __VA_ARGS__)
 
 /**
  * @param sink class logging the message
@@ -115,29 +209,31 @@ TOAST_API void flush() noexcept;
  *
  * We will terminate the process when a critical error happens via @c std::abort();
  */
-#define TOAST_CRITICAL(sink, ...)         \
-	do {                                    \
-		TOAST_LOG_IMPL(4, sink, __VA_ARGS__); \
-		std::abort();                         \
+#define TOAST_CRITICAL(sink, ...)                                     \
+	do {                                                                \
+		TOAST_LOG_IMPL(::logging::Severity::critical, sink, __VA_ARGS__); \
+		std::abort();                                                     \
 	} while (0)
 
-#ifdef _DEBUG
+/// critical in debug and an error otherwise
+#ifdef DEBUG
+#define TOAST_ASSERT_FAILED(sink, ...) TOAST_CRITICAL(sink, __VA_ARGS__)
+#else
+#define TOAST_ASSERT_FAILED(sink, ...) TOAST_ERROR(sink, __VA_ARGS__)
+#endif
+
 /**
  * @macro TOAST_ASSERT
- * @brief requires that a condition is met, if not, the program will
- *        terminate with a critical failure
+ * @brief requires that a condition is met
+ * @param condition evaluated in every build
  * @param sink class logging the message
  * @param ... fmt formatted message
  */
-#define TOAST_ASSERT(condition, sink, ...)  \
-	do {                                      \
-		if (!(condition)) {                     \
-			TOAST_LOG_IMPL(4, sink, __VA_ARGS__); \
-			assert(condition);                    \
-		}                                       \
+#define TOAST_ASSERT(condition, sink, ...)                                                          \
+	do {                                                                                              \
+		if (!(condition)) {                                                                             \
+			TOAST_ASSERT_FAILED(sink, "Assertion failed ({}): {}", #condition, std::format(__VA_ARGS__)); \
+		}                                                                                               \
 	} while (0)
-#else
-#define TOAST_ASSERT(condition, sink, ...)
-#endif
 
 #define TOAST_NOT_IMPLEMENTED TOAST_ASSERT(false, "Engine", "Not implemented")
diff --git a/engine/src/toast/logger.cpp b/engine/src/toast/logger.cpp
index 3299b9e67..9b106542f 100644
--- a/engine/src/toast/logger.cpp
+++ b/engine/src/toast/logger.cpp
@@ -5,11 +5,17 @@
 #include "log.hpp"      // public functions
 #include "thread_pool.hpp"
 
+#include <array>
 #include <chrono>
 #include <cstdlib>
 #include <filesystem>
+#include <future>
+#include <google/protobuf/io/coded_stream.h>
 #include <iostream>
+#include <iterator>
 #include <print>
+#include <string>
+#include <thread>
 #include <tracy/Tracy.hpp>
 #include <vector>
 
@@ -59,15 +65,108 @@ auto moduleDirectory() -> std::filesystem::path {
 }
 
 std::mutex fallback_database_mutex;
-std::vector<std::tuple<std::string, unsigned, char, std::string, std::string>> fallback_database;
+std::vector<Pending> fallback_database;    ///< logged before the logger existed
+
+/// true while this thread holds send_mutex
+thread_local bool t_sending = false;
+
+struct SendingScope {
+	SendingScope() noexcept { t_sending = true; }
+
+	~SendingScope() noexcept { t_sending = false; }
+
+	SendingScope(const SendingScope&) = delete;
+	auto operator=(const SendingScope&) -> SendingScope& = delete;
+};
+
+/// longest text kept in one field
+constexpr std::size_t k_max_field_bytes = 1024 * 1024;
+constexpr std::string_view k_truncated_suffix = "\xE2\x80\xA6[truncated]";    // ellipsis then truncated
+constexpr std::string_view k_replacement_character = "\xEF\xBF\xBD";          // U+FFFD
+
+struct Utf8Sequence {
+	std::size_t length = 0;                                                     ///< bytes it spans
+	bool valid = false;
+};
+
+/// reads one utf8 sequence per the unicode table
+auto utf8SequenceAt(std::string_view text) -> Utf8Sequence {
+	const auto byte = [text](std::size_t i) -> unsigned { return static_cast<unsigned char>(text[i]); };
+	const unsigned lead = byte(0);
+	if (lead < 0x80) {
+		return {.length = 1, .valid = true};
+	}
+
+	std::size_t length = 0;
+	unsigned second_min = 0x80;
+	unsigned second_max = 0xBF;
+	if (lead >= 0xC2 && lead <= 0xDF) {
+		length = 2;
+	} else if (lead >= 0xE0 && lead <= 0xEF) {
+		length = 3;
+		second_min = lead == 0xE0 ? 0xA0 : 0x80;
+		second_max = lead == 0xED ? 0x9F : 0xBF;
+	} else if (lead >= 0xF0 && lead <= 0xF4) {
+		length = 4;
+		second_min = lead == 0xF0 ? 0x90 : 0x80;
+		second_max = lead == 0xF4 ? 0x8F : 0xBF;
+	} else {
+		return {.length = 1, .valid = false};
+	}
+
+	for (std::size_t i = 1; i < length; ++i) {
+		const unsigned min = i == 1 ? second_min : 0x80;
+		const unsigned max = i == 1 ? second_max : 0xBF;
+		if (i >= text.size() || byte(i) < min || byte(i) > max) {
+			return {.length = i, .valid = false};
+		}
+	}
+	return {.length = length, .valid = true};
+}
+
+/// replaces invalid utf8 and cuts long text
+auto sanitizeField(std::string_view text) -> std::string {
+	std::string result;
+	std::size_t copied = 0;    // text before this offset is already in result
+	std::size_t offset = 0;
+	// stops once past the limit
+	while (offset < text.size() && result.size() + (offset - copied) <= k_max_field_bytes) {
+		const Utf8Sequence sequence = utf8SequenceAt(text.substr(offset));
+		if (!sequence.valid) {
+			result.append(text.substr(copied, offset - copied));
+			result.append(k_replacement_character);
+			copied = offset + sequence.length;
+		}
+		offset += sequence.length;
+	}
+	result.append(text.substr(copied, offset - copied));
+
+	if (result.size() > k_max_field_bytes) {
+		// back to the start of a character
+		std::size_t cut = k_max_field_bytes - k_truncated_suffix.size();
+		while (cut > 0 && (static_cast<unsigned char>(result[cut]) & 0xC0) == 0x80) {
+			--cut;
+		}
+		result.resize(cut);
+		result.append(k_truncated_suffix);
+	}
+	return result;
+}
 }
 
 void _detail::log(
     uint8_t severity, std::string_view file_name, unsigned line_number, std::string_view sink, std::string_view message
+) {
+	_detail::log(severity, file_name, line_number, sink, message, {});
+}
+
+void _detail::log(
+    uint8_t severity, std::string_view file_name, unsigned line_number, std::string_view sink, std::string_view message,
+    std::string_view details
 ) {
 	// We wrap the singleton access here so the public headers don't need to know
 	// anything about the Logger class or its dependencies
-	Logger::log(file_name, line_number, severity, sink, message);
+	Logger::log(file_name, line_number, severity, sink, message, details);
 }
 
 void flush() noexcept {
@@ -84,6 +183,23 @@ auto Logger::create() noexcept -> std::unique_ptr<Logger> {
 	instance = ptr.get();
 
 	toast::ThreadPool::push([] {
+		// load the symbol tables so the first error does not wait
+		warmUpBacktrace();
+
+		// older than anything queued since so they go in front
+		std::vector<Pending> early_logs;
+		{
+			std::lock_guard lock(fallback_database_mutex);
+			early_logs.swap(fallback_database);
+		}
+		{
+			std::lock_guard lock(instance->m.queue_mutex);
+			instance->m.log_queue.insert(
+			    instance->m.log_queue.begin(), std::make_move_iterator(early_logs.begin()), std::make_move_iterator(early_logs.end())
+			);
+			instance->m.enqueued += early_logs.size();
+		}
+
 		// We allow disabling this so it's easier to debug the server
 		// On release this should ALWAYS be on since the client is not expected to open the log server on their own
 		if constexpr (auto_spawn_log_server) {
@@ -177,27 +293,21 @@ auto Logger::create() noexcept -> std::unique_ptr<Logger> {
 		}
 
 		instance->initNetworkRetry();
-
-		// Send logs on the queue
-		std::vector<std::tuple<std::string, unsigned, char, std::string, std::string>> logs_to_send;
-		{
-			std::lock_guard lock(fallback_database_mutex);
-			logs_to_send = fallback_database;
-			fallback_database.clear();
-		}
-		for (const auto& [file, line, severity, sink, message] : logs_to_send) {
-			log(file, line, severity, sink, message);
-		}
 	});
 	return ptr;
 }
 
 Logger::~Logger() noexcept {
-	stop();
+	// first so callers stop reaching a dying logger
 	instance = nullptr;
+	stop();
 }
 
-void Logger::log(std::string_view file, unsigned line, char severity, std::string_view sink, std::string_view message) {
+void Logger::log(
+    std::string_view file, unsigned line, char severity, std::string_view sink, std::string_view message, std::string_view details
+) {
+	// first while the stack is still the callers
+	const RawBacktrace trace = captureBacktrace();
 	auto* logger = instance;
 
 	// DEPRECATED: This is not used anymore
@@ -209,6 +319,23 @@ void Logger::log(std::string_view file, unsigned line, char severity, std::strin
 		trimmed_sink = sink;
 	}
 
+	// nobody to receive
+	if (logger != nullptr && logger->m.unavailable.load(std::memory_order_acquire)) {
+		return;
+	}
+
+	// collectQueue fills the backtrace
+	proto::logging::LogData log;
+	log.set_timestamp(
+	    std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()
+	);    // retarded stl library
+	log.set_filepath(sanitizeField(file));
+	log.set_line_number(line);
+	log.set_severity(static_cast<proto::logging::LogData_Severity>(severity));
+	log.set_sink(sanitizeField(trimmed_sink));
+	log.set_message(sanitizeField(message));
+	log.set_details(sanitizeField(details));
+
 	if (not logger) {
 #ifdef DEBUG
 		try {
@@ -238,28 +365,14 @@ void Logger::log(std::string_view file, unsigned line, char severity, std::strin
 
 		// Add the logs to a fallback database if it doesn't exist, then send them when initialized
 		std::lock_guard lock(fallback_database_mutex);
-		fallback_database.emplace_back(file, line, severity, sink, message);
-		return;
-	}
-
-	// Nothing downstream to receive
-	if (logger->m.unavailable.load(std::memory_order_acquire)) {
+		fallback_database.push_back({.data = std::move(log), .trace = trace});
 		return;
 	}
 
-	proto::logging::LogData log;
-	log.set_timestamp(
-	    std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()
-	);    // retarded stl library
-	log.set_filepath(file);
-	log.set_line_number(line);
-	log.set_severity(static_cast<proto::logging::LogData_Severity>(severity));
-	log.set_sink(trimmed_sink);
-	log.set_message(message);
-
 	{
 		std::lock_guard lock(logger->m.queue_mutex);
-		logger->m.log_queue.emplace_back(std::move(log));
+		logger->m.log_queue.push_back({.data = std::move(log), .trace = trace});
+		++logger->m.enqueued;
 	}
 
 	// We use an atomic exchange to claim a "drain slot". This ensures that
@@ -268,6 +381,11 @@ void Logger::log(std::string_view file, unsigned line, char severity, std::strin
 		toast::ThreadPool::push([logger]() { logger->drain(); });
 	}
 
+	// errors leave before the caller continues
+	if (severity >= 3) {
+		flush();
+	}
+
 #ifdef DEBUG
 	// If in debug we are going to print warnings and errors on console
 	// if (severity >= 3) {
@@ -338,16 +456,31 @@ void Logger::initNetworkRetry() {
 void Logger::stop() {
 	ZoneScoped;
 
-	// We spin briefly to wait for any active background write to finish
-	// This prevents us from closing the socket while a ThreadPool worker is using it
-	while (m.drain_pending.load(std::memory_order_acquire)) {
+	// We spin briefly to wait for any active background drain to finish
+	// claim the slot so no drain runs after this
+	while (m.drain_pending.exchange(true, std::memory_order_acq_rel)) {
 		std::this_thread::yield();
 	}
+	// a drain is gone once this lock was held
+	m.queue_mutex.lock();
+	m.queue_mutex.unlock();
+
+	// wait for a flush on another thread
+	std::lock_guard send_lock(m.send_mutex);
+	const SendingScope sending;
+	m.stopped.store(true, std::memory_order_release);
 
 	// Any logs produced during the last drain or while we were waiting above
 	// must be flushed synchronously before the object is destroyed
 	flushSync();
 
+	// zero length frame is the goodbye
+	if (m.connected.load(std::memory_order_acquire) && m.socket.is_open()) {
+		constexpr std::array<uint8_t, 4> goodbye {};
+		asio::error_code ec;
+		asio::write(m.socket, asio::buffer(goodbye), ec);
+	}
+
 	m.connected.store(false, std::memory_order_release);
 
 	if (m.socket.is_open()) {
@@ -362,109 +495,200 @@ void Logger::stop() {
 void Logger::drain() {
 	ZoneScoped;
 
+	// every exit gives the slot back under queue_mutex
 	if (m.unavailable.load(std::memory_order_acquire)) {
-		[[maybe_unused]]
-		auto discarded = collectQueue();
+		// destroyed outside the lock
+		std::deque<Pending> discarded;
+		std::lock_guard lock(m.queue_mutex);
+		discarded.swap(m.log_queue);
+		m.sent.fetch_add(discarded.size(), std::memory_order_relaxed);
 		m.drain_pending.store(false, std::memory_order_release);
 		return;
 	}
 
 	// The socket is open but not yet connected while initNetworkRetry is still running
 	if (!m.connected.load(std::memory_order_acquire)) {
+		std::lock_guard lock(m.queue_mutex);
 		m.drain_pending.store(false, std::memory_order_release);
 		return;
 	}
 
-	auto batch = collectQueue();
-
-	if (!batch.empty() && m.socket.is_open()) {
-		try {
-			uint32_t len = static_cast<uint32_t>(batch.size());
-			std::array<uint8_t, 4> len_buf;
-			len_buf[0] = (len >> 24) & 0xFF;
-			len_buf[1] = (len >> 16) & 0xFF;
-			len_buf[2] = (len >> 8) & 0xFF;
-			len_buf[3] = len & 0xFF;
-
-			std::array<asio::const_buffer, 2> bufs = {asio::buffer(len_buf, 4), asio::buffer(batch)};
-			asio::write(m.socket, bufs);
-		} catch (const std::exception& e) {
-			// If sending fails, we fallback to stderr to avoid losing critical info
-			std::println(std::cerr, "[Logger] Send failure: {}", e.what());
+	// bursts go out as several frames
+	// send_mutex is taken per frame
+	try {
+		while (true) {
+			std::lock_guard send_lock(m.send_mutex);
+			const SendingScope sending;
+			const std::vector<uint8_t> batch = collectQueue(k_max_frame_bytes);
+			if (batch.empty()) {
+				break;
+			}
+			if (const asio::error_code ec = writeFrame(batch)) {
+				// If sending fails, we fallback to stderr to avoid losing critical info
+				std::println(std::cerr, "[Logger] Send failure: {}", ec.message());
+			}
 		}
-	}
+	} catch (const std::exception& e) { std::println(std::cerr, "[Logger] Send failure: {}", e.what()); }
 
 	// Release the drain slot, but check if more logs arrived while we were busy
 	// This "double-check" pattern ensures the queue is actually empty when we finish
+	std::lock_guard lock(m.queue_mutex);
 	m.drain_pending.store(false, std::memory_order_release);
-	{
-		std::lock_guard lock(m.queue_mutex);
-		if (!m.log_queue.empty() && !m.drain_pending.exchange(true)) {
-			toast::ThreadPool::push([this]() { drain(); });
-		}
+	if (!m.log_queue.empty() && !m.drain_pending.exchange(true)) {
+		toast::ThreadPool::push([this]() { drain(); });
 	}
 }
 
-auto Logger::collectQueue() -> std::vector<uint8_t> {
+auto Logger::collectQueue(std::size_t max_bytes) -> std::vector<uint8_t> {
 	ZoneScoped;
 
-	// Batching logs together significantly reduces the number of TCP packets
-	// and system calls, which is better for performance
-	proto::logging::LogBatch batch;
+	// records only grow once their trace is formatted
+	std::vector<Pending> taken;
 	{
 		std::lock_guard lock(m.queue_mutex);
-		while (!m.log_queue.empty()) {
-			auto* new_log = batch.add_logs();
-			*new_log = std::move(m.log_queue.front());
+		std::size_t untraced_bytes = 0;
+		while (!m.log_queue.empty() && (taken.empty() || untraced_bytes < max_bytes)) {
+			untraced_bytes += m.log_queue.front().data.ByteSizeLong();
+			taken.push_back(std::move(m.log_queue.front()));
 			m.log_queue.pop_front();
 		}
 	}
 
-	if (batch.logs_size() == 0) {
+	if (taken.empty()) {
 		return {};
 	}
 
+	// Batching logs together significantly reduces the number of TCP packets
+	// and system calls, which is better for performance
+	// symbols resolve outside the lock
+	proto::logging::LogBatch batch;
+	std::size_t batch_bytes = 0;
+	std::size_t used = 0;
+	for (; used < taken.size(); ++used) {
+		proto::logging::LogData& data = taken[used].data;
+		data.set_backtrace(sanitizeField(formatBacktrace(taken[used].trace)));
+
+		// tag length and record
+		const std::size_t data_bytes = data.ByteSizeLong();
+		const std::size_t entry_bytes = 1 + google::protobuf::io::CodedOutputStream::VarintSize64(data_bytes) + data_bytes;
+		if (used > 0 && batch_bytes + entry_bytes > max_bytes) {
+			break;
+		}
+		batch_bytes += entry_bytes;
+		*batch.add_logs() = std::move(data);
+	}
+	// a failed write loses them too
+	m.sent.fetch_add(used, std::memory_order_relaxed);
+
+	if (used < taken.size()) {
+		// what did not fit goes back in front
+		std::lock_guard lock(m.queue_mutex);
+		m.log_queue.insert(
+		    m.log_queue.begin(),
+		    std::make_move_iterator(taken.begin() + static_cast<std::ptrdiff_t>(used)),
+		    std::make_move_iterator(taken.end())
+		);
+	}
+
 	std::vector<uint8_t> buffer(batch.ByteSizeLong());
-	batch.SerializeToArray(buffer.data(), buffer.size());
+	batch.SerializeToArray(buffer.data(), static_cast<int>(buffer.size()));
 	return buffer;
 }
 
+auto Logger::writeFrame(const std::vector<uint8_t>& payload) -> asio::error_code {
+	assert(!payload.empty() && "a frame of length 0 is the goodbye");
+
+	uint32_t len = static_cast<uint32_t>(payload.size());
+	std::array<uint8_t, 4> len_buf;
+	len_buf[0] = (len >> 24) & 0xFF;
+	len_buf[1] = (len >> 16) & 0xFF;
+	len_buf[2] = (len >> 8) & 0xFF;
+	len_buf[3] = len & 0xFF;
+
+	std::array<asio::const_buffer, 2> bufs = {asio::buffer(len_buf, 4), asio::buffer(payload)};
+	asio::error_code ec;
+	asio::write(m.socket, bufs, ec);
+	return ec;
+}
+
 void Logger::flush() noexcept {
 	auto* logger = instance;
-	if (logger == nullptr) {
+	// t_sending avoids locking send_mutex twice
+	if (logger == nullptr || t_sending || logger->m.stopped.load(std::memory_order_acquire)) {
 		return;
 	}
 
-	// Holding the drain slot keeps a pool drain off the socket. Bounded since the pool may be stuck on the caller
-	constexpr auto k_timeout = std::chrono::milliseconds(500);
-	const auto deadline = std::chrono::steady_clock::now() + k_timeout;
-	while (logger->m.drain_pending.exchange(true, std::memory_order_acq_rel)) {
-		if (std::chrono::steady_clock::now() > deadline) {
+	try {
+		// only what is queued now
+		uint64_t target = 0;
+		{
+			std::lock_guard lock(logger->m.queue_mutex);
+			target = logger->m.enqueued;
+		}
+
+		// the socket has its own lock so a drain job cannot hold this up
+		constexpr auto k_timeout = std::chrono::milliseconds(500);
+		const auto deadline = std::chrono::steady_clock::now() + k_timeout;
+		std::unique_lock<std::timed_mutex> send_lock(logger->m.send_mutex, std::defer_lock);
+		if (!send_lock.try_lock_until(deadline)) {
 			return;
 		}
-		std::this_thread::yield();
+		const SendingScope sending;
+		if (!logger->m.stopped.load(std::memory_order_acquire)) {
+			logger->flushSync(target, deadline);
+		}
+	} catch (...) { (void)0; }
+}
+
+void Logger::crashFlush(std::string_view reason, const RawBacktrace& trace) noexcept {
+	auto* logger = instance;
+	if (logger == nullptr) {
+		return;
 	}
+
 	try {
-		logger->flushSync();
+		proto::logging::LogData data;
+		data.set_timestamp(
+		    std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count()
+		);
+		data.set_severity(static_cast<proto::logging::LogData_Severity>(4));
+		data.set_sink("Crash");
+		data.set_message(sanitizeField(reason));
+		{
+			std::lock_guard lock(logger->m.queue_mutex);
+			logger->m.log_queue.push_back({.data = std::move(data), .trace = trace});
+			++logger->m.enqueued;
+		}
+
+		// the sending thread owns the promise
+		std::promise<void> done;
+		auto finished = done.get_future();
+		std::thread([promise = std::move(done)]() mutable {
+			flush();
+			promise.set_value();
+		}).detach();
+		finished.wait_for(std::chrono::milliseconds(1000));
 	} catch (...) { (void)0; }
-	logger->m.drain_pending.store(false, std::memory_order_release);
 }
 
-void Logger::flushSync() {
+void Logger::flushSync(uint64_t target, std::chrono::steady_clock::time_point deadline) {
 	ZoneScoped;
 
-	auto batch = collectQueue();
-	if (!batch.empty() && m.connected.load(std::memory_order_acquire) && m.socket.is_open()) {
-		uint32_t len = static_cast<uint32_t>(batch.size());
-		std::array<uint8_t, 4> len_buf;
-		len_buf[0] = (len >> 24) & 0xFF;
-		len_buf[1] = (len >> 16) & 0xFF;
-		len_buf[2] = (len >> 8) & 0xFF;
-		len_buf[3] = len & 0xFF;
+	// errors flush while the connection may not be up yet
+	if (!m.connected.load(std::memory_order_acquire) || !m.socket.is_open()) {
+		return;
+	}
 
-		std::array<asio::const_buffer, 2> bufs = {asio::buffer(len_buf, 4), asio::buffer(batch)};
-		asio::error_code ec;
-		asio::write(m.socket, bufs, ec);
+	while (m.sent.load(std::memory_order_relaxed) < target && std::chrono::steady_clock::now() < deadline) {
+		// an empty batch reads as the goodbye
+		const std::vector<uint8_t> batch = collectQueue(k_max_frame_bytes);
+		if (batch.empty()) {
+			return;
+		}
+		// a failed write is usually the send timeout so stop here
+		if (writeFrame(batch)) {
+			return;
+		}
 	}
 }
 
@@ -492,4 +716,8 @@ void toast_error(const char* sink, const char* message, const char* file, unsign
 void toast_critical(const char* sink, const char* message, const char* file, unsigned line) noexcept {
 	Logger::log(file, line, 4, sink, message);
 }
+
+void toast_log_invalidate_backtraces() noexcept {
+	invalidateBacktraceCache();
+}
 }
diff --git a/engine/src/toast/logger.hpp b/engine/src/toast/logger.hpp
index 426f6d7cb..1fd3bd04a 100644
--- a/engine/src/toast/logger.hpp
+++ b/engine/src/toast/logger.hpp
@@ -10,13 +10,17 @@
 
 #pragma once
 
+#include "backtrace.hpp"
 #include "generated/logging.pb.h"
 
 #include <asio.hpp>
 #include <atomic>
 #include <cassert>
+#include <chrono>
+#include <cstddef>
 #include <cstdint>
 #include <deque>
+#include <limits>
 #include <memory>
 #include <mutex>
 #include <string_view>
@@ -24,6 +28,12 @@
 
 namespace logging {
 
+/// log plus its raw trace
+struct Pending {
+	proto::logging::LogData data;
+	RawBacktrace trace;
+};
+
 class Logger {
 	inline static Logger* instance = nullptr;
 
@@ -31,14 +41,20 @@ class Logger {
 		asio::io_context io_ctx;
 		asio::ip::tcp::socket socket {io_ctx};
 
-		std::deque<proto::logging::LogData> log_queue;
+		// send_mutex before queue_mutex
+
+		std::deque<Pending> log_queue;
 		std::mutex queue_mutex;
+		/// records ever queued
+		uint64_t enqueued = 0;
+
+		/// held while writing to the socket
+		std::timed_mutex send_mutex;
+		std::atomic<uint64_t> sent = 0;       ///< records that left the queue
+		std::atomic<bool> stopped = false;    ///< set by stop
 
 		/**
-		 * @brief Prevents multiple background jobs from fighting over the same socket
-		 *
-		 * We use an atomic flag to ensure only one 'drain' job is scheduled at a time,
-		 * avoiding unnecessary context switches and thread contention.
+		 * @brief Means a drain job is queued or running
 		 */
 		std::atomic<bool> drain_pending = false;
 
@@ -57,6 +73,7 @@ class Logger {
 	static constexpr uint16_t port = 12800;                ///< Port to connect to the server
 	static constexpr bool auto_spawn_log_server = true;    ///< Decides if the engine should create a log server or not
 	static constexpr bool show_server_logs = false;        ///< If true, log server consoole will also appear on the terminal
+	static constexpr std::size_t k_max_frame_bytes = 4 * 1024 * 1024;    ///< largest batch per frame
 
 public:
 	/**
@@ -83,19 +100,33 @@ class Logger {
 	 * Thread-safe. It pushes the log to a local queue and signals a background
 	 * task to handle the actual network I/O
 	 */
-	static void log(std::string_view file, unsigned line, char severity, std::string_view sink, std::string_view message);
+	static void
+	    log(std::string_view file, unsigned line, char severity, std::string_view sink, std::string_view message,
+			    std::string_view details = {});
 
-	/// Blocks until the queue reached the socket or the background drain stayed busy too long
+	/// sends what is queued on the calling thread
 	static void flush() noexcept;
 
+	/// logs a crash and sends everything queued
+	static void crashFlush(std::string_view reason, const RawBacktrace& trace) noexcept;
+
 private:
 	Logger() = default;
 
 	void initNetworkRetry();    ///< @brief Tries to establish a connection, retrying if the server isn't ready
 	void stop();                ///< @brief Blocks until the background work finishes to avoid data races during shutdown
 	void drain();               ///< @brief Background worker that batches queued logs and sends them
-	auto collectQueue() -> std::vector<uint8_t>;    ///< @brief Pulls everything from the queue and turns it into a bit buffer
-	void flushSync();    ///< @brief Synchronous fallback for when we can't rely on background threads (like shutdown)
+	/// pulls queued records into a batch
+	auto collectQueue(std::size_t max_bytes) -> std::vector<uint8_t>;
+	/// never sends an empty payload
+	auto writeFrame(const std::vector<uint8_t>& payload) -> asio::error_code;
+	/**
+	 * @brief Synchronous fallback for when we can't rely on background threads (like shutdown)
+	 */
+	void flushSync(
+	    uint64_t target = std::numeric_limits<uint64_t>::max(),
+	    std::chrono::steady_clock::time_point deadline = std::chrono::steady_clock::time_point::max()
+	);
 };
 
 }
diff --git a/engine/src/toast/renderer/shader_compiler.cpp b/engine/src/toast/renderer/shader_compiler.cpp
index 06d16070d..8c53df62a 100644
--- a/engine/src/toast/renderer/shader_compiler.cpp
+++ b/engine/src/toast/renderer/shader_compiler.cpp
@@ -203,7 +203,7 @@ void logDiagnostics(const Slang::ComPtr<slang::IBlob>& diagnostics, std::string_
 	if (diag_ptr && diag_size > 0) {
 		const char* diag_c = reinterpret_cast<const char*>(diag_ptr);
 		const std::string diag_str(diag_c, diag_c + diag_size);
-		TOAST_ERROR("Render", "Slang diagnostics for '{}':\n{}", source_name, diag_str);
+		TOAST_MESSAGE(logging::Severity::error, "Render", std::format("Slang diagnostics for '{}'", source_name), diag_str);
 	}
 }
 
diff --git a/engine/src/toast/renderer/vulkan_core.cpp b/engine/src/toast/renderer/vulkan_core.cpp
index d81215f35..5df7cd4c1 100644
--- a/engine/src/toast/renderer/vulkan_core.cpp
+++ b/engine/src/toast/renderer/vulkan_core.cpp
@@ -171,22 +171,20 @@ auto debugCallback(
 	}
 
 	const char* message = (p_callback_data != nullptr && p_callback_data->pMessage != nullptr) ? p_callback_data->pMessage : "";
+	logging::Severity severity = logging::Severity::trace;
 	switch (message_severity) {
-		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
-			TOAST_TRACE("ValidationLayers", "[Vulkan Validation] [{}]: {}", message_type_string, message);
-			break;
-		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
-			TOAST_INFO("ValidationLayers", "[Vulkan Validation] [{}]: {}", message_type_string, message);
-			break;
-		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
-			TOAST_WARN("ValidationLayers", "[Vulkan Validation] [{}]: {}", message_type_string, message);
-			break;
-		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
-			TOAST_ERROR("ValidationLayers", "[Vulkan Validation] [{}]: {}", message_type_string, message);
-			break;
-		default: break;
+		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: severity = logging::Severity::trace; break;
+		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: severity = logging::Severity::info; break;
+		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: severity = logging::Severity::warning; break;
+		case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: severity = logging::Severity::error; break;
+		default: return VK_FALSE;
 	}
 
+	// The first line is the problem, the rest is the layer's explanation and the spec link
+	const auto [summary, body] = logging::splitFirstLine(message);
+	const std::string line = std::format("[Vulkan Validation] [{}]: {}", message_type_string, summary);
+	TOAST_MESSAGE(severity, "ValidationLayers", line, body);
+
 	return VK_FALSE;
 }
 
@@ -522,9 +520,13 @@ void VulkanCore::pickPhysicalDevice(std::span<const char* const> required_device
 		for (std::size_t i = 0; i < queues.size(); ++i) {
 			TOAST_TRACE("Render", "    Queue family {} | flags:{}", i, formatQueueFlags(queues[i].queueFlags));
 		}
-		TOAST_TRACE("Render", "  Extensions: {}", joinExtensions(extensions));
+		TOAST_MESSAGE(
+		    logging::Severity::trace, "Render", std::format("  Device extensions ({})", extensions.size()), joinExtensions(extensions)
+		);
 
-		TOAST_TRACE("Render", "  {}", device_score.toString());
+		TOAST_MESSAGE(
+		    logging::Severity::trace, "Render", std::format("  Device score: {}", device_score.total), device_score.toString()
+		);
 
 		if (!device_score.missing_extensions.empty()) {
 			std::string missing;
diff --git a/engine/src/toast/scripting/lua_state.cpp b/engine/src/toast/scripting/lua_state.cpp
index 00432c61a..656c7e61a 100644
--- a/engine/src/toast/scripting/lua_state.cpp
+++ b/engine/src/toast/scripting/lua_state.cpp
@@ -507,7 +507,12 @@ LuaState::LuaState() : m_pool_size(1 + toast::ThreadPool::workerCount()), m_entr
 		lua_atpanic(entry.state, [](auto* state) -> int {
 			const char* message = lua_tostring(state, -1);
 			luaL_traceback(state, state, message ? message : "(non-string error)", 0);
-			TOAST_ERROR("Lua", "Panic: {}\n{}", message ? message : "(non-string error)", lua_tostring(state, -1));
+			TOAST_MESSAGE(
+			    logging::Severity::error,
+			    "Lua",
+			    std::format("Panic: {}", message ? message : "(non-string error)"),
+			    std::string_view(lua_tostring(state, -1))
+			);
 			return 0;
 		});
 
diff --git a/engine/src/toast/window/sdl_window.cpp b/engine/src/toast/window/sdl_window.cpp
index 7d223c35d..d7ffcfe66 100644
--- a/engine/src/toast/window/sdl_window.cpp
+++ b/engine/src/toast/window/sdl_window.cpp
@@ -58,7 +58,8 @@ namespace toast {
 
 SDLWindow::SDLWindow(const char* title, unsigned width, unsigned height, uint64_t flags) {
 	ZoneScoped;
-	TOAST_ASSERT(SDL_Init(SDL_INIT_VIDEO) == true, "Window", "SDL cannot be initialized");
+	const bool sdl_initialized = SDL_Init(SDL_INIT_VIDEO);
+	TOAST_ASSERT(sdl_initialized, "Window", "SDL cannot be initialized");
 
 	if ((flags & SDL_WINDOW_VULKAN) != 0) {
 		const char* video_driver = SDL_GetCurrentVideoDriver();
diff --git a/protos/logging.proto b/protos/logging.proto
index 7a8c7531b..651c353e1 100644
--- a/protos/logging.proto
+++ b/protos/logging.proto
@@ -18,6 +18,8 @@ message LogData {
 
   string sink = 5;
   string message = 6;
+  string details = 7;
+  string backtrace = 8;
 }
 
 message LogBatch {
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index 72c4fd513..5837af56f 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -1,14 +1,33 @@
 add_subdirectory(player)
 add_subdirectory(dummy_game)
-add_subdirectory(kenzo)
 add_subdirectory(log_server)
 add_subdirectory(reflection_generator)
 add_subdirectory(asset_packer)
 add_subdirectory(crash_reporter)
 
+if (NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/kenzo/CMakeLists.txt")
+    message(FATAL_ERROR "kenzo submodule is empty, run git submodule update --init")
+endif ()
+
+set(KENZO_ARGS -G "${CMAKE_GENERATOR}" -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} -DCMAKE_BUILD_TYPE=$<CONFIG>)
+if (CMAKE_GENERATOR_PLATFORM)
+    list(APPEND KENZO_ARGS -A ${CMAKE_GENERATOR_PLATFORM})
+endif ()
+if (WIN32)
+    list(APPEND KENZO_ARGS -DVCPKG_TARGET_TRIPLET=x64-windows-static)
+endif ()
+foreach (config IN ITEMS Debug Release RelWithDebInfo MinSizeRel)
+    string(TOUPPER "${config}" config_upper)
+    list(APPEND KENZO_ARGS -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_${config_upper}=${OUTPUT_ROOT}/${config}/kenzo)
+endforeach ()
+
+add_custom_target(kenzo ALL
+        COMMAND ${CMAKE_COMMAND} -S "${CMAKE_CURRENT_SOURCE_DIR}/kenzo" -B "${OUTPUT_ROOT}/$<CONFIG>/kenzo-build" ${KENZO_ARGS}
+        COMMAND ${CMAKE_COMMAND} --build "${OUTPUT_ROOT}/$<CONFIG>/kenzo-build" --config $<CONFIG> --target kenzo
+        COMMENT "Building kenzo"
+        VERBATIM
+)
 
-add_dependencies(kenzo log_server)
-add_dependencies(packer kenzo)
 add_dependencies(reflection_generator packer)
 
 if (BUILD_TESTING)
diff --git a/tools/kenzo b/tools/kenzo
new file mode 160000
index 000000000..1b84ad362
--- /dev/null
+++ b/tools/kenzo
@@ -0,0 +1 @@
+Subproject commit 1b84ad362b75d6accb5b2b1a65d704b85e45bb2e
diff --git a/tools/kenzo/CMakeLists.txt b/tools/kenzo/CMakeLists.txt
deleted file mode 100644
index f64fad196..000000000
--- a/tools/kenzo/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-project(kenzo NONE)
-
-set(CARGO_PROJECT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-set(CARGO_TARGET_DIR "${OUTPUT_ROOT}/$<CONFIG>/cargo")
-set(CARGO_PROFILE_NAME "$<IF:$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>,release,debug>")
-set(CARGO_PROFILE_FLAG "$<IF:$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>,release,dev>")
-
-find_program(CARGO_EXECUTABLE cargo REQUIRED)
-message(STATUS "Found cargo: ${CARGO_EXECUTABLE}")
-message(STATUS "Build configuration: ${CARGO_PROFILE_NAME}")
-message(STATUS "Cargo target directory: ${CARGO_TARGET_DIR}")
-
-add_custom_target(kenzo ALL
-        COMMAND ${CARGO_EXECUTABLE} build --profile "${CARGO_PROFILE_FLAG}" --target-dir "${CARGO_TARGET_DIR}"
-        COMMAND ${CMAKE_COMMAND}
-            -DCARGO_TARGET_DIR=${CARGO_TARGET_DIR}
-            -DPROFILE_NAME=${CARGO_PROFILE_NAME}
-            "-DBINARY_NAMES=kenzo"
-            -DEXE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
-            -DDEST_DIR=${OUTPUT_ROOT}/$<CONFIG>/kenzo
-            -P ${CMAKE_SOURCE_DIR}/cmake/install_cargo_output.cmake
-        WORKING_DIRECTORY ${CARGO_PROJECT_DIR}
-        COMMENT "[cargo] Building kenzo (${CARGO_PROFILE_NAME})..."
-        VERBATIM
-)
diff --git a/tools/kenzo/Cargo.toml b/tools/kenzo/Cargo.toml
deleted file mode 100644
index 347e238d4..000000000
--- a/tools/kenzo/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "kenzo"
-version = "0.1.0"
-edition = "2021"
-
-[[bin]]
-name = "kenzo"
-path = "src/main.rs"
-
-[dependencies]
-anyhow = "1.0"
-chrono = "0.4"
-clap = { version = "4", features = ["derive"] }
-csv = "1.3.1"
-crossterm = "0.28.1"
-ratatui = "0.29.0"
-prost = "0.14"
-prost-types = "0.13.5"
-textwrap = "0.16"
-tokio = { version = "1", features = ["full"] }
-tui-input = "0.11"
diff --git a/tools/kenzo/src/app.rs b/tools/kenzo/src/app.rs
deleted file mode 100644
index 8ef2a3227..000000000
--- a/tools/kenzo/src/app.rs
+++ /dev/null
@@ -1,743 +0,0 @@
-use crate::proto::{LogBatch, LogData};
-use crate::tui::Tui;
-use anyhow::Result;
-use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
-use prost::Message;
-use std::time::Duration;
-use tokio::io::AsyncReadExt;
-use tokio::net::TcpStream;
-use tokio::sync::mpsc;
-use tui_input::backend::crossterm::EventHandler;
-use tui_input::Input;
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum Severity {
-    Trace = 0,
-    Info = 1,
-    Warning = 2,
-    Error = 3,
-    Critical = 4,
-}
-
-impl From<i32> for Severity {
-    fn from(i: i32) -> Self {
-        match i {
-            0 => Severity::Trace,
-            1 => Severity::Info,
-            2 => Severity::Warning,
-            3 => Severity::Error,
-            4 => Severity::Critical,
-            _ => Severity::Info,
-        }
-    }
-}
-
-#[derive(PartialEq, Debug, Clone)]
-pub enum ConnectionState {
-    Disconnected,
-    Connecting(String),   // Address
-    Reconnecting(String), // Address
-    Connected,
-    #[allow(dead_code)]
-    CsvMode(String), // Path
-}
-
-#[derive(PartialEq, Debug, Clone, Copy)]
-pub enum AppFocus {
-    Table,
-    Search,
-    FilterSeverity,
-    FilterSink,
-}
-
-#[derive(PartialEq, Debug, Clone, Copy)]
-pub enum PopupOption {
-    Localhost,
-    RemoteIp,
-    CsvFile,
-}
-
-pub struct App {
-    pub logs: Vec<LogData>,
-    pub filtered_logs: Vec<usize>, // Indices of logs that match filters
-    pub display_rows: Vec<(usize, usize)>, // Maps display row to (log_idx, chunk_idx) for split messages
-    pub state: ConnectionState,
-    pub popup_selection: PopupOption,
-    pub input_buffer: Input,
-    pub spinner_frame: usize,
-
-    // Filters & Search
-    pub search_query: String,
-    pub show_filters: bool,
-    pub excluded_severities: std::collections::HashSet<i32>,
-    pub excluded_sinks: std::collections::HashSet<String>,
-    pub seen_severities: std::collections::HashSet<i32>,
-    pub seen_sinks: std::collections::HashSet<String>,
-
-    // Search navigation
-    pub search_matches: Vec<usize>, // indices into filtered_logs, not logs; must be recalculated when filters change
-    pub current_match_idx: Option<usize>,
-
-    // Scrolling
-    pub scroll_locked: bool, // true = user is scrolling manually; false = view auto-follows newest log
-    pub wrap_logs: bool,
-
-    // Navigation
-    pub table_state: ratatui::widgets::TableState,
-    pub severity_list_state: ratatui::widgets::ListState,
-    pub sink_list_state: ratatui::widgets::ListState,
-    pub focus: AppFocus,
-    
-    // Detail view
-    pub detail_view_open: bool,
-    pub detail_view_log_idx: Option<usize>,
-    pub detail_view_scroll: usize,
-
-    // Communication
-    pub log_rx: Option<mpsc::Receiver<Vec<LogData>>>,
-    pub stop_tx: Option<tokio::sync::oneshot::Sender<()>>,
-
-    // Reconnection
-    pub last_connect_addr: Option<String>,
-
-    // Control
-    pub should_exit: bool,
-}
-
-impl App {
-    pub fn new(csv_path: Option<String>) -> Self {
-        let mut app = Self {
-            logs: Vec::new(),
-            filtered_logs: Vec::new(),
-            display_rows: Vec::new(),
-            state: ConnectionState::Disconnected,
-            popup_selection: PopupOption::Localhost,
-            input_buffer: Input::default(),
-            spinner_frame: 0,
-            search_query: String::new(),
-            show_filters: false,
-            excluded_severities: std::collections::HashSet::new(),
-            excluded_sinks: std::collections::HashSet::new(),
-            seen_severities: std::collections::HashSet::new(),
-            seen_sinks: std::collections::HashSet::new(),
-            search_matches: Vec::new(),
-            current_match_idx: None,
-            scroll_locked: false,
-            wrap_logs: true,
-            table_state: ratatui::widgets::TableState::default(),
-            severity_list_state: ratatui::widgets::ListState::default(),
-            sink_list_state: ratatui::widgets::ListState::default(),
-            focus: AppFocus::Table,
-            detail_view_open: false,
-            detail_view_log_idx: None,
-            detail_view_scroll: 0,
-            log_rx: None,
-            stop_tx: None,
-            last_connect_addr: None,
-            should_exit: false,
-        };
-
-        if let Some(path) = csv_path {
-            app.load_csv(&path);
-        }
-
-        app
-    }
-
-    pub async fn run(&mut self, terminal: &mut Tui) -> Result<()> {
-        let tick_rate = Duration::from_millis(100);
-        let mut last_tick = std::time::Instant::now();
-
-        if let ConnectionState::Disconnected = self.state {
-            self.connect("127.0.0.1:12801".to_string()).await;
-        }
-
-        loop {
-            // Draw
-            terminal.draw(|f| crate::ui::draw(f, self))?;
-
-            // Check if we should exit
-            if self.should_exit {
-                break Ok(());
-            }
-
-            // Handle Network Events
-            let mut batches = Vec::new();
-            if let Some(rx) = &mut self.log_rx {
-                while let Ok(batch) = rx.try_recv() {
-                    batches.push(batch);
-                }
-            }
-
-            if !batches.is_empty() {
-                // Transition from Connecting to Connected on first batch (even if empty)
-                if let ConnectionState::Connecting(_) | ConnectionState::Reconnecting(_) =
-                    self.state
-                {
-                    self.state = ConnectionState::Connected;
-                }
-
-                for batch in batches {
-                    for log in batch {
-                        self.process_log(log);
-                    }
-                }
-                self.update_filtered_logs();
-            }
-
-            // Handle Input
-            let timeout = tick_rate
-                .checked_sub(last_tick.elapsed())
-                .unwrap_or_else(|| Duration::from_secs(0));
-
-            if crossterm::event::poll(timeout)? {
-                if let Event::Key(key) = event::read()? {
-                    if key.kind == KeyEventKind::Press
-                        || (key.kind == KeyEventKind::Repeat
-                            && matches!(
-                                key.code,
-                                KeyCode::Char('h')
-                                    | KeyCode::Char('j')
-                                    | KeyCode::Char('k')
-                                    | KeyCode::Char('l')
-                                    | KeyCode::Up
-                                    | KeyCode::Down
-                                    | KeyCode::Left
-                                    | KeyCode::Right
-                            ))
-                    {
-                        self.handle_key(key).await?;
-                    }
-                }
-            }
-
-            if last_tick.elapsed() >= tick_rate {
-                self.on_tick();
-                last_tick = std::time::Instant::now();
-            }
-
-            if let Some(rx) = &mut self.log_rx {
-                if rx.is_closed() {
-                    // Auto-reconnect if we were connected or connecting
-                    if let (
-                        ConnectionState::Connected
-                        | ConnectionState::Connecting(_)
-                        | ConnectionState::Reconnecting(_),
-                        Some(addr),
-                    ) = (&self.state, &self.last_connect_addr)
-                    {
-                        self.reconnect(addr.clone()).await;
-                    } else {
-                        self.disconnect();
-                    }
-                }
-            }
-        }
-    }
-
-    fn on_tick(&mut self) {
-        self.spinner_frame = (self.spinner_frame + 1) % 10;
-    }
-
-    async fn handle_key(&mut self, key: KeyEvent) -> Result<()> {
-        if key.modifiers.contains(KeyModifiers::SHIFT) {
-            match key.code {
-                KeyCode::Char('H') | KeyCode::Left => self.focus = AppFocus::FilterSeverity,
-                KeyCode::Char('L') | KeyCode::Right => self.focus = AppFocus::Table,
-                KeyCode::Char('J') | KeyCode::Down => self.focus = AppFocus::FilterSink,
-                KeyCode::Char('K') | KeyCode::Up => self.focus = AppFocus::FilterSeverity,
-                _ => {}
-            }
-            if self.focus == AppFocus::FilterSeverity || self.focus == AppFocus::FilterSink {
-                self.show_filters = true;
-            }
-        }
-
-        match &self.state {
-            ConnectionState::Disconnected | ConnectionState::Connecting(_) => {
-                self.handle_disconnected_key(key).await
-            }
-            ConnectionState::Connected
-            | ConnectionState::CsvMode(_)
-            | ConnectionState::Reconnecting(_) => self.handle_connected_key(key).await,
-        }
-    }
-
-    async fn handle_disconnected_key(&mut self, key: KeyEvent) -> Result<()> {
-        match key.code {
-            KeyCode::Char('q') => {
-                self.should_exit = true;
-            }
-            KeyCode::Esc => {
-                self.input_buffer = Input::default();
-            }
-            KeyCode::Up | KeyCode::Char('k') => {
-                self.popup_selection = match self.popup_selection {
-                    PopupOption::Localhost => PopupOption::CsvFile,
-                    PopupOption::RemoteIp => PopupOption::Localhost,
-                    PopupOption::CsvFile => PopupOption::RemoteIp,
-                };
-            }
-            KeyCode::Down | KeyCode::Char('j') => {
-                self.popup_selection = match self.popup_selection {
-                    PopupOption::Localhost => PopupOption::RemoteIp,
-                    PopupOption::RemoteIp => PopupOption::CsvFile,
-                    PopupOption::CsvFile => PopupOption::Localhost,
-                };
-            }
-            KeyCode::Enter => match self.popup_selection {
-                PopupOption::Localhost => self.connect("127.0.0.1:12801".to_string()).await,
-                PopupOption::RemoteIp => {
-                    let ip = self.input_buffer.value().to_string();
-                    if !ip.is_empty() {
-                        self.connect(format!("{}:12801", ip)).await;
-                    }
-                }
-                PopupOption::CsvFile => {
-                    let path = self.input_buffer.value().to_string();
-                    if !path.is_empty() {
-                        self.load_csv(&path);
-                    }
-                }
-            },
-            _ => match self.popup_selection {
-                PopupOption::RemoteIp | PopupOption::CsvFile => {
-                    self.input_buffer.handle_event(&Event::Key(key));
-                }
-                _ => {}
-            },
-        }
-        Ok(())
-    }
-
-    async fn handle_connected_key(&mut self, key: KeyEvent) -> Result<()> {
-        if self.detail_view_open {
-            match key.code {
-                KeyCode::Esc => self.close_detail_view(),
-                KeyCode::Char('q') => self.close_detail_view(),
-                KeyCode::Down | KeyCode::Char('j') => {
-                    self.scroll_detail_view_down(10000); // Max scrollable (will be clamped in render)
-                }
-                KeyCode::Up | KeyCode::Char('k') => self.scroll_detail_view_up(),
-                _ => {}
-            }
-            return Ok(());
-        }
-
-        if self.focus == AppFocus::Search {
-            match key.code {
-                KeyCode::Enter => self.focus = AppFocus::Table,
-                KeyCode::Esc => {
-                    self.search_query.clear();
-                    self.focus = AppFocus::Table;
-                    self.update_filtered_logs();
-                }
-                KeyCode::Backspace => {
-                    self.search_query.pop();
-                    self.update_filtered_logs();
-                }
-                KeyCode::Char(c) => {
-                    self.search_query.push(c);
-                    self.update_filtered_logs();
-                }
-                _ => {}
-            }
-            return Ok(());
-        }
-
-        match key.code {
-            KeyCode::Char('q') => {
-                self.disconnect();
-            }
-            KeyCode::Char('v') => self.open_detail_view(),
-            KeyCode::Char('/') => self.focus = AppFocus::Search,
-            KeyCode::Char('f') => {
-                self.show_filters = !self.show_filters;
-                if !self.show_filters {
-                    self.focus = AppFocus::Table;
-                }
-            }
-            KeyCode::Char('s') => {
-                self.scroll_locked = !self.scroll_locked;
-                if !self.scroll_locked {
-                    self.jump_to_latest();
-                }
-            }
-            KeyCode::Char('w') => {
-                self.wrap_logs = !self.wrap_logs;
-            }
-            KeyCode::Char('n') => self.next_match(),
-            KeyCode::Char('p') => self.prev_match(),
-            KeyCode::Char('1') => self.toggle_severity(0),
-            KeyCode::Char('2') => self.toggle_severity(1),
-            KeyCode::Char('3') => self.toggle_severity(2),
-            KeyCode::Char('4') => self.toggle_severity(3),
-            KeyCode::Char('5') => self.toggle_severity(4),
-            KeyCode::Char('j') | KeyCode::Down => self.move_down(),
-            KeyCode::Char('k') | KeyCode::Up => self.move_up(),
-            KeyCode::Enter | KeyCode::Char(' ') => self.toggle_selection(),
-            KeyCode::Esc => {
-                if !self.search_query.is_empty() {
-                    self.search_query.clear();
-                    self.update_filtered_logs();
-                }
-            }
-            _ => {}
-        }
-        Ok(())
-    }
-
-    fn move_down(&mut self) {
-        match self.focus {
-            AppFocus::Table => {
-                self.scroll_locked = true;
-                let i = match self.table_state.selected() {
-                    Some(i) => (i + 1).min(self.display_rows.len().saturating_sub(1)),
-                    None => 0,
-                };
-                self.table_state.select(Some(i));
-            }
-            AppFocus::FilterSeverity => {
-                let i = match self.severity_list_state.selected() {
-                    Some(i) => (i + 1).min(self.seen_severities.len().saturating_sub(1)),
-                    None => 0,
-                };
-                self.severity_list_state.select(Some(i));
-            }
-            AppFocus::FilterSink => {
-                let i = match self.sink_list_state.selected() {
-                    Some(i) => (i + 1).min(self.seen_sinks.len().saturating_sub(1)),
-                    None => 0,
-                };
-                self.sink_list_state.select(Some(i));
-            }
-            _ => {}
-        }
-    }
-
-    fn move_up(&mut self) {
-        match self.focus {
-            AppFocus::Table => {
-                self.scroll_locked = true;
-                let i = match self.table_state.selected() {
-                    Some(i) => i.saturating_sub(1),
-                    None => 0,
-                };
-                self.table_state.select(Some(i));
-            }
-            AppFocus::FilterSeverity => {
-                let i = match self.severity_list_state.selected() {
-                    Some(i) => i.saturating_sub(1),
-                    None => 0,
-                };
-                self.severity_list_state.select(Some(i));
-            }
-            AppFocus::FilterSink => {
-                let i = match self.sink_list_state.selected() {
-                    Some(i) => i.saturating_sub(1),
-                    None => 0,
-                };
-                self.sink_list_state.select(Some(i));
-            }
-            _ => {}
-        }
-    }
-
-    fn toggle_severity(&mut self, sev: i32) {
-        if self.excluded_severities.contains(&sev) {
-            self.excluded_severities.remove(&sev);
-        } else {
-            self.excluded_severities.insert(sev);
-        }
-        self.update_filtered_logs();
-    }
-
-    fn toggle_selection(&mut self) {
-        match self.focus {
-            AppFocus::FilterSeverity => {
-                if let Some(i) = self.severity_list_state.selected() {
-                    let mut sevs: Vec<_> = self.seen_severities.iter().collect();
-                    sevs.sort();
-                    if let Some(&sev) = sevs.get(i) {
-                        if self.excluded_severities.contains(sev) {
-                            self.excluded_severities.remove(sev);
-                        } else {
-                            self.excluded_severities.insert(*sev);
-                        }
-                        self.update_filtered_logs();
-                    }
-                }
-            }
-            AppFocus::FilterSink => {
-                if let Some(i) = self.sink_list_state.selected() {
-                    let mut sinks: Vec<_> = self.seen_sinks.iter().collect();
-                    sinks.sort();
-                    if let Some(&sink) = sinks.get(i) {
-                        if self.excluded_sinks.contains(sink) {
-                            self.excluded_sinks.remove(sink);
-                        } else {
-                            self.excluded_sinks.insert(sink.clone());
-                        }
-                        self.update_filtered_logs();
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn next_match(&mut self) {
-        if self.search_matches.is_empty() {
-            return;
-        }
-        let next_match_idx = match self.current_match_idx {
-            Some(i) => (i + 1) % self.search_matches.len(),
-            None => 0,
-        };
-        self.current_match_idx = Some(next_match_idx);
-        self.scroll_locked = true;
-        self.table_state
-            .select(Some(self.search_matches[next_match_idx]));
-    }
-
-    fn prev_match(&mut self) {
-        if self.search_matches.is_empty() {
-            return;
-        }
-        let prev_match_idx = match self.current_match_idx {
-            Some(i) => {
-                if i == 0 {
-                    self.search_matches.len() - 1
-                } else {
-                    i - 1
-                }
-            }
-            None => self.search_matches.len() - 1,
-        };
-        self.current_match_idx = Some(prev_match_idx);
-        self.scroll_locked = true;
-        self.table_state
-            .select(Some(self.search_matches[prev_match_idx]));
-    }
-
-    async fn connect(&mut self, addr: String) {
-        self.disconnect();
-        self.state = ConnectionState::Connecting(addr.clone());
-        self.last_connect_addr = Some(addr.clone());
-        let (tx, rx) = mpsc::channel(100);
-        let (stop_tx, mut stop_rx) = tokio::sync::oneshot::channel();
-
-        self.log_rx = Some(rx);
-        self.stop_tx = Some(stop_tx);
-
-        let addr_clone = addr.clone();
-        tokio::spawn(async move {
-            match TcpStream::connect(&addr_clone).await {
-                Ok(mut socket) => {
-                    // empty batch signals "connected, no logs yet" so the app transitions out of Connecting
-                    let _ = tx.send(Vec::new()).await;
-
-                    loop {
-                        tokio::select! {
-                             _ = &mut stop_rx => break,
-                             res = read_framed(&mut socket) => {
-                                 match res {
-                                     Ok(batch) => { if tx.send(batch.logs).await.is_err() { break; } }
-                                     Err(_) => break,
-                                 }
-                             }
-                        }
-                    }
-                }
-                Err(_) => {}
-            }
-        });
-    }
-
-    async fn reconnect(&mut self, addr: String) {
-        self.disconnect();
-        self.state = ConnectionState::Reconnecting(addr.clone());
-        self.last_connect_addr = Some(addr.clone());
-        let (tx, rx) = mpsc::channel(100);
-        let (stop_tx, mut stop_rx) = tokio::sync::oneshot::channel();
-
-        self.log_rx = Some(rx);
-        self.stop_tx = Some(stop_tx);
-
-        let addr_clone = addr.clone();
-        tokio::spawn(async move {
-            match TcpStream::connect(&addr_clone).await {
-                Ok(mut socket) => {
-                    // empty batch signals "connected, no logs yet" so the app transitions out of Connecting
-                    let _ = tx.send(Vec::new()).await;
-
-                    loop {
-                        tokio::select! {
-                             _ = &mut stop_rx => break,
-                             res = read_framed(&mut socket) => {
-                                 match res {
-                                     Ok(batch) => { if tx.send(batch.logs).await.is_err() { break; } }
-                                     Err(_) => break,
-                                 }
-                             }
-                        }
-                    }
-                }
-                Err(_) => {}
-            }
-        });
-    }
-
-    fn disconnect(&mut self) {
-        if let Some(tx) = self.stop_tx.take() {
-            let _ = tx.send(());
-        }
-        self.log_rx = None;
-        self.state = ConnectionState::Disconnected;
-    }
-
-    fn load_csv(&mut self, path: &str) {
-        match csv::Reader::from_path(path) {
-            Ok(mut rdr) => {
-                self.logs.clear();
-                for result in rdr.records() {
-                    if let Ok(record) = result {
-                        let log = LogData {
-                            timestamp: record.get(0).unwrap_or("0").parse().unwrap_or(0),
-                            severity: match record.get(1).unwrap_or("INFO") {
-                                "TRACE" => 0,
-                                "INFO" => 1,
-                                "WARNING" => 2,
-                                "ERROR" => 3,
-                                "CRITICAL" => 4,
-                                _ => 1,
-                            },
-                            filepath: record.get(2).unwrap_or("").to_string(),
-                            line_number: record.get(3).unwrap_or("0").parse().unwrap_or(0),
-                            sink: record.get(4).unwrap_or("").to_string(),
-                            message: record.get(5).unwrap_or("").to_string(),
-                        };
-                        self.process_log(log);
-                    }
-                }
-                self.state = ConnectionState::CsvMode(path.to_string());
-                self.update_filtered_logs();
-            }
-            Err(_) => self.state = ConnectionState::Disconnected,
-        }
-    }
-
-    fn process_log(&mut self, log: LogData) {
-        if let ConnectionState::Connecting(_) | ConnectionState::Reconnecting(_) = self.state {
-            self.state = ConnectionState::Connected;
-        }
-        self.seen_severities.insert(log.severity);
-        self.seen_sinks.insert(log.sink.clone());
-        self.logs.push(log);
-    }
-
-    pub fn update_filtered_logs(&mut self) {
-        let q = self.search_query.to_lowercase();
-
-        self.filtered_logs = self
-            .logs
-            .iter()
-            .enumerate()
-            .filter_map(|(i, log)| {
-                if self.excluded_severities.contains(&log.severity) {
-                    return None;
-                }
-                if self.excluded_sinks.contains(&log.sink) {
-                    return None;
-                }
-                Some(i)
-            })
-            .collect();
-
-        // Simple 1:1 mapping between display rows and filtered logs
-        self.display_rows.clear();
-        for &log_idx in &self.filtered_logs {
-            self.display_rows.push((log_idx, 0));
-        }
-
-        self.search_matches.clear();
-        if !q.is_empty() {
-            for (idx, &log_idx) in self.filtered_logs.iter().enumerate() {
-                let log = &self.logs[log_idx];
-                let severity_label = match log.severity {
-                    0 => "trace",
-                    1 => "info",
-                    2 => "warning",
-                    3 => "error",
-                    4 => "critical",
-                    _ => "",
-                };
-                if log.message.to_lowercase().contains(&q)
-                    || log.sink.to_lowercase().contains(&q)
-                    || log.filepath.to_lowercase().contains(&q)
-                    || severity_label.contains(&q)
-                {
-                    self.search_matches.push(idx);
-                }
-            }
-        }
-
-        if self.search_matches.is_empty() {
-            self.current_match_idx = None;
-        } else if self.current_match_idx.is_none() {
-            self.current_match_idx = Some(0);
-        }
-
-        if !self.scroll_locked {
-            self.jump_to_latest();
-        }
-    }
-
-    fn jump_to_latest(&mut self) {
-        if !self.display_rows.is_empty() {
-            self.table_state.select(Some(self.display_rows.len() - 1));
-        }
-    }
-
-    pub fn open_detail_view(&mut self) {
-        if let Some(selected) = self.table_state.selected() {
-            if selected < self.display_rows.len() {
-                let (log_idx, _chunk_idx) = self.display_rows[selected];
-                self.detail_view_open = true;
-                self.detail_view_log_idx = Some(log_idx);
-                self.detail_view_scroll = 0;
-            }
-        }
-    }
-
-    pub fn close_detail_view(&mut self) {
-        self.detail_view_open = false;
-        self.detail_view_log_idx = None;
-        self.detail_view_scroll = 0;
-    }
-
-    pub fn scroll_detail_view_down(&mut self, max_lines: usize) {
-        if self.detail_view_scroll < max_lines.saturating_sub(1) {
-            self.detail_view_scroll = self.detail_view_scroll.saturating_add(3); // Scroll by 3 lines
-            if self.detail_view_scroll >= max_lines {
-                self.detail_view_scroll = max_lines.saturating_sub(1);
-            }
-        }
-    }
-
-    pub fn scroll_detail_view_up(&mut self) {
-        if self.detail_view_scroll >= 3 {
-            self.detail_view_scroll -= 3;
-        } else if self.detail_view_scroll > 0 {
-            self.detail_view_scroll = 0;
-        }
-    }
-}
-
-// wire format: 4-byte big-endian length prefix then protobuf bytes; matches log_server framing
-async fn read_framed(socket: &mut TcpStream) -> Result<LogBatch> {
-    let len = socket.read_u32().await? as usize;
-    let mut buf = vec![0u8; len];
-    socket.read_exact(&mut buf).await?;
-    Ok(LogBatch::decode(&buf[..])?)
-}
diff --git a/tools/kenzo/src/main.rs b/tools/kenzo/src/main.rs
deleted file mode 100644
index e1319ae66..000000000
--- a/tools/kenzo/src/main.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use anyhow::Result;
-use clap::Parser;
-
-pub mod proto;
-
-mod app;
-mod tui;
-mod ui;
-
-use crate::app::App;
-
-#[derive(Parser, Debug)]
-struct Args {
-    /// Path to a CSV log file to open directly
-    #[arg(long)]
-    csv: Option<String>,
-}
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    let args = Args::parse();
-
-    // Set up panic handler to restore terminal
-    let default_panic = std::panic::take_hook();
-    std::panic::set_hook(Box::new(move |panic_info| {
-        let _ = tui::restore();
-        default_panic(panic_info);
-    }));
-
-    // Initialize Terminal
-    let mut terminal = tui::init()?;
-
-    // Create App
-    let mut app = App::new(args.csv);
-
-    // Run Main Loop
-    let res = app.run(&mut terminal).await;
-
-    // Restore Terminal
-    tui::restore()?;
-
-    if let Err(err) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
diff --git a/tools/kenzo/src/proto.rs b/tools/kenzo/src/proto.rs
deleted file mode 100644
index 77aa70350..000000000
--- a/tools/kenzo/src/proto.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogData {
-    #[prost(uint64, tag = "1")]
-    pub timestamp: u64,
-    #[prost(enumeration = "log_data::Severity", tag = "2")]
-    pub severity: i32,
-    #[prost(string, tag = "3")]
-    pub filepath: ::prost::alloc::string::String,
-    #[prost(uint32, tag = "4")]
-    pub line_number: u32,
-    #[prost(string, tag = "5")]
-    pub sink: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub message: ::prost::alloc::string::String,
-}
-/// Nested message and enum types in `LogData`.
-pub mod log_data {
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-    #[repr(i32)]
-    pub enum Severity {
-        Trace = 0,
-        Info = 1,
-        Warning = 2,
-        Error = 3,
-        Critical = 4,
-    }
-    impl Severity {
-        /// String value of the enum field names used in the ProtoBuf definition.
-        ///
-        /// The values are not transformed in any way and thus are considered stable
-        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-        pub fn as_str_name(&self) -> &'static str {
-            match self {
-                Self::Trace => "TRACE",
-                Self::Info => "INFO",
-                Self::Warning => "WARNING",
-                Self::Error => "ERROR",
-                Self::Critical => "CRITICAL",
-            }
-        }
-        /// Creates an enum from field names used in the ProtoBuf definition.
-        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-            match value {
-                "TRACE" => Some(Self::Trace),
-                "INFO" => Some(Self::Info),
-                "WARNING" => Some(Self::Warning),
-                "ERROR" => Some(Self::Error),
-                "CRITICAL" => Some(Self::Critical),
-                _ => None,
-            }
-        }
-    }
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogBatch {
-    #[prost(message, repeated, tag = "1")]
-    pub logs: ::prost::alloc::vec::Vec<LogData>,
-}
diff --git a/tools/kenzo/src/tui.rs b/tools/kenzo/src/tui.rs
deleted file mode 100644
index 0d748890e..000000000
--- a/tools/kenzo/src/tui.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use anyhow::Result;
-use crossterm::{
-    event::{DisableMouseCapture, EnableMouseCapture},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{backend::CrosstermBackend, Terminal};
-use std::io::stdout;
-
-pub type Tui = Terminal<CrosstermBackend<std::io::Stdout>>;
-
-pub fn init() -> Result<Tui> {
-    enable_raw_mode()?;
-    let mut stdout = stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
-    let backend = CrosstermBackend::new(stdout);
-    let terminal = Terminal::new(backend)?;
-    Ok(terminal)
-}
-
-pub fn restore() -> Result<()> {
-    disable_raw_mode()?;
-    execute!(stdout(), LeaveAlternateScreen, DisableMouseCapture)?;
-    Ok(())
-}
diff --git a/tools/kenzo/src/ui.rs b/tools/kenzo/src/ui.rs
deleted file mode 100644
index ace1759f3..000000000
--- a/tools/kenzo/src/ui.rs
+++ /dev/null
@@ -1,670 +0,0 @@
-use crate::app::{App, AppFocus, ConnectionState, PopupOption, Severity};
-use ratatui::{
-    layout::{Alignment, Constraint, Direction, Layout, Rect},
-    style::{Color, Modifier, Style},
-    text::{Line, Span, Text},
-    widgets::{Block, BorderType, Borders, Cell, Clear, List, ListItem, Paragraph, Row, Table},
-    Frame,
-};
-
-pub fn draw(f: &mut Frame, app: &mut App) {
-    let size = f.area();
-
-    match &app.state {
-        ConnectionState::Disconnected | ConnectionState::Connecting(_) => {
-            render_disconnected(f, app, size);
-        }
-        ConnectionState::Connected
-        | ConnectionState::CsvMode(_)
-        | ConnectionState::Reconnecting(_) => {
-            render_connected(f, app, size);
-        }
-    }
-
-    // Render detail view on top if open
-    if app.detail_view_open {
-        render_detail_view(f, app, size);
-    }
-}
-
-fn render_disconnected(f: &mut Frame, app: &mut App, area: Rect) {
-    // Ensure the popup has enough space for all options (at least 10 lines and 60 columns)
-    let popup_width = 60.min(area.width);
-    let popup_height = 10.min(area.height);
-    let area = Rect::new(
-        area.x + (area.width.saturating_sub(popup_width)) / 2,
-        area.y + (area.height.saturating_sub(popup_height)) / 2,
-        popup_width,
-        popup_height,
-    );
-
-    let block = Block::default()
-        .borders(Borders::ALL)
-        .title(" Kenzo ")
-        .title_alignment(Alignment::Center)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(Color::Yellow));
-
-    f.render_widget(Clear, area);
-    f.render_widget(block, area);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(1)
-        .constraints([
-            Constraint::Length(1), // Empty
-            Constraint::Length(1), // Localhost
-            Constraint::Length(1), // Empty
-            Constraint::Length(1), // Remote IP
-            Constraint::Length(1), // Empty
-            Constraint::Length(1), // CSV
-            Constraint::Min(0),    // Rest
-        ])
-        .split(area);
-
-    let spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    let spinner_char = spinner[app.spinner_frame % spinner.len()];
-
-    // Localhost
-    let localhost_style = if app.popup_selection == PopupOption::Localhost {
-        Style::default()
-            .fg(Color::Yellow)
-            .add_modifier(Modifier::BOLD)
-    } else {
-        Style::default().fg(Color::Gray)
-    };
-    let is_connecting_localhost = match &app.state {
-        ConnectionState::Connecting(addr) if addr.contains("127.0.0.1") => true,
-        _ => false,
-    };
-    let localhost_text = if is_connecting_localhost {
-        format!("{} Connecting to Localhost...", spinner_char)
-    } else {
-        "  Connect to Localhost".to_string()
-    };
-    f.render_widget(
-        Paragraph::new(localhost_text).style(localhost_style),
-        chunks[1],
-    );
-
-    // Remote IP
-    let remote_style = if app.popup_selection == PopupOption::RemoteIp {
-        Style::default()
-            .fg(Color::Yellow)
-            .add_modifier(Modifier::BOLD)
-    } else {
-        Style::default().fg(Color::Gray)
-    };
-    let is_connecting_remote = match &app.state {
-        ConnectionState::Connecting(addr) if !addr.contains("127.0.0.1") => true,
-        _ => false,
-    };
-    let remote_input = if app.popup_selection == PopupOption::RemoteIp {
-        app.input_buffer.value()
-    } else {
-        ""
-    };
-    let remote_text = if is_connecting_remote {
-        format!("{} Connecting to {}:12801...", spinner_char, remote_input)
-    } else {
-        format!("  Connect to IP: {}", remote_input)
-    };
-    f.render_widget(Paragraph::new(remote_text).style(remote_style), chunks[3]);
-
-    // CSV
-    let csv_style = if app.popup_selection == PopupOption::CsvFile {
-        Style::default()
-            .fg(Color::Yellow)
-            .add_modifier(Modifier::BOLD)
-    } else {
-        Style::default().fg(Color::Gray)
-    };
-    let csv_input = if app.popup_selection == PopupOption::CsvFile {
-        app.input_buffer.value()
-    } else {
-        ""
-    };
-    let csv_text = format!("  Open CSV: {}", csv_input);
-    f.render_widget(Paragraph::new(csv_text).style(csv_style), chunks[5]);
-}
-
-fn render_connected(f: &mut Frame, app: &mut App, area: Rect) {
-    let is_reconnecting = matches!(app.state, ConnectionState::Reconnecting(_));
-
-    let main_chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints(if is_reconnecting {
-            vec![
-                Constraint::Min(10),
-                Constraint::Length(3), // Search
-                Constraint::Length(1), // Keybinds
-                Constraint::Length(1), // Status bar
-            ]
-        } else {
-            vec![
-                Constraint::Min(10),
-                Constraint::Length(3), // Search
-                Constraint::Length(1), // Keybinds
-            ]
-        })
-        .split(area);
-
-    let content_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints(if app.show_filters {
-            [Constraint::Percentage(20), Constraint::Percentage(80)]
-        } else {
-            [Constraint::Percentage(0), Constraint::Percentage(100)]
-        })
-        .split(main_chunks[0]);
-
-    // Filters
-    if app.show_filters {
-        let filter_chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-            .split(content_chunks[0]);
-
-        // Severity Filter
-        let severity_block = Block::default()
-            .borders(Borders::ALL)
-            .title(" Severities ")
-            .border_type(BorderType::Rounded)
-            .border_style(
-                Style::default().fg(if app.focus == AppFocus::FilterSeverity {
-                    Color::Yellow
-                } else {
-                    Color::DarkGray
-                }),
-            );
-
-        let mut sevs: Vec<_> = app.seen_severities.iter().collect();
-        sevs.sort();
-        let sev_items: Vec<ListItem> = sevs
-            .iter()
-            .map(|&&s| {
-                let label = match s {
-                    0 => "TRACE",
-                    1 => "INFO",
-                    2 => "WARNING",
-                    3 => "ERROR",
-                    4 => "CRITICAL",
-                    _ => "UNKNOWN",
-                };
-                let checked = if app.excluded_severities.contains(&s) {
-                    "[ ]"
-                } else {
-                    "[x]"
-                };
-                ListItem::new(format!("{} {}", checked, label))
-            })
-            .collect();
-        f.render_stateful_widget(
-            List::new(sev_items).block(severity_block).highlight_style(
-                Style::default()
-                    .add_modifier(Modifier::BOLD)
-                    .fg(Color::Yellow),
-            ),
-            filter_chunks[0],
-            &mut app.severity_list_state,
-        );
-
-        // Sink Filter
-        let sink_block = Block::default()
-            .borders(Borders::ALL)
-            .title(" Sinks ")
-            .border_type(BorderType::Rounded)
-            .border_style(Style::default().fg(if app.focus == AppFocus::FilterSink {
-                Color::Yellow
-            } else {
-                Color::DarkGray
-            }));
-
-        let mut sinks: Vec<_> = app.seen_sinks.iter().collect();
-        sinks.sort();
-        let sink_items: Vec<ListItem> = sinks
-            .iter()
-            .map(|&s| {
-                let checked = if app.excluded_sinks.contains(s) {
-                    "[ ]"
-                } else {
-                    "[x]"
-                };
-                ListItem::new(format!("{} {}", checked, s))
-            })
-            .collect();
-        f.render_stateful_widget(
-            List::new(sink_items).block(sink_block).highlight_style(
-                Style::default()
-                    .add_modifier(Modifier::BOLD)
-                    .fg(Color::Yellow),
-            ),
-            filter_chunks[1],
-            &mut app.sink_list_state,
-        );
-    }
-
-    // Table
-    render_table(f, app, content_chunks[1]);
-
-    // Search
-    let search_block = Block::default()
-        .borders(Borders::ALL)
-        .title(" Search (/) ")
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(if app.focus == AppFocus::Search {
-            Color::Yellow
-        } else {
-            Color::DarkGray
-        }));
-    let search_text = if app.search_query.is_empty() && app.focus != AppFocus::Search {
-        Span::styled("Type / to search...", Style::default().fg(Color::DarkGray))
-    } else {
-        Span::raw(&app.search_query)
-    };
-    f.render_widget(
-        Paragraph::new(search_text).block(search_block),
-        main_chunks[1],
-    );
-
-    // Keybinds
-    let keybinds = if !app.detail_view_open {
-        let s_style = if !app.scroll_locked {
-            Style::default().fg(Color::Black).bg(Color::Yellow)
-        } else {
-            Style::default().fg(Color::Gray).bg(Color::DarkGray)
-        };
-        let w_style = if app.wrap_logs {
-            Style::default().fg(Color::Black).bg(Color::Magenta)
-        } else {
-            Style::default().fg(Color::Gray).bg(Color::DarkGray)
-        };
-        Line::from(vec![
-            Span::styled(" q ", Style::default().fg(Color::Gray).bg(Color::DarkGray)),
-            Span::raw(" Quit |"),
-            Span::styled(" v ", Style::default().fg(Color::Gray).bg(Color::DarkGray)),
-            Span::raw(" View |"),
-            Span::styled(" f ", Style::default().fg(Color::Gray).bg(Color::DarkGray)),
-            Span::raw(" Filters |"),
-            Span::styled(" s ", s_style),
-            Span::raw(" Auto-scroll |"),
-            Span::styled(" w ", w_style),
-            Span::raw(" Wrap |"),
-            Span::styled(" / ", Style::default().fg(Color::Gray).bg(Color::DarkGray)),
-            Span::raw(" Search |"),
-            Span::styled(" hjkl ", Style::default().fg(Color::Gray).bg(Color::DarkGray)),
-            Span::raw(" Move |"),
-            Span::styled(" Shift+HJKL ", Style::default().fg(Color::Gray).bg(Color::DarkGray)),
-            Span::raw(" Switch Focus "),
-        ])
-    } else {
-        Line::from(vec![
-            Span::styled("DETAIL VIEW ACTIVE", Style::default().fg(Color::Black).bg(Color::Yellow).add_modifier(Modifier::BOLD)), Span::raw(" - "),
-            Span::styled(" ↑↓/jk ", Style::default().fg(Color::Gray).bg(Color::DarkGray)), Span::raw(" Scroll |"),
-            Span::styled(" ESC/q ", Style::default().fg(Color::Gray).bg(Color::DarkGray)), Span::raw(" Close "),
-        ])
-    };
-    f.render_widget(
-        Paragraph::new(keybinds).alignment(Alignment::Center),
-        main_chunks[2],
-    );
-
-    // Reconnecting Status Bar
-    if is_reconnecting {
-        let spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-        let spinner_char = spinner[app.spinner_frame % spinner.len()];
-        let status_text = format!(
-            "{} reconnecting... Press \"q\" to go to to main menu",
-            spinner_char
-        );
-        f.render_widget(
-            Paragraph::new(status_text)
-                .alignment(Alignment::Center)
-                .style(
-                    Style::default()
-                        .bg(Color::Yellow)
-                        .fg(Color::Black)
-                        .add_modifier(Modifier::BOLD),
-                ),
-            main_chunks[3],
-        );
-    }
-}
-
-fn render_table(f: &mut Frame, app: &mut App, area: Rect) {
-    let mut title = " Kenzo Logs ".to_string();
-    if app.scroll_locked {
-        title = " Kenzo Logs 🔒 ".to_string();
-    }
-
-    let table_block = Block::default()
-        .borders(Borders::ALL)
-        .title(title)
-        .border_type(BorderType::Rounded)
-        .border_style(Style::default().fg(if app.focus == AppFocus::Table {
-            Color::Yellow
-        } else {
-            Color::DarkGray
-        }));
-
-    let inner_area = table_block.inner(area);
-    let show_sink = area.width > 100;
-    let show_file = area.width > 130;
-
-    let mut widths = vec![
-        Constraint::Length(15), // Time
-        Constraint::Length(12), // Severity
-    ];
-    if show_sink {
-        widths.push(Constraint::Length(15));
-    }
-    if show_file {
-        widths.push(Constraint::Length(25));
-    }
-    widths.push(Constraint::Min(20)); // Message
-
-    // Calculate message column width for wrapping (table inner area, minus fixed columns and spacing)
-    let column_spacing = 1u16;
-    let mut occupied_width = 15u16 + 12u16; // Time + Severity
-    let mut num_cols = 2u16;
-    if show_sink {
-        occupied_width += 15;
-        num_cols += 1;
-    }
-    if show_file {
-        occupied_width += 25;
-        num_cols += 1;
-    }
-    let spacing_width = column_spacing.saturating_mul(num_cols.saturating_sub(1));
-    let msg_col_width = inner_area
-        .width
-        .saturating_sub(occupied_width + spacing_width)
-        .max(1) as usize;
-
-    let rows: Vec<Row> = app
-        .filtered_logs
-        .iter()
-        .map(|&log_idx| {
-            let log = &app.logs[log_idx];
-            let severity = Severity::from(log.severity);
-            let (fg, bg) = match severity {
-                Severity::Trace => (Color::Gray, Color::Reset),
-                Severity::Info => (Color::Green, Color::Reset),
-                Severity::Warning => (Color::Yellow, Color::Reset),
-                Severity::Error => (Color::Red, Color::Reset),
-                Severity::Critical => (Color::Black, Color::Red),
-            };
-            let style = Style::default().fg(fg).bg(bg);
-            let highlight_q = app.search_query.to_lowercase();
-
-            let sev_label = match log.severity {
-                0 => "TRACE",
-                1 => "INFO",
-                2 => "WARNING",
-                3 => "ERROR",
-                4 => "CRITICAL",
-                _ => "UNKNOWN",
-            };
-            let sev_str = format!("[{}]", sev_label);
-            let time_str = format!("{}  ", format_timestamp(log.timestamp));
-            let sink_str = format!("[{}]", log.sink);
-            let file_str = format!("{}:{}", log.filepath, log.line_number);
-            let msg_str = log.message.replace('\t', "    ");
-
-            let mut wrapped_lines = Vec::new();
-            if app.wrap_logs {
-                for line in msg_str.lines() {
-                    let wrapped = textwrap::fill(line, msg_col_width);
-                    for subline in wrapped.lines() {
-                        wrapped_lines.push(subline.to_string());
-                    }
-                }
-            } else {
-                let single_line = msg_str.replace('\r', "").replace('\n', " ");
-                wrapped_lines.push(truncate_with_ellipsis(&single_line, msg_col_width));
-            }
-
-            if wrapped_lines.is_empty() {
-                wrapped_lines.push(String::new());
-            }
-
-            let row_height = if app.wrap_logs {
-                wrapped_lines.len().max(1) as u16
-            } else {
-                1
-            };
-
-            let msg_text = Text::from(
-                wrapped_lines
-                    .iter()
-                    .map(|l| {
-                        Line::from(highlight_text(
-                            l,
-                            &highlight_q,
-                            if severity == Severity::Critical {
-                                style
-                            } else if severity == Severity::Trace {
-                                style
-                            } else {
-                                Style::default().fg(Color::White)
-                            },
-                        ))
-                    })
-                    .collect::<Vec<_>>(),
-            );
-
-            let mut cells = vec![
-                Cell::from(Line::from(highlight_text(&time_str, &highlight_q, style))),
-                Cell::from(Line::from(highlight_text(&sev_str, &highlight_q, style))),
-            ];
-            if show_sink {
-                cells.push(Cell::from(Line::from(highlight_text(
-                    &sink_str,
-                    &highlight_q,
-                    style,
-                ))));
-            }
-            if show_file {
-                cells.push(Cell::from(Line::from(highlight_text(
-                    &file_str,
-                    &highlight_q,
-                    style,
-                ))));
-            }
-            cells.push(Cell::from(msg_text));
-
-            Row::new(cells).style(style).height(row_height)
-        })
-        .collect();
-
-    let mut header_cells = vec!["Time", "Severity"];
-    if show_sink {
-        header_cells.push("Sink");
-    }
-    if show_file {
-        header_cells.push("File");
-    }
-    header_cells.push("Message");
-
-    let table = Table::new(rows, widths)
-        .header(
-            Row::new(header_cells).style(
-                Style::default()
-                    .fg(Color::Cyan)
-                    .add_modifier(Modifier::BOLD),
-            ),
-        )
-        .block(table_block)
-        .column_spacing(1)
-        .row_highlight_style(Style::default().add_modifier(Modifier::REVERSED));
-
-    f.render_stateful_widget(table, area, &mut app.table_state);
-}
-
-fn truncate_with_ellipsis(text: &str, max_width: usize) -> String {
-    if max_width == 0 {
-        return String::new();
-    }
-    let text_len = text.chars().count();
-    if text_len <= max_width {
-        return text.to_string();
-    }
-    if max_width <= 3 {
-        return ".".repeat(max_width);
-    }
-    let mut truncated = String::new();
-    for (i, ch) in text.chars().enumerate() {
-        if i >= max_width - 3 {
-            break;
-        }
-        truncated.push(ch);
-    }
-    truncated.push_str("...");
-    truncated
-}
-
-fn highlight_text(text: &str, query: &str, base_style: Style) -> Vec<Span<'static>> {
-    if query.is_empty() || !text.to_lowercase().contains(query) {
-        return vec![Span::styled(text.to_string(), base_style)];
-    }
-    let mut spans = Vec::new();
-    let mut last_end = 0;
-    let text_lower = text.to_lowercase();
-    for (start, _) in text_lower.match_indices(query) {
-        if start > last_end {
-            spans.push(Span::styled(text[last_end..start].to_string(), base_style));
-        }
-        spans.push(Span::styled(
-            text[start..start + query.len()].to_string(),
-            base_style.bg(Color::Yellow).fg(Color::Black),
-        ));
-        last_end = start + query.len();
-    }
-    if last_end < text.len() {
-        spans.push(Span::styled(text[last_end..].to_string(), base_style));
-    }
-    spans
-}
-
-fn format_timestamp(ts: u64) -> String {
-    use chrono::{DateTime, Local, TimeZone, Utc};
-    let seconds = (ts / 1_000_000_000) as i64;
-    let nanos = (ts % 1_000_000_000) as u32;
-    match Utc.timestamp_opt(seconds, nanos) {
-        chrono::LocalResult::Single(dt) => {
-            let local_dt: DateTime<Local> = DateTime::from(dt);
-            local_dt.format("%H:%M:%S.%f").to_string()
-        }
-        _ => ts.to_string(),
-    }
-}
-
-fn render_detail_view(f: &mut Frame, app: &mut App, area: Rect) {
-    if let Some(log_idx) = app.detail_view_log_idx {
-        let log = &app.logs[log_idx];
-
-        // Calculate dialog dimensions
-        let dialog_width = (area.width as usize).saturating_sub(4).max(80) as u16;
-        let dialog_height = (area.height as usize).saturating_sub(4).max(20) as u16;
-
-        let dialog_area = Rect::new(
-            area.x + (area.width.saturating_sub(dialog_width)) / 2,
-            area.y + (area.height.saturating_sub(dialog_height)) / 2,
-            dialog_width,
-            dialog_height,
-        );
-
-        let severity = Severity::from(log.severity);
-        let (fg, _bg) = match severity {
-            Severity::Trace => (Color::Gray, Color::Reset),
-            Severity::Info => (Color::Green, Color::Reset),
-            Severity::Warning => (Color::Yellow, Color::Reset),
-            Severity::Error => (Color::Red, Color::Reset),
-            Severity::Critical => (Color::Black, Color::Red),
-        };
-
-        let sev_label = match log.severity { 0 => "TRACE", 1 => "INFO", 2 => "WARNING", 3 => "ERROR", 4 => "CRITICAL", _ => "UNKNOWN" };
-        let time_str = format_timestamp(log.timestamp);
-
-        // Create header
-        let header = format!("[{}] {} - {} ({}:{})", sev_label, time_str, log.sink, log.filepath, log.line_number);
-
-        // Split message into lines and wrap long lines
-        let msg_lines: Vec<&str> = log.message.lines().collect();
-        let content_width = (dialog_width as usize).saturating_sub(4);
-
-        let mut wrapped_lines = Vec::new();
-        for line in msg_lines.iter() {
-            if line.is_empty() {
-                wrapped_lines.push(String::new());
-            } else if line.len() > content_width {
-                // Wrap long lines
-                let wrapped = textwrap::fill(line, content_width);
-                for subline in wrapped.lines() {
-                    wrapped_lines.push(subline.to_string());
-                }
-            } else {
-                wrapped_lines.push(line.to_string());
-            }
-        }
-
-        let available_lines = (dialog_height as usize).saturating_sub(6); // Account for header, blank line, controls
-
-        // Clamp scroll position to valid range
-        let max_scroll = wrapped_lines.len().saturating_sub(available_lines);
-        if app.detail_view_scroll > max_scroll {
-            app.detail_view_scroll = max_scroll;
-        }
-
-        let start_line = app.detail_view_scroll;
-        let end_line = (start_line + available_lines).min(wrapped_lines.len());
-
-        let mut content_lines = vec![
-            Line::from(Span::styled(header, Style::default().add_modifier(Modifier::BOLD).fg(Color::Cyan))),
-            Line::from(""),
-        ];
-
-        // Add message lines with proper formatting
-        for line in &wrapped_lines[start_line..end_line] {
-            content_lines.push(Line::from(Span::styled(line.clone(), Style::default().fg(fg))));
-        }
-
-        let content = Text::from(content_lines);
-
-        let scroll_info = if wrapped_lines.len() > available_lines {
-            format!("Line {}/{}", start_line + 1, wrapped_lines.len())
-        } else {
-            String::new()
-        };
-
-        // Use bright yellow border to indicate focus
-        let block = Block::default()
-            .borders(Borders::ALL)
-            .title(" Message Details (FOCUSED) ")
-            .border_type(BorderType::Rounded)
-            .border_style(Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD))
-            .title_alignment(Alignment::Center);
-
-        let paragraph = Paragraph::new(content)
-            .block(block)
-            .style(Style::default());
-
-        f.render_widget(Clear, dialog_area);
-        f.render_widget(paragraph, dialog_area);
-
-        // Draw footer with controls and scroll info
-        let footer_text = if scroll_info.is_empty() {
-            "Press ↑↓/jk to scroll • ESC/q to close".to_string()
-        } else {
-            format!("Press ↑↓/jk to scroll • {} • ESC/q to close", scroll_info)
-        };
-
-        let footer_area = Rect::new(
-            dialog_area.x + 1,
-            dialog_area.y + dialog_area.height.saturating_sub(1),
-            dialog_area.width.saturating_sub(2),
-            1,
-        );
-        f.render_widget(Paragraph::new(footer_text).style(Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)), footer_area);
-    }
-}
diff --git a/tools/log_server/CMakeLists.txt b/tools/log_server/CMakeLists.txt
index d2c52181e..5c613005a 100644
--- a/tools/log_server/CMakeLists.txt
+++ b/tools/log_server/CMakeLists.txt
@@ -1,25 +1,64 @@
-project(log_server NONE)
-
-set(CARGO_PROJECT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-set(CARGO_TARGET_DIR "${OUTPUT_ROOT}/$<CONFIG>/cargo")
-set(CARGO_PROFILE_NAME "$<IF:$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>,release,debug>")
-set(CARGO_PROFILE_FLAG "$<IF:$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>,release,dev>")
-
-find_program(CARGO_EXECUTABLE cargo REQUIRED)
-message(STATUS "Found cargo: ${CARGO_EXECUTABLE}")
-message(STATUS "Build configuration: ${CARGO_PROFILE_NAME}")
-message(STATUS "Cargo target directory: ${CARGO_TARGET_DIR}")
-
-add_custom_target(log_server ALL
-        COMMAND ${CARGO_EXECUTABLE} build --profile "${CARGO_PROFILE_FLAG}" --target-dir "${CARGO_TARGET_DIR}"
-        COMMAND ${CMAKE_COMMAND}
-            -DCARGO_TARGET_DIR=${CARGO_TARGET_DIR}
-            -DPROFILE_NAME=${CARGO_PROFILE_NAME}
-            "-DBINARY_NAMES=log_server"
-            -DEXE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
-            -DDEST_DIR=${OUTPUT_ROOT}/$<CONFIG>/log_server
-            -P ${CMAKE_SOURCE_DIR}/cmake/install_cargo_output.cmake
-        WORKING_DIRECTORY ${CARGO_PROJECT_DIR}
-        COMMENT "[cargo] Building log_server (${CARGO_PROFILE_NAME})..."
+project(log_server CXX)
+
+find_package(protobuf CONFIG REQUIRED)
+find_package(asio CONFIG REQUIRED)
+find_package(Threads REQUIRED)
+find_package(CURL REQUIRED)
+find_package(ZLIB REQUIRED)
+find_package(nlohmann_json CONFIG REQUIRED)
+
+set(LOG_SERVER_PROTO "${CMAKE_SOURCE_DIR}/protos/logging.proto")
+set(LOG_SERVER_GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
+set(LOG_SERVER_PROTO_SOURCES "${LOG_SERVER_GENERATED_DIR}/logging.pb.cc" "${LOG_SERVER_GENERATED_DIR}/logging.pb.h")
+
+add_custom_command(
+        OUTPUT ${LOG_SERVER_PROTO_SOURCES}
+        COMMAND ${CMAKE_COMMAND} -E make_directory "${LOG_SERVER_GENERATED_DIR}"
+        COMMAND $<TARGET_FILE:protobuf::protoc>
+            "--proto_path=${CMAKE_SOURCE_DIR}/protos"
+            "--cpp_out=${LOG_SERVER_GENERATED_DIR}"
+            "${LOG_SERVER_PROTO}"
+        DEPENDS "${LOG_SERVER_PROTO}"
+        COMMENT "[protoc] Generating log_server protobuf sources..."
         VERBATIM
 )
+
+set(LOG_SERVER_CORE_SOURCES
+        src/server.cpp
+        src/storage.cpp
+        src/upload.cpp
+)
+set(LOG_SERVER_SOURCES src/main.cpp ${LOG_SERVER_CORE_SOURCES})
+
+add_executable(log_server ${LOG_SERVER_SOURCES} ${LOG_SERVER_PROTO_SOURCES})
+target_include_directories(log_server PRIVATE src "${LOG_SERVER_GENERATED_DIR}")
+target_link_libraries(log_server PRIVATE protobuf::libprotobuf asio::asio Threads::Threads CURL::libcurl ZLIB::ZLIB nlohmann_json::nlohmann_json)
+target_compile_definitions(log_server PRIVATE ASIO_STANDALONE ASIO_NO_DEPRECATED)
+
+if (MSVC)
+    target_compile_definitions(log_server PRIVATE NOMINMAX WIN32_LEAN_AND_MEAN NOGDI _CRT_SECURE_NO_WARNINGS)
+    target_link_options(log_server PRIVATE /SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup)
+    set_source_files_properties(${LOG_SERVER_SOURCES} PROPERTIES COMPILE_OPTIONS "/W4;/utf-8")
+else ()
+    set_source_files_properties(${LOG_SERVER_SOURCES} PROPERTIES COMPILE_OPTIONS "-Wall;-Wextra")
+endif ()
+
+foreach (config IN ITEMS Debug Release RelWithDebInfo MinSizeRel)
+    string(TOUPPER "${config}" config_upper)
+    set_target_properties(log_server PROPERTIES RUNTIME_OUTPUT_DIRECTORY_${config_upper} "${OUTPUT_ROOT}/${config}/log_server")
+endforeach ()
+
+add_executable(log_server_checks EXCLUDE_FROM_ALL checks/checks.cpp ${LOG_SERVER_CORE_SOURCES} ${LOG_SERVER_PROTO_SOURCES})
+target_include_directories(log_server_checks PRIVATE src "${LOG_SERVER_GENERATED_DIR}")
+target_link_libraries(log_server_checks PRIVATE protobuf::libprotobuf asio::asio Threads::Threads CURL::libcurl ZLIB::ZLIB nlohmann_json::nlohmann_json)
+target_compile_definitions(log_server_checks PRIVATE ASIO_STANDALONE ASIO_NO_DEPRECATED)
+if (MSVC)
+    target_compile_definitions(log_server_checks PRIVATE NOMINMAX WIN32_LEAN_AND_MEAN NOGDI _CRT_SECURE_NO_WARNINGS)
+    set_source_files_properties(checks/checks.cpp PROPERTIES COMPILE_OPTIONS "/W4;/utf-8")
+else ()
+    set_source_files_properties(checks/checks.cpp PROPERTIES COMPILE_OPTIONS "-Wall;-Wextra")
+endif ()
+foreach (config IN ITEMS Debug Release RelWithDebInfo MinSizeRel)
+    string(TOUPPER "${config}" config_upper)
+    set_target_properties(log_server_checks PROPERTIES RUNTIME_OUTPUT_DIRECTORY_${config_upper} "${OUTPUT_ROOT}/${config}/log_server")
+endforeach ()
diff --git a/tools/log_server/Cargo.toml b/tools/log_server/Cargo.toml
deleted file mode 100644
index d224327df..000000000
--- a/tools/log_server/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "log_server"
-version = "0.1.0"
-edition = "2021"
-
-[[bin]]
-name = "log_server"
-path = "src/main.rs"
-
-[dependencies]
-prost   = "0.14"
-tokio   = { version = "1",     features = ["full"] }
-clap    = { version = "4",     features = ["derive"] }
-csv     = "1.3.1"
-serde   = { version = "1",     features = ["derive"] }
-chrono  = "0.4"
\ No newline at end of file
diff --git a/tools/log_server/checks/checks.cpp b/tools/log_server/checks/checks.cpp
new file mode 100644
index 000000000..966b2327d
--- /dev/null
+++ b/tools/log_server/checks/checks.cpp
@@ -0,0 +1,485 @@
+/**
+ * @file checks.cpp
+ * @author Xein
+ * @date 25 Oct 2026
+ * @brief Checks for the upload path
+ */
+
+#include "storage.hpp"
+#include "remote_config.hpp"
+#include "upload.hpp"
+
+#include <asio.hpp>
+#include <zlib.h>
+
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <exception>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iterator>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+namespace {
+
+struct Check {
+	const char* name;
+	std::function<void()> run;
+};
+
+std::vector<Check>& registry() {
+	static std::vector<Check> checks;
+	return checks;
+}
+
+struct Register {
+	Register(const char* name, std::function<void()> run) { registry().push_back({name, std::move(run)}); }
+};
+
+void check(bool condition, const char* message) {
+	if (!condition) {
+		throw std::runtime_error(message);
+	}
+}
+
+void setEnv(const char* name, const std::string& value) {
+#ifdef _WIN32
+	_putenv_s(name, value.c_str());
+#else
+	setenv(name, value.c_str(), 1);
+#endif
+}
+
+/// fresh directory for the session csv
+struct TempConfigDir {
+	fs::path root;
+	TempConfigDir() {
+		root = fs::temp_directory_path() / ("log_server_checks_" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
+		fs::create_directories(root);
+#ifdef _WIN32
+		setEnv("APPDATA", root.string());
+#else
+		setEnv("XDG_CONFIG_HOME", root.string());
+#endif
+	}
+	~TempConfigDir() {
+		std::error_code ec;
+		fs::remove_all(root, ec);
+	}
+};
+
+#define CHECK(name) \
+	void name(); \
+	const Register register_##name(#name, name); \
+	void name()
+
+CHECK(finish_session_returns_summary_once) {
+	TempConfigDir dir;
+	log_server::LogStorage storage;
+	const auto path = storage.beginSession();
+	check(path.has_value(), "beginSession opens a file");
+	storage.addLog(log_server::serverLog(log_server::LogData::INFO, "x"));
+
+	const auto summary = storage.finishSession();
+	check(summary.has_value(), "first finishSession returns a summary");
+	check(summary->path == *path, "summary path is the session file");
+	check(fs::exists(summary->path), "summary file exists");
+	check(summary->size > 0, "summary size is positive");
+	check(summary->size == fs::file_size(summary->path), "summary size is the file size");
+	check(summary->duration >= std::chrono::seconds(0), "duration is not negative");
+	const auto age = std::chrono::system_clock::now() - summary->started;
+	check(age >= std::chrono::seconds(-1) && age < std::chrono::minutes(1), "started is about now");
+
+	check(!storage.finishSession().has_value(), "second finishSession returns nothing");
+}
+
+CHECK(finish_session_without_begin_returns_nothing) {
+	log_server::LogStorage storage;
+	check(!storage.finishSession().has_value(), "no session, no summary");
+}
+
+CHECK(finish_session_concurrent_yields_one_summary) {
+	TempConfigDir dir;
+	log_server::LogStorage storage;
+	check(storage.beginSession().has_value(), "beginSession opens a file");
+	storage.addLog(log_server::serverLog(log_server::LogData::INFO, "x"));
+
+	std::atomic<int> winners = 0;
+	std::vector<std::thread> threads;
+	for (int i = 0; i < 8; ++i) {
+		threads.emplace_back([&] {
+			if (storage.finishSession().has_value()) {
+				++winners;
+			}
+		});
+	}
+	for (auto& thread : threads) {
+		thread.join();
+	}
+	check(winners == 1, "exactly one thread gets the summary");
+}
+
+/// one thread http server for the checks
+class FakeHttp {
+public:
+	struct Request {
+		std::string method, target, headers, body;
+	};
+	struct Reply {
+		int status = 200;
+		std::string body;
+	};
+	using Handler = std::function<Reply(const Request&)>;
+
+	explicit FakeHttp(Handler handler)
+	    : handler(std::move(handler)), acceptor(context, asio::ip::tcp::endpoint(asio::ip::make_address("127.0.0.1"), 0)) {
+		worker = std::thread([this] { serve(); });
+	}
+	~FakeHttp() {
+		stopping = true;
+		asio::error_code ec;
+		acceptor.close(ec);
+		worker.join();
+	}
+
+	[[nodiscard]] std::uint16_t port() const { return acceptor.local_endpoint().port(); }
+	[[nodiscard]] std::string url() const { return "http://127.0.0.1:" + std::to_string(port()); }
+	[[nodiscard]] std::vector<Request> requests() {
+		std::scoped_lock lock(mutex);
+		return seen;
+	}
+
+private:
+	void serve() {
+		while (!stopping) {
+			asio::ip::tcp::socket socket(context);
+			asio::error_code ec;
+			acceptor.accept(socket, ec);
+			if (ec) {
+				continue;
+			}
+			handle(socket);
+		}
+	}
+
+	void handle(asio::ip::tcp::socket& socket) {
+		asio::error_code ec;
+		asio::streambuf buffer;
+		asio::read_until(socket, buffer, "\r\n\r\n", ec);
+		if (ec) {
+			return;
+		}
+		std::string all(asio::buffers_begin(buffer.data()), asio::buffers_end(buffer.data()));
+		const std::size_t head_end = all.find("\r\n\r\n") + 4;
+		Request request;
+		request.headers = all.substr(0, head_end);
+		const std::size_t line_end = request.headers.find("\r\n");
+		const std::string line = request.headers.substr(0, line_end);
+		request.method = line.substr(0, line.find(' '));
+		request.target = line.substr(line.find(' ') + 1, line.rfind(' ') - line.find(' ') - 1);
+		request.body = all.substr(head_end);
+
+		std::string lower = request.headers;
+		for (char& c : lower) {
+			c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+		}
+		if (lower.find("expect: 100-continue") != std::string::npos) {
+			asio::write(socket, asio::buffer(std::string("HTTP/1.1 100 Continue\r\n\r\n")), ec);
+		}
+		const bool chunked = lower.find("transfer-encoding: chunked") != std::string::npos;
+		std::size_t length = 0;
+		if (const auto at = lower.find("content-length:"); at != std::string::npos) {
+			length = static_cast<std::size_t>(std::stoull(lower.substr(at + 15)));
+		}
+		std::array<char, 65536> chunk {};
+		const auto complete = [&] { return chunked ? request.body.ends_with("0\r\n\r\n") : request.body.size() >= length; };
+		while (!complete()) {
+			const std::size_t got = socket.read_some(asio::buffer(chunk), ec);
+			if (ec) {
+				break;
+			}
+			request.body.append(chunk.data(), got);
+		}
+		const Reply reply = handler(request);
+		{
+			std::scoped_lock lock(mutex);
+			seen.push_back(request);
+		}
+		const std::string out = "HTTP/1.1 " + std::to_string(reply.status) + " X\r\nContent-Type: application/json\r\nContent-Length: " +
+		                        std::to_string(reply.body.size()) + "\r\nConnection: close\r\n\r\n" + reply.body;
+		asio::write(socket, asio::buffer(out), ec);
+		socket.shutdown(asio::ip::tcp::socket::shutdown_both, ec);
+	}
+
+	Handler handler;
+	asio::io_context context;
+	asio::ip::tcp::acceptor acceptor;
+	std::thread worker;
+	std::atomic<bool> stopping = false;
+	std::mutex mutex;
+	std::vector<Request> seen;
+};
+
+std::string readAll(const fs::path& path) {
+	std::ifstream in(path, std::ios::binary);
+	return std::string(std::istreambuf_iterator<char>(in), {});
+}
+
+std::string gunzip(const std::string& data) {
+	z_stream stream {};
+	check(inflateInit2(&stream, 15 + 16) == Z_OK, "inflateInit2");
+	stream.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(data.data()));
+	stream.avail_in = static_cast<uInt>(data.size());
+	std::string out;
+	std::array<char, 65536> buffer {};
+	int status = Z_OK;
+	while (status == Z_OK) {
+		stream.next_out = reinterpret_cast<Bytef*>(buffer.data());
+		stream.avail_out = static_cast<uInt>(buffer.size());
+		status = inflate(&stream, Z_NO_FLUSH);
+		out.append(buffer.data(), buffer.size() - stream.avail_out);
+	}
+	inflateEnd(&stream);
+	check(status == Z_STREAM_END, "gzip stream ends cleanly");
+	return out;
+}
+
+fs::path tempFile(const char* name, const std::string& content) {
+	const fs::path path = fs::temp_directory_path() / (std::string("log_server_checks_") + name);
+	std::ofstream(path, std::ios::binary) << content;
+	return path;
+}
+
+log_server::UploadJob sampleJob(const fs::path& csv) {
+	log_server::UploadJob job;
+	job.csv = csv;
+	job.host = "devbox";
+	job.user = "zo\xC3\xAB";
+	job.started = "2026-10-25 12:00:00.000Z";
+	job.duration_s = 42;
+	job.size = fs::file_size(csv);
+	return job;
+}
+
+CHECK(gzip_round_trips_big_and_empty_files) {
+	std::string big;
+	for (int i = 0; i < 200000; ++i) {
+		big += "1792684753419544000,INFO,engine.cpp," + std::to_string(i) + ",Engine,line\n";
+	}
+	const fs::path in = tempFile("big.csv", big);
+	const fs::path out = tempFile("big.csv.gz", "");
+	check(log_server::gzipFile(in, out), "gzipFile succeeds");
+	check(gunzip(readAll(out)) == big, "round trip is identical");
+
+	const fs::path empty = tempFile("empty.csv", "");
+	check(log_server::gzipFile(empty, out), "empty input gzips");
+	check(gunzip(readAll(out)).empty(), "empty round trip");
+	std::error_code ec;
+	fs::remove(in, ec);
+	fs::remove(out, ec);
+	fs::remove(empty, ec);
+}
+
+CHECK(format_utc_has_millisecond_precision) {
+	using namespace std::chrono;
+	check(log_server::formatUtc(system_clock::time_point(duration_cast<system_clock::duration>(milliseconds(1500)))) == "1970-01-01 00:00:01.500Z", "epoch plus 1.5 s");
+}
+
+CHECK(upload_posts_token_fields_and_gzip) {
+	const fs::path csv = tempFile("up.csv", "a,b,c\n1,2,3\n");
+	FakeHttp server([](const FakeHttp::Request& request) -> FakeHttp::Reply {
+		if (request.method == "GET" && request.target == "/kenzo/token") {
+			return {200, R"({"token":"T"})"};
+		}
+		return {200, "{}"};
+	});
+	setEnv("KENZO_REMOTE_URL", server.url());
+	log_server::runUpload(sampleJob(csv));
+
+	const auto seen = server.requests();
+	check(seen.size() == 2, "token request then upload");
+	check(seen[0].target == "/kenzo/token", "token route");
+	const auto& post = seen[1];
+	check(post.method == "POST" && post.target == "/api/collections/logs/records", "records route");
+	check(post.headers.find("Authorization: Bearer T") != std::string::npos, "bearer header");
+	for (const char* field : {"name=\"host\"", "name=\"user\"", "name=\"started\"", "name=\"duration_s\"", "name=\"size\"", "name=\"file\"; filename=\""}) {
+		check(post.body.find(field) != std::string::npos, field);
+	}
+	check(post.body.find(".csv.gz\"") != std::string::npos, "file is named .csv.gz");
+	check(post.body.find("zo\xC3\xAB") != std::string::npos, "non-ASCII user survives");
+	check(post.body.find("\x1f\x8b") != std::string::npos, "gzip magic in body");
+	check(!fs::exists(fs::path(csv).concat(".gz.tmp")), "temp file removed");
+	std::error_code ec;
+	fs::remove(csv, ec);
+}
+
+CHECK(upload_to_a_closed_port_returns_quickly_and_cleans_up) {
+	std::uint16_t port = 0;
+	{
+		asio::io_context context;
+		asio::ip::tcp::acceptor probe(context, asio::ip::tcp::endpoint(asio::ip::make_address("127.0.0.1"), 0));
+		port = probe.local_endpoint().port();
+	}
+	setEnv("KENZO_REMOTE_URL", "http://127.0.0.1:" + std::to_string(port));
+	const fs::path csv = tempFile("closed.csv", "a,b\n");
+	const auto begin = std::chrono::steady_clock::now();
+	log_server::runUpload(sampleJob(csv));
+	check(std::chrono::steady_clock::now() - begin < std::chrono::seconds(12), "returns within 12 s");
+	check(!fs::exists(fs::path(csv).concat(".gz.tmp")), "temp file removed");
+	std::error_code ec;
+	fs::remove(csv, ec);
+}
+
+CHECK(upload_survives_server_errors) {
+	FakeHttp server([](const FakeHttp::Request&) -> FakeHttp::Reply { return {500, "boom"}; });
+	setEnv("KENZO_REMOTE_URL", server.url());
+	const fs::path csv = tempFile("err.csv", "a,b\n");
+	log_server::runUpload(sampleJob(csv));
+	check(!fs::exists(fs::path(csv).concat(".gz.tmp")), "temp file removed");
+	check(server.requests().size() == 1, "no upload without a token");
+	std::error_code ec;
+	fs::remove(csv, ec);
+}
+
+CHECK(an_upload_that_takes_too_long_is_dropped) {
+	// takes the request and never answers
+	FakeHttp server([](const FakeHttp::Request& request) -> FakeHttp::Reply {
+		if (request.target == "/kenzo/token") {
+			return {200, R"({"token":"T"})"};
+		}
+		std::this_thread::sleep_for(std::chrono::seconds(8));
+		return {200, "{}"};
+	});
+	setEnv("KENZO_REMOTE_URL", server.url());
+	const fs::path csv = tempFile("slow.csv", "a,b\n");
+	const long saved = log_server::g_upload_timeout_seconds;
+	log_server::g_upload_timeout_seconds = 2;
+	const auto begin = std::chrono::steady_clock::now();
+	log_server::runUpload(sampleJob(csv));
+	const auto took = std::chrono::steady_clock::now() - begin;
+	log_server::g_upload_timeout_seconds = saved;
+	check(took < std::chrono::seconds(6), "gives up at the limit instead of waiting for the server");
+	check(!fs::exists(fs::path(csv).concat(".gz.tmp")), "temp file removed");
+	check(saved == 300, "the default limit is five minutes");
+	std::error_code ec;
+	fs::remove(csv, ec);
+}
+
+CHECK(host_and_user_names_are_never_empty) {
+	check(!log_server::hostName().empty(), "host name");
+	check(!log_server::userName().empty(), "user name");
+}
+
+CHECK(upload_args_round_trip_with_spaces_and_unicode) {
+	const fs::path csv = tempFile("args.csv", "a\n");
+	auto job = sampleJob(csv);
+	job.user = "Ana Mar\xC3\xAD" "a";
+	job.host = "caf\xC3\xA9" " box";
+	const auto parsed = log_server::parseUploadArgs(log_server::uploadArgs(job));
+	check(parsed.has_value(), "parses");
+	check(parsed->csv == job.csv && parsed->host == job.host && parsed->user == job.user, "strings survive");
+	check(parsed->started == job.started && parsed->duration_s == job.duration_s && parsed->size == job.size, "numbers survive");
+	std::error_code ec;
+	fs::remove(csv, ec);
+}
+
+CHECK(upload_args_reject_incomplete_input) {
+	check(!log_server::parseUploadArgs({}).has_value(), "empty");
+	check(!log_server::parseUploadArgs({"--other"}).has_value(), "not an upload");
+	check(!log_server::parseUploadArgs({"--upload"}).has_value(), "missing csv");
+	check(!log_server::parseUploadArgs({"--upload", "x.csv", "--host"}).has_value(), "missing value");
+	check(!log_server::parseUploadArgs({"--upload", "x.csv", "--duration", "abc"}).has_value(), "bad number");
+}
+
+CHECK(spawn_uploader_respects_opt_out_and_empty_files) {
+	const fs::path csv = tempFile("spawn.csv", "a,b\n");
+	log_server::SessionSummary summary;
+	summary.path = csv;
+	summary.started = std::chrono::system_clock::now();
+	summary.duration = std::chrono::seconds(5);
+	summary.size = fs::file_size(csv);
+
+	std::vector<std::vector<std::string>> spawned;
+	log_server::g_spawn_override = [&](const std::vector<std::string>& args) {
+		spawned.push_back(args);
+		return true;
+	};
+
+	setEnv("KENZO_REMOTE_URL", "http://127.0.0.1:1");
+	setEnv("KENZO_NO_UPLOAD", "1");
+	log_server::spawnUploader(summary);
+	check(spawned.empty(), "opt-out spawns nothing");
+
+	setEnv("KENZO_NO_UPLOAD", "");
+	auto empty = summary;
+	empty.size = 0;
+	log_server::spawnUploader(empty);
+	check(spawned.empty(), "zero size spawns nothing");
+
+	auto missing = summary;
+	missing.path = csv.parent_path() / "does_not_exist.csv";
+	log_server::spawnUploader(missing);
+	check(spawned.empty(), "missing file spawns nothing");
+
+	log_server::spawnUploader(summary);
+	check(spawned.size() == 1, "a real session spawns once");
+	const auto job = log_server::parseUploadArgs(spawned[0]);
+	check(job.has_value() && job->csv == csv && job->duration_s == 5 && job->size == summary.size, "arguments describe the session");
+
+	log_server::g_spawn_override = nullptr;
+	std::error_code ec;
+	fs::remove(csv, ec);
+}
+
+CHECK(the_built_in_server_is_used_unless_overridden) {
+	setEnv("KENZO_REMOTE_URL", "");
+	check(log_server::remoteBaseUrl() == "http://kenzo.nullptr.es:8080", "the built-in server");
+	setEnv("KENZO_REMOTE_URL", "http://127.0.0.1:9/");
+	check(log_server::remoteBaseUrl() == "http://127.0.0.1:9", "an environment override wins, trailing slash trimmed");
+	setEnv("KENZO_REMOTE_URL", "");
+}
+
+CHECK(finish_and_upload_spawns_once_even_when_called_twice) {
+	TempConfigDir dir;
+	setEnv("KENZO_NO_UPLOAD", "");
+	setEnv("KENZO_REMOTE_URL", "http://127.0.0.1:1");
+	int spawns = 0;
+	log_server::g_spawn_override = [&](const std::vector<std::string>&) {
+		++spawns;
+		return true;
+	};
+	log_server::LogStorage storage;
+	check(storage.beginSession().has_value(), "beginSession");
+	storage.addLog(log_server::serverLog(log_server::LogData::INFO, "x"));
+	log_server::finishAndUpload(storage);
+	log_server::finishAndUpload(storage);
+	log_server::g_spawn_override = nullptr;
+	check(spawns == 1, "one uploader for one session");
+}
+
+}  // namespace
+
+int main() {
+	int failed = 0;
+	for (const auto& entry : registry()) {
+		try {
+			entry.run();
+			std::printf("ok   %s\n", entry.name);
+		} catch (const std::exception& e) {
+			std::printf("FAIL %s: %s\n", entry.name, e.what());
+			++failed;
+		}
+	}
+	std::printf("%zu checks, %d failed\n", registry().size(), failed);
+	return failed == 0 ? 0 : 1;
+}
diff --git a/tools/log_server/src/main.cpp b/tools/log_server/src/main.cpp
new file mode 100644
index 000000000..635bcbe03
--- /dev/null
+++ b/tools/log_server/src/main.cpp
@@ -0,0 +1,181 @@
+/**
+ * @file main.cpp
+ * @author Xein
+ * @date 25 Oct 2026
+ */
+
+#include "server.hpp"
+#include "storage.hpp"
+#include "upload.hpp"
+
+#include <charconv>
+#include <cstdio>
+#include <cstdlib>
+#include <exception>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <shellapi.h>
+#endif
+
+namespace {
+
+constexpr std::uint16_t tui_port = 12801;
+
+struct Args {
+	/// engine port
+	std::uint16_t port = 12800;
+	/// keep running after the engine disconnects
+	bool infinite = false;
+};
+
+/// closed on shutdown
+log_server::LogStorage* g_storage = nullptr;
+
+void printUsage(std::FILE* out) {
+	std::fputs("Usage: log_server [OPTIONS]\n\nOptions:\n      --port <PORT>  Port for the engine to connect to [default: 12800]\n      --infinite     Keep server running even after engine disconnects\n  -h, --help         Print help\n", out);
+}
+
+[[noreturn]] void usageError(const std::string& message) {
+	std::fprintf(stderr, "error: %s\n\n", message.c_str());
+	printUsage(stderr);
+	std::exit(2);
+}
+
+std::uint16_t parsePort(std::string_view text) {
+	unsigned value = 0;
+	const auto [end, ec] = std::from_chars(text.data(), text.data() + text.size(), value);
+	if (ec != std::errc() || end != text.data() + text.size() || value > 65535) {
+		usageError("invalid value '" + std::string(text) + "' for '--port <PORT>'");
+	}
+	return static_cast<std::uint16_t>(value);
+}
+
+Args parseArgs(int argc, char** argv) {
+	Args args;
+	for (int i = 1; i < argc; ++i) {
+		const std::string_view arg = argv[i];
+		if (arg == "--infinite") {
+			args.infinite = true;
+		} else if (arg == "--port") {
+			if (i + 1 >= argc) {
+				usageError("a value is required for '--port <PORT>' but none was supplied");
+			}
+			args.port = parsePort(argv[++i]);
+		} else if (arg.starts_with("--port=")) {
+			args.port = parsePort(arg.substr(7));
+		} else if (arg == "-h" || arg == "--help") {
+			printUsage(stdout);
+			std::exit(0);
+		} else {
+			usageError("unexpected argument '" + std::string(arg) + "' found");
+		}
+	}
+	return args;
+}
+
+/// arguments as utf8
+std::vector<std::string> commandLineArgs(int argc, char** argv) {
+	std::vector<std::string> args;
+#ifdef _WIN32
+	(void)argc;
+	(void)argv;
+	int count = 0;
+	wchar_t** wide = CommandLineToArgvW(GetCommandLineW(), &count);
+	if (wide != nullptr) {
+		for (int i = 1; i < count; ++i) {
+			const int size = WideCharToMultiByte(CP_UTF8, 0, wide[i], -1, nullptr, 0, nullptr, nullptr);
+			std::string text(size > 0 ? static_cast<std::size_t>(size - 1) : 0, char{});
+			WideCharToMultiByte(CP_UTF8, 0, wide[i], -1, text.data(), size, nullptr, nullptr);
+			args.push_back(std::move(text));
+		}
+		LocalFree(wide);
+	}
+#else
+	for (int i = 1; i < argc; ++i) {
+		args.emplace_back(argv[i]);
+	}
+#endif
+	return args;
+}
+
+/// closes the session file and exits
+[[noreturn]] void shutdownNow() {
+	log_server::finishAndUpload(*g_storage);
+	std::_Exit(0);
+}
+
+#ifdef _WIN32
+BOOL WINAPI onConsoleEvent(DWORD event) {
+	if (event == CTRL_C_EVENT || event == CTRL_SHUTDOWN_EVENT) {
+		shutdownNow();
+	}
+	return FALSE;
+}
+#endif
+
+}  // namespace
+
+int main(int argc, char** argv) {
+	// the detached child that uploads a session
+	if (const auto upload = log_server::parseUploadArgs(commandLineArgs(argc, argv))) {
+		log_server::runUpload(*upload);
+		return 0;
+	}
+
+	const Args args = parseArgs(argc, argv);
+
+	log_server::LogStorage storage;
+	g_storage = &storage;
+	log_server::Server server(storage);
+
+	// close the session file on an unhandled exception
+	std::set_terminate([] {
+		log_server::finishAndUpload(*g_storage);
+		std::abort();
+	});
+
+	asio::io_context context;
+
+	// close the session file when asked to stop
+#ifdef _WIN32
+	SetConsoleCtrlHandler(onConsoleEvent, TRUE);
+#else
+	asio::signal_set signals(context, SIGINT, SIGTERM, SIGHUP);
+	signals.async_wait([](const asio::error_code& ec, int) {
+		if (!ec) {
+			shutdownNow();
+		}
+	});
+#endif
+
+	asio::co_spawn(context, server.runTuiListener(tui_port), [](std::exception_ptr error) {
+		if (error) {
+			try {
+				std::rethrow_exception(error);
+			} catch (const std::exception& e) {
+				log_server::note(std::string("TUI Listener failed: ") + e.what());
+			}
+		}
+	});
+
+	int exit_code = 0;
+	asio::co_spawn(context, server.runEngineListener(args.port, args.infinite), [&](std::exception_ptr error) {
+		if (error) {
+			try {
+				std::rethrow_exception(error);
+			} catch (const std::exception& e) {
+				std::fprintf(stderr, "Error: %s\n", e.what());
+			}
+			exit_code = 1;
+			context.stop();
+		}
+	});
+
+	context.run();
+	log_server::finishAndUpload(storage);
+	return exit_code;
+}
diff --git a/tools/log_server/src/main.rs b/tools/log_server/src/main.rs
deleted file mode 100644
index c0478ba0a..000000000
--- a/tools/log_server/src/main.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * @file main.rs
- * @author Xein
- * @date 26 Mar 2026
- */
-
-#![windows_subsystem = "windows"]
-
-use clap::Parser;
-use std::sync::Arc;
-
-pub mod proto;
-
-mod server;
-mod storage;
-
-use storage::LogStorage;
-use server::Server;
-
-#[derive(Parser, Debug)]
-struct Args {
-    /// Port for the engine to connect to
-    #[arg(long, default_value_t = 12800)]
-    port: u16,
-
-    /// Keep server running even after engine disconnects
-    #[arg(long, default_value_t = false)]
-    infinite: bool,
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args = Args::parse();
-    
-    let storage = LogStorage::new();
-    let server = Arc::new(Server::new(storage));
-
-    // Spawn TUI listener
-    let server_tui = server.clone();
-    tokio::spawn(async move {
-        if let Err(e) = server_tui.run_tui_listener(12801).await {
-            eprintln!("TUI Listener failed: {:?}", e);
-        }
-    });
-
-    // Run Engine listener
-    server.run_engine_listener(args.port, args.infinite).await?;
-
-    Ok(())
-}
diff --git a/tools/log_server/src/proto.rs b/tools/log_server/src/proto.rs
deleted file mode 100644
index ab320dce1..000000000
--- a/tools/log_server/src/proto.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogData {
-    #[prost(uint64, tag = "1")]
-    pub timestamp: u64,
-    #[prost(enumeration = "log_data::Severity", tag = "2")]
-    pub severity: i32,
-    #[prost(string, tag = "3")]
-    pub filepath: ::prost::alloc::string::String,
-    #[prost(uint32, tag = "4")]
-    pub line_number: u32,
-    #[prost(string, tag = "5")]
-    pub sink: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub message: ::prost::alloc::string::String,
-}
-/// Nested message and enum types in `LogData`.
-pub mod log_data {
-    #[derive(
-        Clone,
-        Copy,
-        Debug,
-        PartialEq,
-        Eq,
-        Hash,
-        PartialOrd,
-        Ord,
-        ::prost::Enumeration
-    )]
-    #[repr(i32)]
-    pub enum Severity {
-        Trace = 0,
-        Info = 1,
-        Warning = 2,
-        Error = 3,
-        Critical = 4,
-    }
-    impl Severity {
-        /// String value of the enum field names used in the ProtoBuf definition.
-        ///
-        /// The values are not transformed in any way and thus are considered stable
-        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-        pub fn as_str_name(&self) -> &'static str {
-            match self {
-                Self::Trace => "TRACE",
-                Self::Info => "INFO",
-                Self::Warning => "WARNING",
-                Self::Error => "ERROR",
-                Self::Critical => "CRITICAL",
-            }
-        }
-        /// Creates an enum from field names used in the ProtoBuf definition.
-        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-            match value {
-                "TRACE" => Some(Self::Trace),
-                "INFO" => Some(Self::Info),
-                "WARNING" => Some(Self::Warning),
-                "ERROR" => Some(Self::Error),
-                "CRITICAL" => Some(Self::Critical),
-                _ => None,
-            }
-        }
-    }
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogBatch {
-    #[prost(message, repeated, tag = "1")]
-    pub logs: ::prost::alloc::vec::Vec<LogData>,
-}
diff --git a/tools/log_server/src/remote_config.hpp b/tools/log_server/src/remote_config.hpp
new file mode 100644
index 000000000..22c7eef1a
--- /dev/null
+++ b/tools/log_server/src/remote_config.hpp
@@ -0,0 +1,27 @@
+/**
+ * @file remote_config.hpp
+ * @author Xein
+ * @date 25 Oct 2026
+ * @brief Where finished sessions are uploaded
+ */
+
+#pragma once
+
+#include <cstdlib>
+#include <string>
+
+namespace log_server {
+
+/// KENZO_REMOTE_URL overrides it
+inline std::string remoteBaseUrl() {
+	std::string url = "http://kenzo.nullptr.es:8080";
+	if (const char* env = std::getenv("KENZO_REMOTE_URL"); env != nullptr && *env != '\0') {
+		url = env;
+	}
+	while (!url.empty() && url.back() == '/') {
+		url.pop_back();
+	}
+	return url;
+}
+
+}  // namespace log_server
diff --git a/tools/log_server/src/server.cpp b/tools/log_server/src/server.cpp
new file mode 100644
index 000000000..a60ccff17
--- /dev/null
+++ b/tools/log_server/src/server.cpp
@@ -0,0 +1,264 @@
+/**
+ * @file server.cpp
+ * @author Xein
+ * @date 25 Oct 2026
+ */
+
+#include "server.hpp"
+#include "upload.hpp"
+
+#include <array>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <deque>
+#include <memory>
+
+namespace log_server {
+
+namespace {
+
+using asio::ip::tcp;
+
+/// largest frame the server accepts
+constexpr std::uint32_t max_frame_len = 64 * 1024 * 1024;
+
+/// how long to wait for the TUIs before exiting
+constexpr auto tui_flush_limit = std::chrono::milliseconds(500);
+
+/// how an engine session ended
+enum class SessionEnd {
+	/// the engine sent the goodbye frame
+	goodbye,
+	/// anything else ending the connection
+	lost,
+};
+
+std::string endpointText(const tcp::endpoint& endpoint) {
+	const auto address = endpoint.address();
+	const std::string host = address.is_v6() ? "[" + address.to_string() + "]" : address.to_string();
+	return host + ":" + std::to_string(endpoint.port());
+}
+
+tcp::acceptor listen(asio::io_context& context, std::uint16_t port) {
+	// no address reuse on windows
+#ifdef _WIN32
+	constexpr bool reuse_address = false;
+#else
+	constexpr bool reuse_address = true;
+#endif
+	return tcp::acceptor(context, tcp::endpoint(tcp::v4(), port), reuse_address);
+}
+
+/// last row of a session
+LogData buildEndLog(SessionEnd end) {
+	switch (end) {
+		case SessionEnd::goodbye: return serverLog(LogData::INFO, "Toast Engine exited cleanly");
+		case SessionEnd::lost: return serverLog(LogData::CRITICAL, "Toast Engine connection lost (probable crash or kill)");
+	}
+	return serverLog(LogData::CRITICAL, "Toast Engine connection lost (probable crash or kill)");
+}
+
+/// eof is how a killed process looks
+SessionEnd connectionLost(const asio::error_code& error) {
+	if (error != asio::error::eof) {
+		note("Engine connection error: " + error.message());
+	}
+	return SessionEnd::lost;
+}
+
+std::string frameBatch(const LogBatch& batch) {
+	const auto size = static_cast<std::uint32_t>(batch.ByteSizeLong());
+	std::string frame(4 + size, '\0');
+	frame[0] = static_cast<char>(size >> 24);
+	frame[1] = static_cast<char>(size >> 16);
+	frame[2] = static_cast<char>(size >> 8);
+	frame[3] = static_cast<char>(size);
+	batch.SerializeToArray(frame.data() + 4, static_cast<int>(size));
+	return frame;
+}
+
+asio::awaitable<SessionEnd> handleEngineConnection(tcp::socket& socket, LogStorage& storage) {
+	const auto token = asio::as_tuple(asio::use_awaitable);
+	for (;;) {
+		std::array<unsigned char, 4> header {};
+		if (auto [ec, read] = co_await asio::async_read(socket, asio::buffer(header), token); ec) {
+			co_return connectionLost(ec);
+		}
+		const std::uint32_t len = (std::uint32_t(header[0]) << 24) | (std::uint32_t(header[1]) << 16) | (std::uint32_t(header[2]) << 8) |
+		                          std::uint32_t(header[3]);
+
+		if (len == 0) {
+			co_return SessionEnd::goodbye;
+		}
+
+		if (len > max_frame_len) {
+			note(
+			    "Engine sent a frame of " + std::to_string(len) + " bytes (limit " + std::to_string(max_frame_len) +
+			    "); treating the stream as corrupt"
+			);
+			co_return SessionEnd::lost;
+		}
+
+		std::string buf(len, '\0');
+		if (auto [ec, read] = co_await asio::async_read(socket, asio::buffer(buf), token); ec) {
+			co_return connectionLost(ec);
+		}
+
+		// invalid utf8 drops the frame and keeps the session
+		LogBatch batch;
+		if (batch.ParseFromArray(buf.data(), static_cast<int>(len))) {
+			storage.addLogs(std::move(batch));
+		} else {
+			storage.addLog(serverLog(LogData::WARNING, "Dropped an undecodable log frame (" + std::to_string(len) + " bytes)"));
+		}
+	}
+}
+
+}  // namespace
+
+void note(const std::string& message) {
+	std::fwrite(message.data(), 1, message.size(), stdout);
+	std::fputc('\n', stdout);
+	std::fflush(stdout);
+}
+
+/// a connected TUI and its queued frames
+struct TuiSession {
+	explicit TuiSession(tcp::socket s) : socket(std::move(s)), wake(socket.get_executor()) {
+		wake.expires_at(asio::steady_timer::time_point::max());
+	}
+
+	tcp::socket socket;
+	std::deque<std::string> pending;
+	bool writing = false;
+	asio::steady_timer wake;
+
+	bool idle() const { return pending.empty() && !writing; }
+
+	void push(std::string frame) {
+		// unbounded so a slow TUI never loses rows
+		pending.push_back(std::move(frame));
+		wake.cancel();
+	}
+};
+
+asio::awaitable<void> Server::runTuiListener(std::uint16_t port) {
+	auto executor = co_await asio::this_coro::executor;
+	auto& context = static_cast<asio::io_context&>(executor.context());
+	tcp::acceptor listener = listen(context, port);
+	note("TUI Listener running on 0.0.0.0:" + std::to_string(port));
+
+	for (;;) {
+		tcp::socket socket = co_await listener.async_accept(asio::use_awaitable);
+		asio::co_spawn(executor, handleTuiConnection(std::move(socket)), asio::detached);
+	}
+}
+
+asio::awaitable<void> Server::handleTuiConnection(tcp::socket socket) {
+	asio::error_code ignored;
+	const auto peer = socket.remote_endpoint(ignored);
+	const std::string peer_text = endpointText(peer);
+	note("TUI connected: " + peer_text);
+
+	TuiSession session(std::move(socket));
+	tui_sessions.insert(&session);
+
+	// send everything logged so far then each new log as its own frame
+	// subscribe and snapshot together so no row is missed or repeated
+	const std::uint64_t subscription = storage.subscribe([&session](const LogData& log) {
+		LogBatch update;
+		*update.add_logs() = log;
+		session.push(frameBatch(update));
+	});
+	const std::string initial = frameBatch(storage.snapshot());
+
+	try {
+		session.writing = true;
+		co_await asio::async_write(session.socket, asio::buffer(initial), asio::use_awaitable);
+		session.writing = false;
+
+		for (;;) {
+			if (session.pending.empty()) {
+				asio::error_code woken;
+				session.wake.expires_at(asio::steady_timer::time_point::max());
+				co_await session.wake.async_wait(asio::redirect_error(asio::use_awaitable, woken));
+				continue;
+			}
+			const std::string frame = std::move(session.pending.front());
+			session.pending.pop_front();
+			session.writing = true;
+			co_await asio::async_write(session.socket, asio::buffer(frame), asio::use_awaitable);
+			session.writing = false;
+		}
+	} catch (const std::system_error& e) {
+		note(std::string("TUI connection error: ") + e.code().message());
+	}
+
+	storage.unsubscribe(subscription);
+	tui_sessions.erase(&session);
+	note("TUI disconnected: " + peer_text);
+}
+
+/// closes the TUI sockets gracefully so a reset drops nothing
+void Server::closeTuiSessions() {
+	for (TuiSession* session : tui_sessions) {
+		asio::error_code ignored;
+		session->socket.shutdown(tcp::socket::shutdown_send, ignored);
+		session->socket.close(ignored);
+	}
+}
+
+/// lets the TUIs send what is still queued
+asio::awaitable<void> Server::flushTuiSessions() {
+	asio::steady_timer timer(co_await asio::this_coro::executor);
+	const auto deadline = std::chrono::steady_clock::now() + tui_flush_limit;
+	for (;;) {
+		bool busy = false;
+		for (const TuiSession* session : tui_sessions) {
+			busy = busy || !session->idle();
+		}
+		if (!busy || std::chrono::steady_clock::now() >= deadline) {
+			co_return;
+		}
+		timer.expires_after(std::chrono::milliseconds(5));
+		asio::error_code ignored;
+		co_await timer.async_wait(asio::redirect_error(asio::use_awaitable, ignored));
+	}
+}
+
+asio::awaitable<void> Server::runEngineListener(std::uint16_t port, bool infinite) {
+	auto executor = co_await asio::this_coro::executor;
+	auto& context = static_cast<asio::io_context&>(executor.context());
+	tcp::acceptor listener = listen(context, port);
+	note("Engine Listener running on 0.0.0.0:" + std::to_string(port));
+
+	// a second engine waits in the backlog
+	for (;;) {
+		tcp::socket socket = co_await listener.async_accept(asio::use_awaitable);
+		asio::error_code ignored;
+		const std::string peer_text = endpointText(socket.remote_endpoint(ignored));
+		note("Engine connected: " + peer_text);
+
+		if (auto session = storage.beginSession(); !session) {
+			note("Failed to open session log: " + session.error());
+		}
+
+		const SessionEnd end = co_await handleEngineConnection(socket, storage);
+
+		storage.addLog(buildEndLog(end));
+		co_await flushTuiSessions();
+
+		note("Engine disconnected: " + peer_text);
+
+		finishAndUpload(storage);
+
+		if (!infinite) {
+			note("Shutting down server (no --infinite).");
+			closeTuiSessions();
+			std::_Exit(0);
+		}
+	}
+}
+
+}  // namespace log_server
diff --git a/tools/log_server/src/server.hpp b/tools/log_server/src/server.hpp
new file mode 100644
index 000000000..c54a41597
--- /dev/null
+++ b/tools/log_server/src/server.hpp
@@ -0,0 +1,42 @@
+/**
+ * @file server.hpp
+ * @author Xein
+ * @date 25 Oct 2026
+ * @brief Engine and TUI listeners
+ */
+
+#pragma once
+
+#include "storage.hpp"
+
+#include <asio.hpp>
+#include <cstdint>
+#include <set>
+#include <string>
+
+namespace log_server {
+
+/// writes a line to stdout
+void note(const std::string& message);
+
+struct TuiSession;
+
+class Server {
+public:
+	explicit Server(LogStorage& storage) : storage(storage) {}
+
+	asio::awaitable<void> runTuiListener(std::uint16_t port);
+
+	/// serves one engine at a time
+	asio::awaitable<void> runEngineListener(std::uint16_t port, bool infinite);
+
+private:
+	asio::awaitable<void> handleTuiConnection(asio::ip::tcp::socket socket);
+	asio::awaitable<void> flushTuiSessions();
+	void closeTuiSessions();
+
+	LogStorage& storage;
+	std::set<TuiSession*> tui_sessions;
+};
+
+}  // namespace log_server
diff --git a/tools/log_server/src/server.rs b/tools/log_server/src/server.rs
deleted file mode 100644
index e045cd7e2..000000000
--- a/tools/log_server/src/server.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-use crate::proto::{log_data::Severity, LogBatch, LogData};
-use crate::storage::LogStorage;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use prost::Message;
-use std::sync::Arc;
-use tokio::sync::{Mutex, broadcast};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-pub struct Server {
-    storage: LogStorage,
-    engine_connected: Arc<Mutex<bool>>,
-}
-
-impl Server {
-    pub fn new(storage: LogStorage) -> Self {
-        Self {
-            storage,
-            engine_connected: Arc::new(Mutex::new(false)),
-        }
-    }
-
-    pub async fn run_tui_listener(&self, port: u16) -> Result<(), Box<dyn std::error::Error>> {
-        let addr = format!("0.0.0.0:{}", port);
-        let listener = TcpListener::bind(&addr).await?;
-        println!("TUI Listener running on {}", addr);
-
-        loop {
-            let (mut socket, peer_addr) = listener.accept().await?;
-            println!("TUI connected: {}", peer_addr);
-            let storage = self.storage.clone();
-
-            tokio::spawn(async move {
-                if let Err(e) = handle_tui_connection(&mut socket, storage).await {
-                    eprintln!("TUI connection error: {:?}", e);
-                }
-                println!("TUI disconnected: {}", peer_addr);
-            });
-        }
-    }
-
-    pub async fn run_engine_listener(&self, port: u16, infinite: bool) -> Result<(), Box<dyn std::error::Error>> {
-        let addr = format!("0.0.0.0:{}", port);
-        let listener = TcpListener::bind(&addr).await?;
-        println!("Engine Listener running on {}", addr);
-
-        loop {
-            let (mut socket, peer_addr) = listener.accept().await?;
-            println!("Engine connected: {}", peer_addr);
-
-            {
-                let mut connected = self.engine_connected.lock().await;
-                if *connected {
-                    // Reject every engine connection if we're already connected to one instance
-                    println!("Engine already connected, rejecting {}", peer_addr);
-                    continue;
-                }
-                *connected = true;
-            }
-
-            let storage = self.storage.clone();
-            if let Err(e) = handle_engine_connection(&mut socket, storage).await {
-                eprintln!("Engine connection error: {:?}", e);
-            }
-
-            println!("Engine disconnected: {}", peer_addr);
-
-            {
-                let mut connected = self.engine_connected.lock().await;
-                *connected = false;
-            }
-
-            // Save CSV
-            if let Err(e) = self.storage.save_csv().await {
-                eprintln!("Failed to save CSV: {:?}", e);
-            } else {
-                println!("Logs saved to CSV.");
-            }
-
-            if !infinite {
-                println!("Shutting down server (no --infinite).");
-                std::process::exit(0);
-            }
-        }
-    }
-}
-
-fn build_disconnect_log() -> LogData {
-    let timestamp = match SystemTime::now().duration_since(UNIX_EPOCH) {
-        Ok(duration) => duration.as_millis() as u64,
-        Err(_) => 0,
-    };
-
-    LogData {
-        timestamp,
-        severity: Severity::Critical as i32,
-        filepath: String::new(),
-        line_number: 0,
-        sink: "Log Server".to_string(),
-        message: "Toast Engine disconnected".to_string(),
-    }
-}
-
-async fn handle_engine_connection(socket: &mut TcpStream, storage: LogStorage) -> Result<(), Box<dyn std::error::Error>> {
-    loop {
-        let len = match socket.read_u32().await {
-            Ok(l) => l,
-            Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
-                send_disconnect_notice(&storage).await;
-                return Ok(());
-            }
-            Err(e) => {
-                send_disconnect_notice(&storage).await;
-                return Err(e.into());
-            }
-        };
-
-        let mut buf = vec![0u8; len as usize];
-        if let Err(e) = socket.read_exact(&mut buf).await {
-            if e.kind() == std::io::ErrorKind::UnexpectedEof {
-                send_disconnect_notice(&storage).await;
-                return Ok(());
-            }
-            send_disconnect_notice(&storage).await;
-            return Err(e.into());
-        }
-
-        let batch = LogBatch::decode(&buf[..])?;
-        storage.add_logs(batch).await;
-    }
-}
-
-async fn send_disconnect_notice(storage: &LogStorage) {
-    let disconnect_log = build_disconnect_log();
-    storage.add_logs(LogBatch { logs: vec![disconnect_log] }).await;
-    tokio::task::yield_now().await;
-}
-
-async fn handle_tui_connection(socket: &mut TcpStream, storage: LogStorage) -> Result<(), Box<dyn std::error::Error>> {
-    // Our approach for the TUI connection should be:
-    //    - On connection, make a batch of all the previous messages logged by the engine
-    //      so that the TUI isn't missing any information
-    //    - Then, every time we receive a log, we will send a unique TCP package to the
-    //      TUI. We may saturate the TCP connection of the TUI but having a log delayed a
-    //      couple of milliseconds is not that big of a deal if the timestamp is correct
-    // OPTIMIZE: How is this handled with CPUs that may not be able to allocate a thread
-    // to the TUI process??
-
-    // Send initial batch
-    let existing_logs = storage.get_all().await;
-    let batch = LogBatch { logs: existing_logs };
-    let mut buf = Vec::new();
-    batch.encode(&mut buf)?;
-    send_framed(socket, &batch).await?;
-
-    // Subscribe to new logs
-    let mut rx = storage.subscribe();
-    loop {
-        match rx.recv().await {
-            Ok(log) => {
-                let update_batch = LogBatch { logs: vec![log] };
-                send_framed(socket, &update_batch).await?;
-            }
-            Err(broadcast::error::RecvError::Lagged(_)) => {
-                // FIXME: lagged subscribers silently drop messages (broadcast capacity 1000)
-            }
-            Err(broadcast::error::RecvError::Closed) => {
-                break;
-            }
-        }
-    }
-    Ok(())
-}
-
-async fn send_framed(socket: &mut TcpStream, batch: &LogBatch) -> Result<(), Box<dyn std::error::Error>> {
-    let mut buf = Vec::new();
-    batch.encode(&mut buf)?;
-    let len = buf.len() as u32;
-    socket.write_u32(len).await?;
-    socket.write_all(&buf).await?;
-    Ok(())
-}
diff --git a/tools/log_server/src/storage.cpp b/tools/log_server/src/storage.cpp
new file mode 100644
index 000000000..f1c4f7f41
--- /dev/null
+++ b/tools/log_server/src/storage.cpp
@@ -0,0 +1,458 @@
+/**
+ * @file storage.cpp
+ * @author Xein
+ * @date 25 Oct 2026
+ */
+
+#include "storage.hpp"
+
+#include <array>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <optional>
+#include <span>
+#include <string_view>
+#include <utility>
+#include <system_error>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <cerrno>
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+namespace log_server {
+
+namespace {
+
+namespace fs = std::filesystem;
+
+constexpr std::array<std::string_view, 8> csv_header = {
+	"Timestamp", "Severity", "Filepath", "Line", "Sink", "Message", "Details", "Backtrace",
+};
+
+/// suffixes to try when a name is taken
+constexpr std::uint32_t max_name_attempts = 1000;
+
+std::optional<fs::path> envPath(const char* name) {
+#ifdef _WIN32
+	// getenv mangles non ascii names
+	const std::wstring wide_name(name, name + std::char_traits<char>::length(name));
+	const DWORD size = GetEnvironmentVariableW(wide_name.c_str(), nullptr, 0);
+	if (size <= 1) {
+		return std::nullopt;
+	}
+	std::wstring value(size, L'\0');
+	const DWORD written = GetEnvironmentVariableW(wide_name.c_str(), value.data(), size);
+	value.resize(written);
+	if (value.empty()) {
+		return std::nullopt;
+	}
+	return fs::path(value);
+#else
+	const char* value = std::getenv(name);
+	if (value == nullptr || *value == '\0') {
+		return std::nullopt;
+	}
+	return fs::path(value);
+#endif
+}
+
+std::string_view severityText(int severity) {
+	switch (severity) {
+		case 0: return "TRACE";
+		case 1: return "INFO";
+		case 2: return "WARNING";
+		case 3: return "ERROR";
+		case 4: return "CRITICAL";
+		default: return "UNKNOWN";
+	}
+}
+
+/// quoted only when needed
+void appendField(std::string& out, std::string_view field) {
+	if (field.find_first_of(",\"\r\n") == std::string_view::npos) {
+		out.append(field);
+		return;
+	}
+	out.push_back('"');
+	for (const char c : field) {
+		if (c == '"') {
+			out.push_back('"');
+		}
+		out.push_back(c);
+	}
+	out.push_back('"');
+}
+
+void appendRecord(std::string& out, std::span<const std::string_view> fields) {
+	bool first = true;
+	for (const auto field : fields) {
+		if (!first) {
+			out.push_back(',');
+		}
+		first = false;
+		appendField(out, field);
+	}
+	out.push_back('\n');
+}
+
+void appendLog(std::string& out, const LogData& log) {
+	const std::string timestamp = std::to_string(log.timestamp());
+	const std::string line = std::to_string(log.line_number());
+	const std::array<std::string_view, 8> fields = {
+		timestamp, severityText(log.severity()), log.filepath(), line, log.sink(), log.message(), log.details(), log.backtrace(),
+	};
+	appendRecord(out, fields);
+}
+
+#ifdef _WIN32
+using NativeFile = HANDLE;
+inline const NativeFile no_file = INVALID_HANDLE_VALUE;
+
+/// creates a file that must not exist
+NativeFile createNewFile(const fs::path& path, std::error_code& ec) {
+	const HANDLE handle = CreateFileW(
+	    path.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, nullptr
+	);
+	if (handle == INVALID_HANDLE_VALUE) {
+		ec.assign(static_cast<int>(GetLastError()), std::system_category());
+	}
+	return handle;
+}
+
+bool writeSome(NativeFile file, const char* data, std::size_t size, std::size_t& written, std::error_code& ec) {
+	DWORD count = 0;
+	if (!WriteFile(file, data, static_cast<DWORD>(std::min<std::size_t>(size, 1u << 30)), &count, nullptr)) {
+		ec.assign(static_cast<int>(GetLastError()), std::system_category());
+		return false;
+	}
+	written = count;
+	return true;
+}
+
+bool syncFile(NativeFile file, std::error_code& ec) {
+	if (!FlushFileBuffers(file)) {
+		ec.assign(static_cast<int>(GetLastError()), std::system_category());
+		return false;
+	}
+	return true;
+}
+
+void closeFile(NativeFile file) {
+	CloseHandle(file);
+}
+#else
+using NativeFile = int;
+constexpr NativeFile no_file = -1;
+
+NativeFile createNewFile(const fs::path& path, std::error_code& ec) {
+	const int fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0666);
+	if (fd < 0) {
+		ec.assign(errno, std::generic_category());
+	}
+	return fd;
+}
+
+bool writeSome(NativeFile file, const char* data, std::size_t size, std::size_t& written, std::error_code& ec) {
+	for (;;) {
+		const ssize_t count = ::write(file, data, size);
+		if (count >= 0) {
+			written = static_cast<std::size_t>(count);
+			return true;
+		}
+		if (errno != EINTR) {
+			ec.assign(errno, std::generic_category());
+			return false;
+		}
+	}
+}
+
+bool syncFile(NativeFile file, std::error_code& ec) {
+	if (::fsync(file) != 0) {
+		ec.assign(errno, std::generic_category());
+		return false;
+	}
+	return true;
+}
+
+void closeFile(NativeFile file) {
+	::close(file);
+}
+#endif
+
+/// adds a numeric suffix when the name is taken
+std::expected<std::pair<NativeFile, fs::path>, std::error_code> createUniqueFile(const fs::path& dir, const std::string& stamp) {
+	for (std::uint32_t attempt = 0; attempt < max_name_attempts; ++attempt) {
+		const std::string name = attempt == 0 ? stamp + ".csv" : stamp + "-" + std::to_string(attempt) + ".csv";
+		fs::path path = dir / name;
+		std::error_code ec;
+		const NativeFile file = createNewFile(path, ec);
+		if (!ec) {
+			return std::pair {file, std::move(path)};
+		}
+		if (ec != std::errc::file_exists) {
+			return std::unexpected(ec);
+		}
+	}
+	return std::unexpected(std::make_error_code(std::errc::file_exists));
+}
+
+std::string sessionStamp() {
+	const std::time_t now = std::time(nullptr);
+	std::tm local {};
+#ifdef _WIN32
+	localtime_s(&local, &now);
+#else
+	localtime_r(&now, &local);
+#endif
+	std::array<char, 32> text {};
+	const std::size_t size = std::strftime(text.data(), text.size(), "%Y-%m-%d_%H-%M-%S", &local);
+	return std::string(text.data(), size);
+}
+
+void report(const char* what, const std::error_code& ec) {
+	std::fprintf(stderr, "%s: %s\n", what, ec.message().c_str());
+}
+
+}  // namespace
+
+std::uint64_t nowNanos() {
+	const auto since_epoch = std::chrono::system_clock::now().time_since_epoch();
+	const auto nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(since_epoch).count();
+	return nanos < 0 ? 0 : static_cast<std::uint64_t>(nanos);
+}
+
+std::string toUtf8(const fs::path& path) {
+	const auto text = path.u8string();
+	return std::string(text.begin(), text.end());
+}
+
+std::vector<fs::path> candidateLogDirs() {
+	std::vector<fs::path> dirs;
+
+#ifdef _WIN32
+	const std::optional<fs::path> config_dir = envPath("APPDATA");
+#else
+	std::optional<fs::path> config_dir = envPath("XDG_CONFIG_HOME");
+	if (!config_dir) {
+		if (const auto home = envPath("HOME")) {
+			config_dir = *home / ".config";
+		}
+	}
+#endif
+
+	if (config_dir) {
+		dirs.push_back(*config_dir / "ToastEngine" / "logs");
+	}
+	dirs.emplace_back("./logs");
+	std::error_code ec;
+	auto temp = fs::temp_directory_path(ec);
+	if (ec) {
+		temp = ".";
+	}
+	dirs.push_back(temp / "ToastEngine" / "logs");
+	return dirs;
+}
+
+LogData serverLog(LogData::Severity severity, std::string message) {
+	LogData log;
+	log.set_timestamp(nowNanos());
+	log.set_severity(severity);
+	log.set_sink("Log Server");
+	log.set_message(std::move(message));
+	return log;
+}
+
+/// one session csv
+class SessionWriter {
+public:
+	SessionWriter(const SessionWriter&) = delete;
+	SessionWriter& operator=(const SessionWriter&) = delete;
+
+	~SessionWriter() {
+		closeFile(file);
+	}
+
+	/// writes the header
+	static std::expected<std::unique_ptr<SessionWriter>, std::error_code> start(NativeFile file) {
+		std::unique_ptr<SessionWriter> writer(new SessionWriter(file));
+		appendRecord(writer->buf, csv_header);
+		if (std::error_code ec = writer->commit()) {
+			return std::unexpected(ec);
+		}
+		return writer;
+	}
+
+	/// formats in memory then writes once
+	std::error_code append(const LogBatch& batch) {
+		for (const auto& log : batch.logs()) {
+			appendLog(buf, log);
+		}
+		return commit();
+	}
+
+	std::error_code finish() {
+		std::error_code ec;
+		syncFile(file, ec);
+		return ec;
+	}
+
+private:
+	explicit SessionWriter(NativeFile file) : file(file) {}
+
+	/// a failed write makes the next one start with a newline
+	std::error_code commit() {
+		if (buf.empty()) {
+			return {};
+		}
+		if (needs_newline) {
+			buf.insert(buf.begin(), '\n');
+		}
+		std::error_code ec;
+		const char* data = buf.data();
+		std::size_t left = buf.size();
+		while (left > 0 && !ec) {
+			std::size_t written = 0;
+			if (writeSome(file, data, left, written, ec)) {
+				data += written;
+				left -= written;
+			}
+		}
+		buf.clear();
+		needs_newline = static_cast<bool>(ec);
+		return ec;
+	}
+
+	NativeFile file = no_file;
+	/// rows are formatted here first
+	std::string buf;
+	/// the last write failed
+	bool needs_newline = false;
+};
+
+LogStorage::LogStorage() = default;
+LogStorage::~LogStorage() = default;
+
+std::expected<fs::path, std::string> LogStorage::beginSession() {
+	const std::string stamp = sessionStamp();
+	std::optional<std::error_code> last_error;
+
+	for (const auto& candidate : candidateLogDirs()) {
+		std::error_code ec;
+		fs::path dir = fs::absolute(candidate, ec);
+		if (ec) {
+			dir = candidate;
+			ec.clear();
+		}
+		dir = dir.lexically_normal();
+		if (dir.has_filename() == false && dir.has_parent_path()) {
+			dir = dir.parent_path();
+		}
+
+		fs::create_directories(dir, ec);
+		if (ec) {
+			last_error = ec;
+			continue;
+		}
+		auto created = createUniqueFile(dir, stamp);
+		if (!created) {
+			last_error = created.error();
+			continue;
+		}
+		auto [file, path] = std::move(*created);
+		auto writer = SessionWriter::start(file);
+		if (!writer) {
+			last_error = writer.error();  // start closed the file
+			continue;
+		}
+		{
+			std::scoped_lock lock(session_mutex);
+			session = std::move(*writer);
+			session_path = path;
+			session_started = std::chrono::system_clock::now();
+			session_began = std::chrono::steady_clock::now();
+		}
+		addLog(serverLog(LogData::INFO, "Saving logs to " + toUtf8(path)));
+		return path;
+	}
+
+	return std::unexpected(last_error ? last_error->message() : std::string("no log directory candidates"));
+}
+
+void LogStorage::addLogs(LogBatch&& batch) {
+	// on disk before it is broadcast
+	{
+		std::scoped_lock lock(session_mutex);
+		if (session) {
+			if (const std::error_code ec = session->append(batch)) {
+				report("Failed to write session log", ec);
+			}
+		}
+	}
+
+	for (auto& log : *batch.mutable_logs()) {
+		// broadcast first then store
+		for (const auto& [id, subscriber] : subscribers) {
+			subscriber(log);
+		}
+		logs.push_back(std::move(log));
+	}
+}
+
+void LogStorage::addLog(LogData&& log) {
+	LogBatch batch;
+	*batch.add_logs() = std::move(log);
+	addLogs(std::move(batch));
+}
+
+LogBatch LogStorage::snapshot() const {
+	LogBatch batch;
+	batch.mutable_logs()->Reserve(static_cast<int>(logs.size()));
+	for (const auto& log : logs) {
+		*batch.add_logs() = log;
+	}
+	return batch;
+}
+
+std::uint64_t LogStorage::subscribe(Subscriber subscriber) {
+	const std::uint64_t id = next_subscriber++;
+	subscribers.emplace(id, std::move(subscriber));
+	return id;
+}
+
+void LogStorage::unsubscribe(std::uint64_t id) {
+	subscribers.erase(id);
+}
+
+std::optional<SessionSummary> LogStorage::finishSession() {
+	std::unique_ptr<SessionWriter> writer;
+	SessionSummary summary;
+	{
+		std::scoped_lock lock(session_mutex);
+		writer = std::move(session);
+		summary.path = std::move(session_path);
+		summary.started = session_started;
+		summary.duration = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - session_began);
+	}
+	if (!writer) {
+		return std::nullopt;
+	}
+	if (const std::error_code ec = writer->finish()) {
+		report("Failed to finish session log", ec);
+	}
+	// the size is only final after closing
+	writer.reset();
+	std::error_code ec;
+	summary.size = fs::file_size(summary.path, ec);
+	if (ec) {
+		summary.size = 0;
+	}
+	return summary;
+}
+
+}  // namespace log_server
diff --git a/tools/log_server/src/storage.hpp b/tools/log_server/src/storage.hpp
new file mode 100644
index 000000000..0b20264ec
--- /dev/null
+++ b/tools/log_server/src/storage.hpp
@@ -0,0 +1,92 @@
+/**
+ * @file storage.hpp
+ * @author Xein
+ * @date 25 Oct 2026
+ * @brief Log store and session csv
+ */
+
+#pragma once
+
+#include "logging.pb.h"
+
+#include <chrono>
+#include <cstdint>
+#include <deque>
+#include <expected>
+#include <filesystem>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace log_server {
+
+using LogData = proto::logging::LogData;
+using LogBatch = proto::logging::LogBatch;
+
+/// nanoseconds since the unix epoch
+std::uint64_t nowNanos();
+
+/// where the session csv can go
+std::vector<std::filesystem::path> candidateLogDirs();
+
+/// utf8 text of a path
+std::string toUtf8(const std::filesystem::path& path);
+
+/// a row written by the server itself
+LogData serverLog(LogData::Severity severity, std::string message);
+
+class SessionWriter;
+
+/// what is known once the file is closed
+struct SessionSummary {
+	std::filesystem::path path;
+	std::chrono::system_clock::time_point started;
+	std::chrono::seconds duration {0};
+	/// bytes of the csv
+	std::uint64_t size = 0;
+};
+
+/// owns every log and the session csv
+class LogStorage {
+public:
+	using Subscriber = std::function<void(const LogData&)>;
+
+	LogStorage();
+	~LogStorage();
+	LogStorage(const LogStorage&) = delete;
+	LogStorage& operator=(const LogStorage&) = delete;
+
+	/// opens the session csv in the first usable directory
+	std::expected<std::filesystem::path, std::string> beginSession();
+
+	/// writes the batch then broadcasts it
+	void addLogs(LogBatch&& batch);
+	void addLog(LogData&& log);
+
+	/// copy of every row
+	LogBatch snapshot() const;
+
+	/// calls subscriber for every new row
+	std::uint64_t subscribe(Subscriber subscriber);
+	void unsubscribe(std::uint64_t id);
+
+	/// closes the file and returns its summary once
+	std::optional<SessionSummary> finishSession();
+
+private:
+	std::deque<LogData> logs;
+	std::map<std::uint64_t, Subscriber> subscribers;
+	std::uint64_t next_subscriber = 0;
+
+	std::mutex session_mutex;
+	std::unique_ptr<SessionWriter> session;
+	std::filesystem::path session_path;
+	std::chrono::system_clock::time_point session_started;
+	std::chrono::steady_clock::time_point session_began;
+};
+
+}  // namespace log_server
diff --git a/tools/log_server/src/storage.rs b/tools/log_server/src/storage.rs
deleted file mode 100644
index ec39421b9..000000000
--- a/tools/log_server/src/storage.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use crate::proto::{LogBatch, LogData};
-use std::sync::Arc;
-use tokio::sync::{broadcast, RwLock};
-use std::path::Path;
-use std::fs;
-use chrono::Local;
-
-#[derive(Clone)]
-pub struct LogStorage {
-    logs: Arc<RwLock<Vec<LogData>>>,
-    tx: broadcast::Sender<LogData>,
-}
-
-impl LogStorage {
-    pub fn new() -> Self {
-        let (tx, _) = broadcast::channel(1000);
-        Self {
-            logs: Arc::new(RwLock::new(Vec::new())),
-            tx,
-        }
-    }
-
-    pub async fn add_logs(&self, batch: LogBatch) {
-        let mut logs = self.logs.write().await;
-        for log in batch.logs {
-            // Broadcast first, then store
-            let _ = self.tx.send(log.clone());
-            logs.push(log);
-        }
-    }
-
-    pub async fn get_all(&self) -> Vec<LogData> {
-        self.logs.read().await.clone()
-    }
-
-    pub fn subscribe(&self) -> broadcast::Receiver<LogData> {
-        // broadcast capacity is 1000; lagged subscribers silently drop messages
-        self.tx.subscribe()
-    }
-
-    pub async fn save_csv(&self) -> Result<String, Box<dyn std::error::Error>> {
-        let logs = self.logs.read().await;
-        let now = Local::now();
-        // path is relative to the working directory; the logs/ dir is created if it doesn't exist
-        let filename = format!("logs/{}.csv", now.format("%Y-%m-%d_%H-%M-%S"));
-        let path = Path::new(&filename);
-
-        if let Some(parent) = path.parent() {
-            fs::create_dir_all(parent)?;
-        }
-
-        let mut wtr = csv::Writer::from_path(path)?;
-        
-        // Write header
-        wtr.write_record(&["Timestamp", "Severity", "Filepath", "Line", "Sink", "Message"])?;
-
-        for log in logs.iter() {
-            let severity_str = match log.severity {
-                0 => "TRACE",
-                1 => "INFO",
-                2 => "WARNING",
-                3 => "ERROR",
-                4 => "CRITICAL",
-                _ => "UNKNOWN",
-            };
-
-            wtr.write_record(&[
-                log.timestamp.to_string(),
-                severity_str.to_string(),
-                log.filepath.clone(),
-                log.line_number.to_string(),
-                log.sink.clone(),
-                log.message.clone(),
-            ])?;
-        }
-
-        wtr.flush()?;
-        Ok(filename)
-    }
-}
diff --git a/tools/log_server/src/upload.cpp b/tools/log_server/src/upload.cpp
new file mode 100644
index 000000000..96bf48967
--- /dev/null
+++ b/tools/log_server/src/upload.cpp
@@ -0,0 +1,519 @@
+/**
+ * @file upload.cpp
+ * @author Xein
+ * @date 25 Oct 2026
+ */
+
+#include "upload.hpp"
+
+#include "remote_config.hpp"
+
+#include <array>
+#include <charconv>
+#include <cstdlib>
+#include <cstdio>
+#include <ctime>
+#include <fstream>
+#include <memory>
+#include <nlohmann/json.hpp>
+#include <optional>
+#include <string_view>
+#include <zlib.h>
+
+#include <curl/curl.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <fcntl.h>
+#include <csignal>
+#include <pwd.h>
+#include <unistd.h>
+#endif
+
+namespace log_server {
+
+namespace {
+
+namespace fs = std::filesystem;
+
+constexpr long connect_timeout_s = 10;
+constexpr long token_timeout_s = 30;
+/// slower than 1 KB/s for this long is given up on
+constexpr long stall_limit_s = 60;
+
+struct TempFile {
+	fs::path path;
+	~TempFile() {
+		std::error_code ec;
+		fs::remove(path, ec);
+	}
+};
+
+struct CurlHandle {
+	CURL* handle = curl_easy_init();
+	~CurlHandle() { curl_easy_cleanup(handle); }
+};
+
+struct SlistGuard {
+	curl_slist* list = nullptr;
+	~SlistGuard() { curl_slist_free_all(list); }
+};
+
+struct MimeGuard {
+	curl_mime* mime = nullptr;
+	~MimeGuard() { curl_mime_free(mime); }
+};
+
+std::size_t appendToString(char* data, std::size_t size, std::size_t count, void* user) {
+	static_cast<std::string*>(user)->append(data, size * count);
+	return size * count;
+}
+
+void setCommon(CURL* handle, const std::string& url) {
+	curl_easy_setopt(handle, CURLOPT_URL, url.c_str());
+	curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, connect_timeout_s);
+	curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1L);
+	curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 0L);
+}
+
+std::optional<std::string> fetchToken(const std::string& base) {
+	CurlHandle curl;
+	if (curl.handle == nullptr) {
+		return std::nullopt;
+	}
+	std::string body;
+	setCommon(curl.handle, base + "/kenzo/token");
+	curl_easy_setopt(curl.handle, CURLOPT_TIMEOUT, token_timeout_s);
+	curl_easy_setopt(curl.handle, CURLOPT_WRITEFUNCTION, appendToString);
+	curl_easy_setopt(curl.handle, CURLOPT_WRITEDATA, &body);
+	if (curl_easy_perform(curl.handle) != CURLE_OK) {
+		return std::nullopt;
+	}
+	long status = 0;
+	curl_easy_getinfo(curl.handle, CURLINFO_RESPONSE_CODE, &status);
+	if (status != 200) {
+		return std::nullopt;
+	}
+	const auto json = nlohmann::json::parse(body, nullptr, false);
+	if (!json.is_object() || !json.contains("token") || !json["token"].is_string()) {
+		return std::nullopt;
+	}
+	return json["token"].get<std::string>();
+}
+
+/// the compressed file as a curl mime part
+struct FileSource {
+	std::ifstream in;
+	curl_off_t size = 0;
+};
+
+std::size_t readFileSource(char* buffer, std::size_t size, std::size_t count, void* user) {
+	auto* source = static_cast<FileSource*>(user);
+	source->in.read(buffer, static_cast<std::streamsize>(size * count));
+	return static_cast<std::size_t>(source->in.gcount());
+}
+
+int seekFileSource(void* user, curl_off_t offset, int origin) {
+	auto* source = static_cast<FileSource*>(user);
+	source->in.clear();
+	const auto dir = origin == SEEK_SET ? std::ios::beg : origin == SEEK_CUR ? std::ios::cur : std::ios::end;
+	source->in.seekg(static_cast<std::streamoff>(offset), dir);
+	return source->in ? CURL_SEEKFUNC_OK : CURL_SEEKFUNC_CANTSEEK;
+}
+
+bool postSession(const std::string& base, const std::string& token, const UploadJob& job, const fs::path& gz) {
+	FileSource source;
+	source.in.open(gz, std::ios::binary);
+	if (!source.in) {
+		return false;
+	}
+	std::error_code ec;
+	source.size = static_cast<curl_off_t>(fs::file_size(gz, ec));
+	if (ec) {
+		return false;
+	}
+
+	CurlHandle curl;
+	if (curl.handle == nullptr) {
+		return false;
+	}
+	MimeGuard mime;
+	mime.mime = curl_mime_init(curl.handle);
+	const auto text = [&](const char* name, const std::string& value) {
+		curl_mimepart* part = curl_mime_addpart(mime.mime);
+		curl_mime_name(part, name);
+		curl_mime_data(part, value.data(), value.size());
+	};
+	text("host", job.host);
+	text("user", job.user);
+	text("started", job.started);
+	text("duration_s", std::to_string(job.duration_s));
+	text("size", std::to_string(job.size));
+	curl_mimepart* file = curl_mime_addpart(mime.mime);
+	curl_mime_name(file, "file");
+	curl_mime_filename(file, (toUtf8(job.csv.stem()) + ".csv.gz").c_str());
+	curl_mime_type(file, "application/gzip");
+	curl_mime_data_cb(file, source.size, readFileSource, seekFileSource, nullptr, &source);
+
+	SlistGuard headers;
+	headers.list = curl_slist_append(headers.list, ("Authorization: Bearer " + token).c_str());
+	// skip the Expect 100-continue round trip
+	headers.list = curl_slist_append(headers.list, "Expect:");
+
+	std::string response;
+	setCommon(curl.handle, base + "/api/collections/logs/records");
+	curl_easy_setopt(curl.handle, CURLOPT_HTTPHEADER, headers.list);
+	curl_easy_setopt(curl.handle, CURLOPT_MIMEPOST, mime.mime);
+	curl_easy_setopt(curl.handle, CURLOPT_TIMEOUT, g_upload_timeout_seconds);
+	curl_easy_setopt(curl.handle, CURLOPT_LOW_SPEED_LIMIT, 1024L);
+	curl_easy_setopt(curl.handle, CURLOPT_LOW_SPEED_TIME, stall_limit_s);
+	curl_easy_setopt(curl.handle, CURLOPT_WRITEFUNCTION, appendToString);
+	curl_easy_setopt(curl.handle, CURLOPT_WRITEDATA, &response);
+	if (curl_easy_perform(curl.handle) != CURLE_OK) {
+		return false;
+	}
+	long status = 0;
+	curl_easy_getinfo(curl.handle, CURLINFO_RESPONSE_CODE, &status);
+	return status >= 200 && status < 300;
+}
+
+#ifdef _WIN32
+std::string narrow(const std::wstring& wide) {
+	if (wide.empty()) {
+		return {};
+	}
+	const int size = WideCharToMultiByte(CP_UTF8, 0, wide.data(), static_cast<int>(wide.size()), nullptr, 0, nullptr, nullptr);
+	std::string out(static_cast<std::size_t>(size), '\0');
+	WideCharToMultiByte(CP_UTF8, 0, wide.data(), static_cast<int>(wide.size()), out.data(), size, nullptr, nullptr);
+	return out;
+}
+#endif
+
+}  // namespace
+
+std::string formatUtc(std::chrono::system_clock::time_point time) {
+	using namespace std::chrono;
+	const auto millis = duration_cast<milliseconds>(time.time_since_epoch());
+	const std::time_t seconds = static_cast<std::time_t>(floor<std::chrono::seconds>(millis).count());
+	std::tm utc {};
+#ifdef _WIN32
+	gmtime_s(&utc, &seconds);
+#else
+	gmtime_r(&seconds, &utc);
+#endif
+	const auto fraction = static_cast<int>((millis - floor<std::chrono::seconds>(millis)).count());
+	std::array<char, 40> text {};
+	std::snprintf(text.data(), text.size(), "%04d-%02d-%02d %02d:%02d:%02d.%03dZ", utc.tm_year + 1900, utc.tm_mon + 1, utc.tm_mday,
+	              utc.tm_hour, utc.tm_min, utc.tm_sec, fraction);
+	return text.data();
+}
+
+std::string hostName() {
+	std::string name;
+#ifdef _WIN32
+	DWORD size = 0;
+	GetComputerNameExW(ComputerNameDnsHostname, nullptr, &size);
+	if (size > 1) {
+		std::wstring wide(size, L'\0');
+		if (GetComputerNameExW(ComputerNameDnsHostname, wide.data(), &size)) {
+			wide.resize(size);
+			name = narrow(wide);
+		}
+	}
+#else
+	std::array<char, 256> buffer {};
+	if (gethostname(buffer.data(), buffer.size() - 1) == 0) {
+		name = buffer.data();
+	}
+#endif
+	return name.empty() ? "unknown" : name;
+}
+
+std::string userName() {
+	std::string name;
+#ifdef _WIN32
+	DWORD size = 0;
+	GetUserNameW(nullptr, &size);
+	if (size > 1) {
+		std::wstring wide(size, L'\0');
+		if (GetUserNameW(wide.data(), &size)) {
+			wide.resize(size > 0 ? size - 1 : 0);
+			name = narrow(wide);
+		}
+	}
+#else
+	if (const passwd* entry = getpwuid(getuid()); entry != nullptr && entry->pw_name != nullptr) {
+		name = entry->pw_name;
+	}
+#endif
+	return name.empty() ? "unknown" : name;
+}
+
+bool gzipFile(const fs::path& in_path, const fs::path& out_path) {
+	std::ifstream in(in_path, std::ios::binary);
+	std::ofstream out(out_path, std::ios::binary | std::ios::trunc);
+	if (!in || !out) {
+		return false;
+	}
+	z_stream stream {};
+	if (deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
+		return false;
+	}
+	std::array<char, 65536> input {};
+	std::array<char, 65536> output {};
+	bool ok = true;
+	bool done = false;
+	while (ok && !done) {
+		in.read(input.data(), static_cast<std::streamsize>(input.size()));
+		const auto got = in.gcount();
+		if (!in.eof() && !in) {
+			ok = false;
+			break;
+		}
+		const int flush = in.eof() ? Z_FINISH : Z_NO_FLUSH;
+		stream.next_in = reinterpret_cast<Bytef*>(input.data());
+		stream.avail_in = static_cast<uInt>(got);
+		do {
+			stream.next_out = reinterpret_cast<Bytef*>(output.data());
+			stream.avail_out = static_cast<uInt>(output.size());
+			const int status = deflate(&stream, flush);
+			if (status == Z_STREAM_ERROR) {
+				ok = false;
+				break;
+			}
+			out.write(output.data(), static_cast<std::streamsize>(output.size() - stream.avail_out));
+			if (!out) {
+				ok = false;
+				break;
+			}
+		} while (stream.avail_out == 0);
+		done = flush == Z_FINISH;
+	}
+	deflateEnd(&stream);
+	out.close();
+	return ok && !out.fail();
+}
+
+void runUpload(const UploadJob& job) {
+	try {
+		static const bool curl_ready = curl_global_init(CURL_GLOBAL_DEFAULT) == CURLE_OK;
+		if (!curl_ready) {
+			return;
+		}
+		const std::string base = remoteBaseUrl();
+		if (base.empty()) {
+			return;
+		}
+		TempFile gz {fs::path(job.csv).concat(".gz.tmp")};
+		if (!gzipFile(job.csv, gz.path)) {
+			return;
+		}
+		const auto token = fetchToken(base);
+		if (!token) {
+			return;
+		}
+		postSession(base, *token, job, gz.path);
+	} catch (...) {
+		// best effort
+	}
+}
+
+std::vector<std::string> uploadArgs(const UploadJob& job) {
+	return {"--upload",   toUtf8(job.csv),  "--host", job.host, "--user", job.user, "--started", job.started,
+	        "--duration", std::to_string(job.duration_s), "--size", std::to_string(job.size)};
+}
+
+std::optional<UploadJob> parseUploadArgs(const std::vector<std::string>& args) {
+	if (args.size() < 2 || args[0] != "--upload") {
+		return std::nullopt;
+	}
+	UploadJob job;
+	job.csv = fs::path(std::u8string(args[1].begin(), args[1].end()));
+	bool have_duration = false;
+	bool have_size = false;
+	for (std::size_t i = 2; i < args.size(); i += 2) {
+		if (i + 1 >= args.size()) {
+			return std::nullopt;
+		}
+		const std::string& key = args[i];
+		const std::string& value = args[i + 1];
+		const auto number = [&](std::uint64_t& out) {
+			const auto [end, ec] = std::from_chars(value.data(), value.data() + value.size(), out);
+			return ec == std::errc() && end == value.data() + value.size();
+		};
+		if (key == "--host") {
+			job.host = value;
+		} else if (key == "--user") {
+			job.user = value;
+		} else if (key == "--started") {
+			job.started = value;
+		} else if (key == "--duration") {
+			if (!number(job.duration_s)) {
+				return std::nullopt;
+			}
+			have_duration = true;
+		} else if (key == "--size") {
+			if (!number(job.size)) {
+				return std::nullopt;
+			}
+			have_size = true;
+		} else {
+			return std::nullopt;
+		}
+	}
+	if (job.host.empty() || job.user.empty() || job.started.empty() || !have_duration || !have_size) {
+		return std::nullopt;
+	}
+	return job;
+}
+
+namespace {
+
+#ifdef _WIN32
+std::wstring widen(const std::string& text) {
+	if (text.empty()) {
+		return {};
+	}
+	const int size = MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), nullptr, 0);
+	std::wstring out(static_cast<std::size_t>(size), L'\0');
+	MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), out.data(), size);
+	return out;
+}
+
+/// quoting as CommandLineToArgvW reads it back
+std::wstring quoteArg(const std::wstring& arg) {
+	if (!arg.empty() && arg.find_first_of(L" \t\n\v\"") == std::wstring::npos) {
+		return arg;
+	}
+	std::wstring out = L"\"";
+	for (auto it = arg.begin();; ++it) {
+		std::size_t backslashes = 0;
+		while (it != arg.end() && *it == L'\\') {
+			++it;
+			++backslashes;
+		}
+		if (it == arg.end()) {
+			out.append(backslashes * 2, L'\\');
+			break;
+		}
+		if (*it == L'"') {
+			out.append(backslashes * 2 + 1, L'\\');
+		} else {
+			out.append(backslashes, L'\\');
+		}
+		out.push_back(*it);
+	}
+	out.push_back(L'"');
+	return out;
+}
+
+bool spawnDetached(const std::vector<std::string>& args) {
+	std::wstring exe(MAX_PATH, L'\0');
+	for (;;) {
+		const DWORD length = GetModuleFileNameW(nullptr, exe.data(), static_cast<DWORD>(exe.size()));
+		if (length == 0) {
+			return false;
+		}
+		if (length < exe.size()) {
+			exe.resize(length);
+			break;
+		}
+		exe.resize(exe.size() * 2);
+	}
+	std::wstring command = quoteArg(exe);
+	for (const auto& arg : args) {
+		command += L' ' + quoteArg(widen(arg));
+	}
+	STARTUPINFOW startup {};
+	startup.cb = sizeof(startup);
+	PROCESS_INFORMATION process {};
+	const DWORD flags = DETACHED_PROCESS | CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP | CREATE_UNICODE_ENVIRONMENT;
+	if (!CreateProcessW(exe.c_str(), command.data(), nullptr, nullptr, FALSE, flags, nullptr, nullptr, &startup, &process)) {
+		return false;
+	}
+	CloseHandle(process.hThread);
+	CloseHandle(process.hProcess);
+	return true;
+}
+#else
+bool spawnDetached(const std::vector<std::string>& args) {
+	std::error_code ec;
+	const fs::path exe = fs::read_symlink("/proc/self/exe", ec);
+	if (ec) {
+		return false;
+	}
+	std::vector<std::string> storage;
+	storage.push_back(exe.string());
+	storage.insert(storage.end(), args.begin(), args.end());
+	std::vector<char*> argv;
+	for (auto& arg : storage) {
+		argv.push_back(arg.data());
+	}
+	argv.push_back(nullptr);
+
+	// no zombies when running with --infinite
+	signal(SIGCHLD, SIG_IGN);
+	const pid_t child = fork();
+	if (child < 0) {
+		return false;
+	}
+	if (child == 0) {
+		setsid();
+		// sockets must not outlive the server
+		const long limit = sysconf(_SC_OPEN_MAX);
+		for (int fd = 3; fd < (limit > 0 && limit < 65536 ? limit : 65536); ++fd) {
+			close(fd);
+		}
+		const int null = open("/dev/null", O_RDWR);
+		if (null >= 0) {
+			dup2(null, 0);
+			dup2(null, 1);
+			dup2(null, 2);
+		}
+		execv(argv[0], argv.data());
+		_exit(0);
+	}
+	return true;
+}
+#endif
+
+}  // namespace
+
+void spawnUploader(const SessionSummary& summary) {
+	try {
+		if (const char* off = std::getenv("KENZO_NO_UPLOAD"); off != nullptr && std::string_view(off) == "1") {
+			return;
+		}
+		std::error_code ec;
+		if (summary.size == 0 || summary.path.empty() || !fs::exists(summary.path, ec)) {
+			return;
+		}
+		if (remoteBaseUrl().empty()) {
+			return;
+		}
+		UploadJob job;
+		job.csv = summary.path;
+		job.host = hostName();
+		job.user = userName();
+		job.started = formatUtc(summary.started);
+		job.duration_s = static_cast<std::uint64_t>(summary.duration.count());
+		job.size = summary.size;
+		const auto args = uploadArgs(job);
+		if (g_spawn_override) {
+			g_spawn_override(args);
+		} else {
+			spawnDetached(args);
+		}
+	} catch (...) {
+		// never get in the way of shutting down
+	}
+}
+
+void finishAndUpload(LogStorage& storage) {
+	if (const auto summary = storage.finishSession()) {
+		spawnUploader(*summary);
+	}
+}
+
+}  // namespace log_server
diff --git a/tools/log_server/src/upload.hpp b/tools/log_server/src/upload.hpp
new file mode 100644
index 000000000..ddcc8fb3a
--- /dev/null
+++ b/tools/log_server/src/upload.hpp
@@ -0,0 +1,63 @@
+/**
+ * @file upload.hpp
+ * @author Xein
+ * @date 25 Oct 2026
+ * @brief Upload of a finished session
+ */
+
+#pragma once
+
+#include "storage.hpp"
+
+#include <chrono>
+#include <cstdint>
+#include <filesystem>
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace log_server {
+
+struct UploadJob {
+	std::filesystem::path csv;
+	std::string host;
+	std::string user;
+	std::string started;
+	std::uint64_t duration_s = 0;
+	/// bytes of the csv
+	std::uint64_t size = 0;
+};
+
+/// utc timestamp as PocketBase prints it
+std::string formatUtc(std::chrono::system_clock::time_point time);
+
+/// machine and account names
+std::string hostName();
+std::string userName();
+
+/// gzips in into out
+bool gzipFile(const std::filesystem::path& in, const std::filesystem::path& out);
+
+/// seconds the upload may take
+inline long g_upload_timeout_seconds = 300;
+
+/// gzips the csv and posts the session
+void runUpload(const UploadJob& job);
+
+/// arguments that make log_server upload a job
+std::vector<std::string> uploadArgs(const UploadJob& job);
+
+/// inverse of uploadArgs
+std::optional<UploadJob> parseUploadArgs(const std::vector<std::string>& args);
+
+/// replaces the real spawn for the checks
+inline std::function<bool(const std::vector<std::string>&)> g_spawn_override;
+
+/// starts a detached upload for the finished session
+void spawnUploader(const SessionSummary& summary);
+
+/// finishes the session then spawns the uploader
+void finishAndUpload(LogStorage& storage);
+
+}  // namespace log_server
diff --git a/vcpkg.json b/vcpkg.json
index 9a9a8415d..d7a00fb2f 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -96,6 +96,12 @@
       "name": "lz4",
       "version>=": "1.10.0"
     },
+    {
+      "name": "curl"
+    },
+    {
+      "name": "zlib"
+    },
     {
       "name": "luabridge3",
       "version>=": "3.0-rc3"
@@ -117,6 +123,16 @@
     {
       "name": "rmlui",
       "version>=": "6.2"
+    },
+    {
+      "name": "cpptrace",
+      "features": [
+        {
+          "name": "libunwind",
+          "platform": "linux"
+        }
+      ],
+      "version>=": "1.0.4"
     }
   ],
   "overrides": [