[common/logging] Simplify logging logic and fix issues when logging before system is created (#3688)

- our logging code was bigger than spdlog itself, why???? just keep it simple
- fix issues when logging before logging system is even started
- removes the "initialized logging twice" issue
- removes uneeded indirection in file logging
- uses direct formatting instead of jumping hoopla-around the fmt::format() ressult
- code duplication and dead code removal as usual

I did explore dup2() but I think it's not worth the hassle
I did try `fwopen()` but it's better if things are just kept as-is.

there is a lot of noise because I removed a bunch of redundant files on logging and just put everything in one file

now normally this wouldn't be a good idea, however consider: the complexity of logging; it's less than 500 lines... does it really need a whole subsystem?!?!?! ITS JUST LOGGING

Signed-off-by: lizzie <lizzie@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3688
Reviewed-by: crueter <crueter@eden-emu.dev>
Reviewed-by: DraVee <chimera@dravee.dev>
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>

src/android/app/src/main/jni/android_config.cpp

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include <common/fs/path_util.h>
-#include <common/logging/log.h>
+#include <common/logging.h>
 #include <common/settings.h>
 #include <input_common/main.h>
 #include "android_config.h"

src/android/app/src/main/jni/emu_window/emu_window.cpp

@@ -7,7 +7,7 @@
 #include <android/native_window_jni.h>
 
 #include "common/android/id_cache.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "input_common/drivers/android.h"
 #include "input_common/drivers/touch_screen.h"
 #include "input_common/drivers/virtual_amiibo.h"

src/android/app/src/main/jni/native.cpp

@@ -42,8 +42,7 @@
 #include "common/detached_tasks.h"
 #include "common/dynamic_library.h"
 #include "common/fs/path_util.h"
-#include "common/logging/backend.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scm_rev.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"

src/android/app/src/main/jni/native_config.cpp

@@ -10,7 +10,7 @@
 #include "common/android/android_common.h"
 #include "common/android/id_cache.h"
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "frontend_common/config.h"
 #include "frontend_common/settings_generator.h"

src/android/app/src/main/jni/native_freedreno.cpp

@@ -23,7 +23,7 @@
 #include <jni.h>
 
 #include "common/android/android_common.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "native.h"
 
 namespace {

src/android/app/src/main/jni/native_log.cpp

@@ -1,8 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <common/android/android_common.h>
-#include <common/logging/log.h>
+#include <common/logging.h>
 #include <jni.h>
 
 extern "C" {

src/audio_core/adsp/apps/audio_renderer/audio_renderer.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -11,7 +11,7 @@
 #include "audio_core/audio_core.h"
 #include "audio_core/common/common.h"
 #include "audio_core/sink/sink.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/core_timing.h"

src/audio_core/adsp/apps/opus/opus_decoder.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -12,7 +12,7 @@
 #include "audio_core/adsp/apps/opus/shared_memory.h"
 #include "audio_core/audio_core.h"
 #include "audio_core/common/common.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/core_timing.h"

src/audio_core/in/audio_in_system.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -9,7 +9,7 @@
 #include "audio_core/audio_event.h"
 #include "audio_core/audio_manager.h"
 #include "audio_core/in/audio_in_system.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"

src/audio_core/out/audio_out_system.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -9,7 +9,7 @@
 #include "audio_core/audio_event.h"
 #include "audio_core/audio_manager.h"
 #include "audio_core/out/audio_out_system.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"

src/audio_core/renderer/command/data_source/decode.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -10,7 +10,7 @@
 #include "audio_core/renderer/command/data_source/decode.h"
 #include "audio_core/renderer/command/resample/resample.h"
 #include "common/fixed_point.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scratch_buffer.h"
 #include "core/guest_memory.h"
 #include "core/memory.h"

src/audio_core/renderer/command/mix/mix_ramp.cpp

@@ -1,10 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "audio_core/adsp/apps/audio_renderer/command_list_processor.h"
 #include "audio_core/renderer/command/mix/mix_ramp.h"
 #include "common/fixed_point.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 namespace AudioCore::Renderer {
 

src/audio_core/renderer/command/mix/volume.cpp

@@ -1,10 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "audio_core/adsp/apps/audio_renderer/command_list_processor.h"
 #include "audio_core/renderer/command/mix/volume.h"
 #include "common/fixed_point.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 namespace AudioCore::Renderer {
 /**

src/audio_core/renderer/nodes/node_states.cpp

@@ -1,8 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "audio_core/renderer/nodes/node_states.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 namespace AudioCore::Renderer {
 

src/audio_core/sink/cubeb_sink.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -10,7 +10,7 @@
 #include "audio_core/common/common.h"
 #include "audio_core/sink/cubeb_sink.h"
 #include "audio_core/sink/sink_stream.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
 

src/audio_core/sink/oboe_sink.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,7 +12,7 @@
 #include "audio_core/common/common.h"
 #include "audio_core/sink/oboe_sink.h"
 #include "audio_core/sink/sink_stream.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
 

src/audio_core/sink/sdl2_sink.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -12,7 +12,7 @@
 #include "audio_core/common/common.h"
 #include "audio_core/sink/sdl2_sink.h"
 #include "audio_core/sink/sink_stream.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
 

src/audio_core/sink/sink_details.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -20,7 +20,7 @@
 #include "audio_core/sink/sdl2_sink.h"
 #endif
 #include "audio_core/sink/null_sink.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings_enums.h"
 
 namespace AudioCore::Sink {

src/common/CMakeLists.txt

@@ -75,16 +75,8 @@ add_library(
     input.h
     intrusive_red_black_tree.h
     literals.h
-    logging/backend.cpp
-    logging/backend.h
-    logging/filter.cpp
-    logging/filter.h
-    logging/formatter.h
-    logging/log.h
-    logging/log_entry.h
-    logging/text_formatter.cpp
-    logging/text_formatter.h
-    logging/types.h
+    logging.cpp
+    logging.h
     lz4_compression.cpp
     lz4_compression.h
     make_unique_for_overwrite.h

src/common/android/applets/software_keyboard.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,7 +12,7 @@
 #include "common/android/android_common.h"
 #include "common/android/applets/software_keyboard.h"
 #include "common/android/id_cache.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/string_util.h"
 #include "core/core.h"
 

src/common/android/applets/web_browser.cpp

@@ -1,10 +1,10 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "common/android/android_common.h"
 #include "common/android/id_cache.h"
 #include "common/android/applets/web_browser.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 static jclass s_native_library_class = nullptr;
 static jmethodID s_open_external_url = nullptr;

src/common/assert.cpp

@@ -1,11 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
 #include "common/common_funcs.h"
-#include "common/logging/backend.h"
+#include "common/logging.h"
 #include "common/settings.h"
 
 #ifdef _MSC_VER

src/common/assert.h

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 // Sometimes we want to try to continue even after hitting an assert.
 // However touching this file yields a global recompilation as this header is included almost

src/common/fs/file.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -12,7 +12,7 @@
 #ifdef ANDROID
 #include "common/fs/fs_android.h"
 #endif
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 #ifdef _WIN32
 #include <io.h>

src/common/fs/fs.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,7 +10,7 @@
 #include "common/fs/fs_android.h"
 #endif
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 namespace Common::FS {
 

src/common/fs/path_util.cpp

@@ -16,7 +16,7 @@
 #endif
 #include "common/fs/fs_paths.h"
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 #ifdef _WIN32
 #include <shlobj.h> // Used in GetExeDirectory()

src/common/heap_tracker.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -6,7 +6,7 @@
 
 #include <fstream>
 #include "common/heap_tracker.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/assert.h"
 
 namespace Common {

src/common/host_memory.cpp

@@ -54,7 +54,7 @@
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>

src/common/input.h

@@ -12,7 +12,7 @@
 #include <ankerl/unordered_dense.h>
 #include <utility>
 #include <vector>
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/param_package.h"
 #include "common/uuid.h"
 

src/common/log_classes.inc

@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
+
+CLS(Log)
+CLS(Common)
+SUB(Common, Filesystem)
+SUB(Common, Memory)
+CLS(Core)
+SUB(Core, ARM)
+SUB(Core, Timing)
+CLS(Config)
+CLS(Debug)
+SUB(Debug, Emulated)
+SUB(Debug, GPU)
+SUB(Debug, Breakpoint)
+SUB(Debug, GDBStub)
+CLS(Kernel)
+SUB(Kernel, SVC)
+CLS(Service)
+SUB(Service, ACC)
+SUB(Service, Audio)
+SUB(Service, AM)
+SUB(Service, AOC)
+SUB(Service, APM)
+SUB(Service, ARP)
+SUB(Service, BCAT)
+SUB(Service, BPC)
+SUB(Service, BGTC)
+SUB(Service, BTDRV)
+SUB(Service, BTM)
+SUB(Service, Capture)
+SUB(Service, ERPT)
+SUB(Service, ETicket)
+SUB(Service, EUPLD)
+SUB(Service, Fatal)
+SUB(Service, FGM)
+SUB(Service, Friend)
+SUB(Service, FS)
+SUB(Service, GRC)
+SUB(Service, HID)
+SUB(Service, IRS)
+SUB(Service, JIT)
+SUB(Service, LBL)
+SUB(Service, LDN)
+SUB(Service, LDR)
+SUB(Service, LM)
+SUB(Service, Migration)
+SUB(Service, Mii)
+SUB(Service, MM)
+SUB(Service, MNPP)
+SUB(Service, NCM)
+SUB(Service, NFC)
+SUB(Service, NFP)
+SUB(Service, NGC)
+SUB(Service, NIFM)
+SUB(Service, NIM)
+SUB(Service, NOTIF)
+SUB(Service, NPNS)
+SUB(Service, NS)
+SUB(Service, NVDRV)
+SUB(Service, Nvnflinger)
+SUB(Service, OLSC)
+SUB(Service, PCIE)
+SUB(Service, PCTL)
+SUB(Service, PCV)
+SUB(Service, PM)
+SUB(Service, PREPO)
+SUB(Service, PSC)
+SUB(Service, PTM)
+SUB(Service, SET)
+SUB(Service, SM)
+SUB(Service, SPL)
+SUB(Service, SSL)
+SUB(Service, TCAP)
+SUB(Service, Time)
+SUB(Service, USB)
+SUB(Service, VI)
+SUB(Service, WLAN)
+CLS(HW)
+SUB(HW, Memory)
+SUB(HW, LCD)
+SUB(HW, GPU)
+SUB(HW, AES)
+CLS(IPC)
+CLS(Frontend)
+CLS(Render)
+SUB(Render, Software)
+SUB(Render, OpenGL)
+SUB(Render, Vulkan)
+CLS(Shader)
+SUB(Shader, SPIRV)
+SUB(Shader, GLASM)
+SUB(Shader, GLSL)
+CLS(Audio)
+SUB(Audio, DSP)
+SUB(Audio, Sink)
+CLS(Input)
+CLS(Network)
+CLS(Loader)
+CLS(CheatEngine)
+CLS(Crypto)
+CLS(WebService)

src/common/logging.cpp

@@ -0,0 +1,454 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <atomic>
+#include <chrono>
+#include <climits>
+#include <cstdlib>
+#include <regex>
+#include <thread>
+
+#if defined(__ANDROID__)
+#include <android/log.h>
+#endif
+#ifdef _WIN32
+#include <windows.h> // For OutputDebugStringW
+#else
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+#include <boost/algorithm/string/replace.hpp>
+#include <fmt/ranges.h>
+
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/fs_paths.h"
+#include "common/fs/path_util.h"
+#include "common/literals.h"
+#include "common/polyfill_thread.h"
+#include "common/thread.h"
+
+#include "common/logging.h"
+#include "common/settings.h"
+#include "common/string_util.h"
+#include "common/bounded_threadsafe_queue.h"
+
+namespace Common::Log {
+
+namespace {
+
+/// @brief Returns the name of the passed log class as a C-string. Subclasses are separated by periods
+/// instead of underscores as in the enumeration.
+/// @note GetClassName is a macro defined by Windows.h, grrr...
+const char* GetLogClassName(Class log_class) {
+    switch (log_class) {
+#define CLS(x) case Class::x: return #x;
+#define SUB(x, y) case Class::x##_##y: return #x "." #y;
+#include "common/log_classes.inc"
+#undef CLS
+#undef SUB
+    default: return "?";
+    }
+}
+
+/// @brief Returns the name of the passed log level as a C-string.
+const char* GetLevelName(Level log_level) {
+    switch (log_level) {
+#define LVL(x) case Level::x: return #x;
+    LVL(Trace)
+    LVL(Debug)
+    LVL(Info)
+    LVL(Warning)
+    LVL(Error)
+    LVL(Critical)
+#undef LVL
+    default: return "?";
+    }
+}
+
+}
+
+// Some IDEs prefer <file>:<line> instead, so let's just do that :)
+std::string FormatLogMessage(const Entry& entry) noexcept {
+    if (!entry.filename) return "";
+    auto const time_seconds = uint32_t(entry.timestamp.count() / 1000000);
+    auto const time_fractional = uint32_t(entry.timestamp.count() % 1000000);
+    auto const class_name = GetLogClassName(entry.log_class);
+    auto const level_name = GetLevelName(entry.log_level);
+    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}", time_seconds, time_fractional, class_name, level_name, entry.filename, entry.line_num, entry.function, entry.message);
+}
+
+namespace {
+template <typename It>
+Level GetLevelByName(const It begin, const It end) {
+    for (u32 i = 0; i < u32(Level::Count); ++i) {
+        const char* level_name = GetLevelName(Level(i));
+        if (Common::ComparePartialString(begin, end, level_name))
+            return Level(i);
+    }
+    return Level::Count;
+}
+
+template <typename It>
+Class GetClassByName(const It begin, const It end) {
+    for (u32 i = 0; i < u32(Class::Count); ++i) {
+        const char* level_name = GetLogClassName(Class(i));
+        if (Common::ComparePartialString(begin, end, level_name))
+            return Class(i);
+    }
+    return Class::Count;
+}
+
+template <typename Iterator>
+bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
+    auto level_separator = std::find(begin, end, ':');
+    if (level_separator == end) {
+        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}", std::string(begin, end));
+        return false;
+    }
+    const Level level = GetLevelByName(level_separator + 1, end);
+    if (level == Level::Count) {
+        LOG_ERROR(Log, "Unknown log level in filter: {}", std::string(begin, end));
+        return false;
+    }
+    if (Common::ComparePartialString(begin, level_separator, "*")) {
+        instance.class_levels.fill(level);
+        return true;
+    }
+    const Class log_class = GetClassByName(begin, level_separator);
+    if (log_class == Class::Count) {
+        LOG_ERROR(Log, "Unknown log class in filter: {}", std::string(begin, end));
+        return false;
+    }
+    instance.SetClassLevel(log_class, level);
+    return true;
+}
+} // Anonymous namespace
+
+void Filter::ParseFilterString(std::string_view filter_view) {
+    auto clause_begin = filter_view.cbegin();
+    while (clause_begin != filter_view.cend()) {
+        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
+        // If clause isn't empty
+        if (clause_end != clause_begin) {
+            ParseFilterRule(*this, clause_begin, clause_end);
+        }
+        if (clause_end != filter_view.cend()) {
+            // Skip over the whitespace
+            ++clause_end;
+        }
+        clause_begin = clause_end;
+    }
+}
+
+namespace {
+
+/// @brief Trims up to and including the last of ../, ..\, src/, src\ in a string
+/// do not be fooled this isn't generating new strings on .rodata :)
+constexpr const char* TrimSourcePath(std::string_view source) noexcept {
+    const auto rfind = [source](const std::string_view match) {
+        return source.rfind(match) == source.npos ? 0 : (source.rfind(match) + match.size());
+    };
+    auto idx = (std::max)({rfind("src/"), rfind("src\\"), rfind("../"), rfind("..\\")});
+    return source.data() + idx;
+}
+
+/// @brief Interface for logging backends.
+struct Backend {
+    virtual ~Backend() noexcept = default;
+    virtual void Write(const Entry& entry) noexcept = 0;
+    virtual void Flush() noexcept = 0;
+};
+
+/// @brief Formatting specifier (to use with printf) of the equivalent fmt::format() expression
+#define CCB_PRINTF_FMT "[%4d.%06d] %s <%s> %s:%u:%s: %s"
+
+/// @brief Instead of using fmt::format() just use the system's formatting capabilities directly
+struct DirectFormatArgs {
+    const char *class_name;
+    const char *level_name;
+    uint32_t time_seconds;
+    uint32_t time_fractional;
+};
+[[nodiscard]] inline DirectFormatArgs GetDirectFormatArgs(Entry const& entry) noexcept {
+    return {
+        .class_name = GetLogClassName(entry.log_class),
+        .level_name = GetLevelName(entry.log_level),
+        .time_seconds = uint32_t(entry.timestamp.count() / 1000000),
+        .time_fractional = uint32_t(entry.timestamp.count() % 1000000),
+    };
+}
+
+/// @brief Backend that writes to stdout and with color
+struct ColorConsoleBackend final : public Backend {
+#ifdef _WIN32
+    explicit ColorConsoleBackend() noexcept {
+        console_handle = GetStdHandle(STD_ERROR_HANDLE);
+        GetConsoleScreenBufferInfo(console_handle, &original_info);
+    }
+    ~ColorConsoleBackend() noexcept override {
+        SetConsoleTextAttribute(console_handle, original_info.wAttributes);
+    }
+    void Write(const Entry& entry) noexcept override {
+        if (enabled && console_handle != INVALID_HANDLE_VALUE) {
+            WORD color = WORD([&entry]() {
+                switch (entry.log_level) {
+                case Level::Debug: return FOREGROUND_GREEN | FOREGROUND_BLUE; // Cyan
+                case Level::Info: return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // Bright gray
+                case Level::Warning: return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
+                case Level::Error: return FOREGROUND_RED | FOREGROUND_INTENSITY;
+                case Level::Critical: return FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
+                default: break;
+                }
+                return FOREGROUND_INTENSITY; // Grey
+            }());
+            SetConsoleTextAttribute(console_handle, color);
+            auto const df = GetDirectFormatArgs(entry);
+            std::fprintf(stdout, CCB_PRINTF_FMT "\n", df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message.c_str());
+        }
+    }
+    void Flush() noexcept override {}
+    CONSOLE_SCREEN_BUFFER_INFO original_info = {};
+    HANDLE console_handle = INVALID_HANDLE_VALUE;
+    std::atomic_bool enabled = false;
+#else // ^^^ Windows vvv POSIX
+    explicit ColorConsoleBackend() noexcept {}
+    ~ColorConsoleBackend() noexcept override {}
+    void Write(const Entry& entry) noexcept override {
+        if (enabled) {
+#define ESC "\x1b"
+            auto const color_str = [&entry]() -> const char* {
+                switch (entry.log_level) {
+#define CCB_MAKE_COLOR_FMT(X) ESC X CCB_PRINTF_FMT ESC "[0m\n"
+                case Level::Debug: return CCB_MAKE_COLOR_FMT("[0;36m"); // Cyan
+                case Level::Info: return CCB_MAKE_COLOR_FMT("[0;37m"); // Bright gray
+                case Level::Warning: return CCB_MAKE_COLOR_FMT("[1;33m"); // Bright yellow
+                case Level::Error: return CCB_MAKE_COLOR_FMT("[1;31m"); // Bright red
+                case Level::Critical: return CCB_MAKE_COLOR_FMT("[1;35m"); // Bright magenta
+                default: return CCB_MAKE_COLOR_FMT("[1;30m"); // Grey
+#undef CCB_MAKE_COLOR_FMT
+                }
+            }();
+            auto const df = GetDirectFormatArgs(entry);
+            std::fprintf(stdout, color_str, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message.c_str());
+#undef ESC
+        }
+    }
+    void Flush() noexcept override {}
+    std::atomic_bool enabled = false;
+#endif
+};
+
+#ifndef __OPENORBIS__
+/// @brief Backend that writes to a file passed into the constructor
+struct FileBackend final : public Backend {
+    explicit FileBackend(const std::filesystem::path& filename) noexcept {
+        auto old_filename = filename;
+        old_filename += ".old.txt";
+        // Existence checks are done within the functions themselves.
+        // We don't particularly care if these succeed or not.
+        void(FS::RemoveFile(old_filename));
+        void(FS::RenameFile(filename, old_filename));
+        file.emplace(filename, FS::FileAccessMode::Write, FS::FileType::TextFile);
+    }
+    ~FileBackend() noexcept override = default;
+
+    void Write(const Entry& entry) noexcept override {
+        if (!enabled)
+            return;
+
+        auto message = FormatLogMessage(entry).append(1, '\n');
+#ifndef __ANDROID__
+        if (Settings::values.censor_username.GetValue()) {
+            // This must be a static otherwise it would get checked on EVERY
+            // instance of logging an entry...
+            static std::string username = []() -> std::string {
+                // in order of precedence
+                // LOGNAME usually works on UNIX, USERNAME on Windows
+                // Some UNIX systems suck and don't use LOGNAME so we also
+                // need USER :(
+                for (auto const var : { "LOGNAME", "USERNAME", "USER", })
+                    if (auto const s = ::getenv(var); s != nullptr)
+                        return std::string{s};
+                return std::string{};
+            }();
+            if (!username.empty())
+                boost::replace_all(message, username, "user");
+        }
+#endif
+        bytes_written += file->WriteString(message);
+
+        // Option to log each line rather than 4k buffers
+        if (Settings::values.log_flush_line.GetValue())
+            file->Flush();
+
+        using namespace Common::Literals;
+        // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
+        const auto write_limit = Settings::values.extended_logging.GetValue() ? 1_GiB : 100_MiB;
+        const bool write_limit_exceeded = bytes_written > write_limit;
+        if (entry.log_level >= Level::Error || write_limit_exceeded) {
+            // Stop writing after the write limit is exceeded.
+            // Don't close the file so we can print a stacktrace if necessary
+            if (write_limit_exceeded)
+                enabled = false;
+            file->Flush();
+        }
+    }
+
+    void Flush() noexcept override {
+        file->Flush();
+    }
+private:
+    std::optional<FS::IOFile> file;
+    std::size_t bytes_written = 0;
+    bool enabled = true;
+};
+#endif
+
+#ifdef _WIN32
+/// @brief Backend that writes to Visual Studio's output window
+struct DebuggerBackend final : public Backend {
+    explicit DebuggerBackend() noexcept = default;
+    ~DebuggerBackend() noexcept override = default;
+    void Write(const Entry& entry) noexcept override {
+        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
+    }
+    void Flush() noexcept override {}
+};
+#endif
+#ifdef ANDROID
+/// @brief Backend that writes to the Android logcat
+struct LogcatBackend : public Backend {
+    explicit LogcatBackend() noexcept = default;
+    ~LogcatBackend() noexcept override = default;
+    void Write(const Entry& entry) noexcept override {
+        android_LogPriority android_log_priority = [&]() {
+            switch (entry.log_level) {
+            case Level::Debug: return ANDROID_LOG_DEBUG;
+            case Level::Info: return ANDROID_LOG_INFO;
+            case Level::Warning: return ANDROID_LOG_WARN;
+            case Level::Error: return ANDROID_LOG_ERROR;
+            case Level::Critical: return ANDROID_LOG_FATAL;
+            case Level::Count:
+            case Level::Trace: return ANDROID_LOG_VERBOSE;
+            }
+        }();
+        auto const df = GetDirectFormatArgs(entry);
+        __android_log_print(android_log_priority, "YuzuNative", CCB_PRINTF_FMT, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message.c_str());
+    }
+    void Flush() noexcept override {}
+};
+#endif
+
+/// @brief Static state as a singleton.
+struct Impl {
+    // Well, I mean it's the default constructor!
+    explicit Impl() noexcept : filter(Level::Trace) {}
+
+    void StartBackendThread() noexcept {
+        backend_thread = std::jthread([this](std::stop_token stop_token) {
+            Common::SetCurrentThreadName("Logger");
+            Entry entry;
+            const auto write_logs = [this, &entry]() {
+                ForEachBackend([&entry](Backend& backend) {
+                    backend.Write(entry);
+                });
+            };
+            do {
+                message_queue.PopWait(entry, stop_token);
+                write_logs();
+            } while (!stop_token.stop_requested());
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+            // case where a system is repeatedly spamming logs even on close.
+            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+            while (max_logs_to_write-- && message_queue.TryPop(entry))
+                write_logs();
+        });
+    }
+
+    void StopBackendThread() noexcept {
+        backend_thread.request_stop();
+        if (backend_thread.joinable())
+            backend_thread.join();
+        ForEachBackend([](Backend& backend) { backend.Flush(); });
+    }
+
+    void ForEachBackend(auto lambda) noexcept {
+        lambda(static_cast<Backend&>(color_console_backend));
+#ifndef __OPENORBIS__
+        if (file_backend)
+            lambda(static_cast<Backend&>(*file_backend));
+#endif
+#ifdef _WIN32
+        lambda(static_cast<Backend&>(debugger_backend));
+#endif
+#ifdef ANDROID
+        lambda(static_cast<Backend&>(lc_backend));
+#endif
+    }
+
+    Filter filter;
+    ColorConsoleBackend color_console_backend{};
+#ifndef __OPENORBIS__
+    std::optional<FileBackend> file_backend;
+#endif
+#ifdef _WIN32
+    DebuggerBackend debugger_backend{};
+#endif
+#ifdef ANDROID
+    LogcatBackend lc_backend{};
+#endif
+    MPSCQueue<Entry> message_queue{};
+    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
+    std::jthread backend_thread;
+};
+} // namespace
+
+// Constructor shall NOT depend upon Settings() or whatever
+// it's ran at global static ctor() time... so BE CAREFUL MFER!
+static Common::Log::Impl logging_instance{};
+
+void Initialize() {
+    logging_instance.filter.ParseFilterString(Settings::values.log_filter.GetValue());
+#ifndef __OPENORBIS__
+    using namespace Common::FS;
+    const auto& log_dir = GetEdenPath(EdenPath::LogDir);
+    void(CreateDir(log_dir));
+    logging_instance.file_backend.emplace(log_dir / LOG_FILE);
+#endif
+}
+
+void Start() {
+    logging_instance.StartBackendThread();
+}
+
+void Stop() {
+    logging_instance.StopBackendThread();
+}
+
+void SetGlobalFilter(const Filter& filter) {
+    logging_instance.filter = filter;
+}
+
+void SetColorConsoleBackendEnabled(bool enabled) {
+    logging_instance.color_console_backend.enabled = enabled;
+}
+
+void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename, unsigned int line_num, const char* function, fmt::string_view format, const fmt::format_args& args) {
+    if (logging_instance.filter.CheckMessage(log_class, log_level)) {
+        logging_instance.message_queue.EmplaceWait(Entry{
+            .message = fmt::vformat(format, args),
+            .timestamp = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - logging_instance.time_origin),
+            .log_class = log_class,
+            .log_level = log_level,
+            .filename = TrimSourcePath(filename),
+            .function = function,
+            .line_num = line_num,
+        });
+    }
+}
+} // namespace Common::Log

src/common/logging.h

@@ -0,0 +1,164 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <chrono>
+#include <algorithm>
+#include <type_traits>
+#include <fmt/ranges.h>
+#include "common/swap.h"
+
+// adapted from https://github.com/fmtlib/fmt/issues/2704
+// a generic formatter for enum classes
+#if FMT_VERSION >= 80100
+template <typename T>
+struct fmt::formatter<T, std::enable_if_t<std::is_enum_v<T>, char>>
+    : formatter<std::underlying_type_t<T>> {
+    template <typename FormatContext>
+    auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
+        return fmt::formatter<std::underlying_type_t<T>>::format(
+            static_cast<std::underlying_type_t<T>>(value), ctx);
+    }
+};
+#endif
+
+template <typename T, typename U>
+struct fmt::formatter<SwapStructT<T, U>> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    template <typename FormatContext>
+    auto format(const SwapStructT<T, U>& reg, FormatContext& ctx) const {
+        return fmt::format_to(ctx.out(), "{}", T(reg));
+    }
+};
+
+#ifdef _DEBUG
+#define LOG_TRACE(log_class, ...) \
+    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Trace, \
+       __FILE__, __LINE__, __func__, __VA_ARGS__)
+#else
+#define LOG_TRACE(log_class, fmt, ...) (void(0))
+#endif
+
+#define LOG_DEBUG(log_class, ...) \
+    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Debug, \
+       __FILE__, __LINE__, __func__, __VA_ARGS__)
+#define LOG_INFO(log_class, ...) \
+    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Info, \
+       __FILE__, __LINE__, __func__, __VA_ARGS__)
+#define LOG_WARNING(log_class, ...) \
+    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Warning, \
+       __FILE__, __LINE__, __func__, __VA_ARGS__)
+#define LOG_ERROR(log_class, ...) \
+    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Error, \
+       __FILE__, __LINE__, __func__, __VA_ARGS__)
+#define LOG_CRITICAL(log_class, ...) \
+    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Critical, \
+       __FILE__, __LINE__, __func__, __VA_ARGS__)
+
+namespace Common::Log {
+
+/// Specifies the severity or level of detail of the log message.
+enum class Level : u8 {
+    Trace, ///< Extremely detailed and repetitive debugging information that is likely to pollute logs.
+    Debug, ///< Less detailed debugging information.
+    Info, ///< Status information from important points during execution.
+    Warning, ///< Minor or potential problems found during execution of a task.
+    Error, ///< Major problems found during execution of a task that prevent it from being completed.
+    Critical, ///< Major problems during execution that threaten the stability of the entire application.
+    Count ///< Total number of logging levels
+};
+
+/// Specifies the sub-system that generated the log message.
+enum class Class : u8 {
+#define SUB(A, B) A##_##B,
+#define CLS(A) A,
+#include "log_classes.inc"
+#undef SUB
+#undef CLS
+    Count,
+};
+
+/// Logs a message to the global logger, using fmt
+void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename, unsigned int line_num, const char* function, fmt::string_view format, const fmt::format_args& args);
+
+template <typename... Args>
+void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num, const char* function, fmt::format_string<Args...> format, const Args&... args) {
+    FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format, fmt::make_format_args(args...));
+}
+
+/// Implements a log message filter which allows different log classes to have different minimum
+/// severity levels. The filter can be changed at runtime and can be parsed from a string to allow
+/// editing via the interface or loading from a configuration file.
+struct Filter {
+    /// Initializes the filter with all classes having `default_level` as the minimum level.
+    explicit Filter(Level level = Level::Info) {
+        class_levels.fill(level);
+    }
+    /// Sets the minimum level of `log_class` (and not of its subclasses) to `level`.
+    void SetClassLevel(Class log_class, Level level) {
+        class_levels[std::size_t(log_class)] = level;
+    }
+    /// Parses a filter string and applies it to this filter.
+    /// A filter string consists of a space-separated list of filter rules, each of the format
+    /// `<class>:<level>`. `<class>` is a log class name, with subclasses separated using periods.
+    /// `*` is allowed as a class name and will reset all filters to the specified level. `<level>`
+    /// a severity level name which will be set as the minimum logging level of the matched classes.
+    /// Rules are applied left to right, with each rule overriding previous ones in the sequence.
+    /// A few examples of filter rules:
+    ///  - `*:Info` -- Resets the level of all classes to Info.
+    ///  - `Service:Info` -- Sets the level of Service to Info.
+    ///  - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace.
+    void ParseFilterString(std::string_view filter_view);
+    /// Matches class/level combination against the filter, returning true if it passed.
+    [[nodiscard]] bool CheckMessage(Class log_class, Level level) const {
+        return u8(level) >= u8(class_levels[std::size_t(log_class)]);
+    }
+    /// Returns true if any logging classes are set to debug
+    [[nodiscard]] bool IsDebug() const {
+        return std::any_of(class_levels.begin(), class_levels.end(), [](const Level& l) {
+            return u8(l) <= u8(Level::Debug);
+        });
+    }
+    std::array<Level, std::size_t(Class::Count)> class_levels;
+};
+
+/// Initializes the logging system. This should be the first thing called in main.
+void Initialize();
+
+void Start();
+
+/// Explicitly stops the logger thread and flushes the buffers
+void Stop();
+
+/// The global filter will prevent any messages from even being processed if they are filtered.
+void SetGlobalFilter(const Filter& filter);
+void SetColorConsoleBackendEnabled(bool enabled);
+
+/// @brief A log entry. Log entries are store in a structured format to permit more varied output
+/// formatting on different frontends, as well as facilitating filtering and aggregation.
+struct Entry {
+    std::string message;
+    std::chrono::microseconds timestamp;
+    Class log_class{};
+    Level log_level{};
+    const char* filename = nullptr;
+    const char* function = nullptr;
+    unsigned int line_num = 0;
+};
+
+/// Formats a log entry into the provided text buffer.
+std::string FormatLogMessage(const Entry& entry) noexcept;
+
+/// Prints the same message as `PrintMessage`, but colored according to the severity level.
+void PrintColoredMessage(const Entry& entry) noexcept;
+
+/// Formats and prints a log entry to the android logcat.
+void PrintMessageToLogcat(const Entry& entry) noexcept;
+
+} // namespace Common::Log

src/common/logging/backend.cpp

@@ -1,369 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <atomic>
-#include <chrono>
-#include <climits>
-#include <cstdlib>
-#include <regex>
-#include <thread>
-
-#include <boost/algorithm/string/replace.hpp>
-#include <fmt/ranges.h>
-
-#ifdef _WIN32
-#include <windows.h> // For OutputDebugStringW
-#endif
-
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/fs/fs_paths.h"
-#include "common/fs/path_util.h"
-#include "common/literals.h"
-#include "common/polyfill_thread.h"
-#include "common/thread.h"
-
-#include "common/logging/backend.h"
-#include "common/logging/log.h"
-#include "common/logging/log_entry.h"
-#include "common/logging/text_formatter.h"
-#include "common/settings.h"
-#ifdef _WIN32
-#include "common/string_util.h"
-#endif
-#include "common/bounded_threadsafe_queue.h"
-
-namespace Common::Log {
-
-namespace {
-
-/// @brief Trims up to and including the last of ../, ..\, src/, src\ in a string
-/// do not be fooled this isn't generating new strings on .rodata :)
-constexpr const char* TrimSourcePath(std::string_view source) noexcept {
-    const auto rfind = [source](const std::string_view match) {
-        return source.rfind(match) == source.npos ? 0 : (source.rfind(match) + match.size());
-    };
-    auto idx = (std::max)({rfind("src/"), rfind("src\\"), rfind("../"), rfind("..\\")});
-    return source.data() + idx;
-}
-
-/// @brief Interface for logging backends.
-struct Backend {
-    virtual ~Backend() noexcept = default;
-    virtual void Write(const Entry& entry) noexcept = 0;
-    virtual void EnableForStacktrace() noexcept= 0;
-    virtual void Flush() noexcept = 0;
-};
-
-/// @brief Backend that writes to stderr and with color
-struct ColorConsoleBackend final : public Backend {
-    explicit ColorConsoleBackend() noexcept = default;
-    ~ColorConsoleBackend() noexcept override = default;
-
-    void Write(const Entry& entry) noexcept override {
-        if (enabled.load(std::memory_order_relaxed))
-            PrintColoredMessage(entry);
-    }
-
-    void Flush() noexcept override {
-        // stderr shouldn't be buffered
-    }
-
-    void EnableForStacktrace() noexcept override {
-        enabled = true;
-    }
-
-    void SetEnabled(bool enabled_) noexcept {
-        enabled = enabled_;
-    }
-
-private:
-    std::atomic_bool enabled{false};
-};
-
-#ifndef __OPENORBIS__
-/// @brief Backend that writes to a file passed into the constructor
-struct FileBackend final : public Backend {
-    explicit FileBackend(const std::filesystem::path& filename) noexcept {
-        auto old_filename = filename;
-        old_filename += ".old.txt";
-
-        // Existence checks are done within the functions themselves.
-        // We don't particularly care if these succeed or not.
-        void(FS::RemoveFile(old_filename));
-        void(FS::RenameFile(filename, old_filename));
-
-        file = std::make_unique<FS::IOFile>(filename, FS::FileAccessMode::Write, FS::FileType::TextFile);
-    }
-
-    ~FileBackend() noexcept override = default;
-
-    void Write(const Entry& entry) noexcept override {
-        if (!enabled)
-            return;
-
-        auto message = FormatLogMessage(entry).append(1, '\n');
-#ifndef __ANDROID__
-        if (Settings::values.censor_username.GetValue()) {
-            // This must be a static otherwise it would get checked on EVERY
-            // instance of logging an entry...
-            static std::string username = []() -> std::string {
-                // in order of precedence
-                // LOGNAME usually works on UNIX, USERNAME on Windows
-                // Some UNIX systems suck and don't use LOGNAME so we also
-                // need USER :(
-                for (auto const var : {
-                         "LOGNAME",
-                         "USERNAME",
-                         "USER",
-                     }) {
-                    if (auto const s = getenv(var); s != nullptr)
-                        return std::string{s};
-                }
-
-                return std::string{};
-            }();
-            if (!username.empty())
-                boost::replace_all(message, username, "user");
-        }
-#endif
-        bytes_written += file->WriteString(message);
-
-        // Option to log each line rather than 4k buffers
-        if (Settings::values.log_flush_line.GetValue())
-            file->Flush();
-
-        using namespace Common::Literals;
-        // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
-        const auto write_limit = Settings::values.extended_logging.GetValue() ? 1_GiB : 100_MiB;
-        const bool write_limit_exceeded = bytes_written > write_limit;
-        if (entry.log_level >= Level::Error || write_limit_exceeded) {
-            // Stop writing after the write limit is exceeded.
-            // Don't close the file so we can print a stacktrace if necessary
-            if (write_limit_exceeded)
-                enabled = false;
-            file->Flush();
-        }
-    }
-
-    void Flush() noexcept override {
-        file->Flush();
-    }
-
-    void EnableForStacktrace() noexcept override {
-        enabled = true;
-        bytes_written = 0;
-    }
-
-private:
-    std::unique_ptr<FS::IOFile> file;
-    std::size_t bytes_written = 0;
-    bool enabled = true;
-};
-#endif
-
-#ifdef _WIN32
-/// @brief Backend that writes to Visual Studio's output window
-struct DebuggerBackend final : public Backend {
-    explicit DebuggerBackend() noexcept = default;
-    ~DebuggerBackend() noexcept override = default;
-    void Write(const Entry& entry) noexcept override {
-        ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
-    }
-    void Flush() noexcept override {}
-    void EnableForStacktrace() noexcept override {}
-};
-#endif
-#ifdef ANDROID
-/// @brief Backend that writes to the Android logcat
-struct LogcatBackend : public Backend {
-    explicit LogcatBackend() noexcept = default;
-    ~LogcatBackend() noexcept override = default;
-    void Write(const Entry& entry) noexcept override {
-        PrintMessageToLogcat(entry);
-    }
-    void Flush() noexcept override {}
-    void EnableForStacktrace() noexcept override {}
-};
-#endif
-
-bool initialization_in_progress_suppress_logging = true;
-
-/// @brief Static state as a singleton.
-class Impl {
-public:
-    static Impl& Instance() noexcept {
-        if (!instance)
-            std::abort();
-        return *instance;
-    }
-
-    static void Initialize() noexcept {
-        if (instance) {
-            LOG_WARNING(Log, "Reinitializing logging backend");
-            return;
-        }
-        using namespace Common::FS;
-        const auto& log_dir = GetEdenPath(EdenPath::LogDir);
-        void(CreateDir(log_dir));
-        Filter filter;
-        filter.ParseFilterString(Settings::values.log_filter.GetValue());
-        instance = std::unique_ptr<Impl, decltype(&Deleter)>(new Impl(log_dir / LOG_FILE, filter), Deleter);
-        initialization_in_progress_suppress_logging = false;
-    }
-
-    static void Start() noexcept {
-        instance->StartBackendThread();
-    }
-
-    static void Stop() noexcept {
-        instance->StopBackendThread();
-    }
-
-    Impl(const Impl&) noexcept = delete;
-    Impl& operator=(const Impl&) noexcept = delete;
-
-    Impl(Impl&&) noexcept = delete;
-    Impl& operator=(Impl&&) noexcept = delete;
-
-    void SetGlobalFilter(const Filter& f) noexcept {
-        filter = f;
-    }
-
-    void SetColorConsoleBackendEnabled(bool enabled) noexcept {
-        color_console_backend.SetEnabled(enabled);
-    }
-
-    bool CanPushEntry(Class log_class, Level log_level) const noexcept {
-        return filter.CheckMessage(log_class, log_level);
-    }
-
-    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num, const char* function, std::string&& message) noexcept {
-        message_queue.EmplaceWait(CreateEntry(log_class, log_level, TrimSourcePath(filename), line_num, function, std::move(message)));
-    }
-
-private:
-    Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_) noexcept :
-        filter{filter_}
-#ifndef __OPENORBIS__
-        , file_backend{file_backend_filename}
-#endif
-    {}
-
-    ~Impl() noexcept = default;
-
-    void StartBackendThread() noexcept {
-        backend_thread = std::jthread([this](std::stop_token stop_token) {
-            Common::SetCurrentThreadName("Logger");
-            Entry entry;
-            const auto write_logs = [this, &entry]() {
-                ForEachBackend([&entry](Backend& backend) {
-                    backend.Write(entry);
-                });
-            };
-            do {
-                message_queue.PopWait(entry, stop_token);
-                write_logs();
-            } while (!stop_token.stop_requested());
-            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-            // case where a system is repeatedly spamming logs even on close.
-            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.TryPop(entry))
-                write_logs();
-        });
-    }
-
-    void StopBackendThread() noexcept {
-        backend_thread.request_stop();
-        if (backend_thread.joinable())
-            backend_thread.join();
-        ForEachBackend([](Backend& backend) { backend.Flush(); });
-    }
-
-    Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr, const char* function, std::string&& message) const noexcept {
-        using std::chrono::duration_cast;
-        using std::chrono::microseconds;
-        using std::chrono::steady_clock;
-        return {
-            .timestamp = duration_cast<microseconds>(steady_clock::now() - time_origin),
-            .log_class = log_class,
-            .log_level = log_level,
-            .filename = filename,
-            .line_num = line_nr,
-            .function = function,
-            .message = std::move(message),
-        };
-    }
-
-    void ForEachBackend(auto lambda) noexcept {
-        lambda(static_cast<Backend&>(color_console_backend));
-#ifndef __OPENORBIS__
-        lambda(static_cast<Backend&>(file_backend));
-#endif
-#ifdef _WIN32
-        lambda(static_cast<Backend&>(debugger_backend));
-#endif
-#ifdef ANDROID
-        lambda(static_cast<Backend&>(lc_backend));
-#endif
-    }
-
-    static void Deleter(Impl* ptr) noexcept {
-        delete ptr;
-    }
-
-    static inline std::unique_ptr<Impl, decltype(&Deleter)> instance{nullptr, Deleter};
-
-    Filter filter;
-    ColorConsoleBackend color_console_backend{};
-#ifndef __OPENORBIS__
-    FileBackend file_backend;
-#endif
-#ifdef _WIN32
-    DebuggerBackend debugger_backend{};
-#endif
-#ifdef ANDROID
-    LogcatBackend lc_backend{};
-#endif
-
-    MPSCQueue<Entry> message_queue{};
-    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
-    std::jthread backend_thread;
-};
-} // namespace
-
-void Initialize() {
-    Impl::Initialize();
-}
-
-void Start() {
-    Impl::Start();
-}
-
-void Stop() {
-    Impl::Stop();
-}
-
-void DisableLoggingInTests() {
-    initialization_in_progress_suppress_logging = true;
-}
-
-void SetGlobalFilter(const Filter& filter) {
-    Impl::Instance().SetGlobalFilter(filter);
-}
-
-void SetColorConsoleBackendEnabled(bool enabled) {
-    Impl::Instance().SetColorConsoleBackendEnabled(enabled);
-}
-
-void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename, unsigned int line_num, const char* function, fmt::string_view format, const fmt::format_args& args) {
-    if (!initialization_in_progress_suppress_logging) {
-        auto& instance = Impl::Instance();
-        if (instance.CanPushEntry(log_class, log_level))
-            instance.PushEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
-    }
-}
-} // namespace Common::Log

src/common/logging/backend.h

@@ -1,28 +0,0 @@
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/logging/filter.h"
-
-namespace Common::Log {
-
-class Filter;
-
-/// Initializes the logging system. This should be the first thing called in main.
-void Initialize();
-
-void Start();
-
-/// Explicitly stops the logger thread and flushes the buffers
-void Stop();
-
-void DisableLoggingInTests();
-
-/**
- * The global filter will prevent any messages from even being processed if they are filtered.
- */
-void SetGlobalFilter(const Filter& filter);
-
-void SetColorConsoleBackendEnabled(bool enabled);
-} // namespace Common::Log

src/common/logging/filter.cpp

@@ -1,242 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <algorithm>
-#include "common/logging/filter.h"
-#include "common/string_util.h"
-
-namespace Common::Log {
-namespace {
-template <typename It>
-Level GetLevelByName(const It begin, const It end) {
-    for (u32 i = 0; i < u32(Level::Count); ++i) {
-        const char* level_name = GetLevelName(Level(i));
-        if (Common::ComparePartialString(begin, end, level_name))
-            return Level(i);
-    }
-    return Level::Count;
-}
-
-template <typename It>
-Class GetClassByName(const It begin, const It end) {
-    for (u32 i = 0; i < u32(Class::Count); ++i) {
-        const char* level_name = GetLogClassName(Class(i));
-        if (Common::ComparePartialString(begin, end, level_name))
-            return Class(i);
-    }
-    return Class::Count;
-}
-
-template <typename Iterator>
-bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
-    auto level_separator = std::find(begin, end, ':');
-    if (level_separator == end) {
-        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}",
-                  std::string(begin, end));
-        return false;
-    }
-
-    const Level level = GetLevelByName(level_separator + 1, end);
-    if (level == Level::Count) {
-        LOG_ERROR(Log, "Unknown log level in filter: {}", std::string(begin, end));
-        return false;
-    }
-
-    if (Common::ComparePartialString(begin, level_separator, "*")) {
-        instance.ResetAll(level);
-        return true;
-    }
-
-    const Class log_class = GetClassByName(begin, level_separator);
-    if (log_class == Class::Count) {
-        LOG_ERROR(Log, "Unknown log class in filter: {}", std::string(begin, end));
-        return false;
-    }
-
-    instance.SetClassLevel(log_class, level);
-    return true;
-}
-} // Anonymous namespace
-
-/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
-#define ALL_LOG_CLASSES()                                                                          \
-    CLS(Log)                                                                                       \
-    CLS(Common)                                                                                    \
-    SUB(Common, Filesystem)                                                                        \
-    SUB(Common, Memory)                                                                            \
-    CLS(Core)                                                                                      \
-    SUB(Core, ARM)                                                                                 \
-    SUB(Core, Timing)                                                                              \
-    CLS(Config)                                                                                    \
-    CLS(Debug)                                                                                     \
-    SUB(Debug, Emulated)                                                                           \
-    SUB(Debug, GPU)                                                                                \
-    SUB(Debug, Breakpoint)                                                                         \
-    SUB(Debug, GDBStub)                                                                            \
-    CLS(Kernel)                                                                                    \
-    SUB(Kernel, SVC)                                                                               \
-    CLS(Service)                                                                                   \
-    SUB(Service, ACC)                                                                              \
-    SUB(Service, Audio)                                                                            \
-    SUB(Service, AM)                                                                               \
-    SUB(Service, AOC)                                                                              \
-    SUB(Service, APM)                                                                              \
-    SUB(Service, ARP)                                                                              \
-    SUB(Service, BCAT)                                                                             \
-    SUB(Service, BPC)                                                                              \
-    SUB(Service, BGTC)                                                                             \
-    SUB(Service, BTDRV)                                                                            \
-    SUB(Service, BTM)                                                                              \
-    SUB(Service, Capture)                                                                          \
-    SUB(Service, ERPT)                                                                             \
-    SUB(Service, ETicket)                                                                          \
-    SUB(Service, EUPLD)                                                                            \
-    SUB(Service, Fatal)                                                                            \
-    SUB(Service, FGM)                                                                              \
-    SUB(Service, Friend)                                                                           \
-    SUB(Service, FS)                                                                               \
-    SUB(Service, GRC)                                                                              \
-    SUB(Service, HID)                                                                              \
-    SUB(Service, IRS)                                                                              \
-    SUB(Service, JIT)                                                                              \
-    SUB(Service, LBL)                                                                              \
-    SUB(Service, LDN)                                                                              \
-    SUB(Service, LDR)                                                                              \
-    SUB(Service, LM)                                                                               \
-    SUB(Service, Migration)                                                                        \
-    SUB(Service, Mii)                                                                              \
-    SUB(Service, MM)                                                                               \
-    SUB(Service, MNPP)                                                                             \
-    SUB(Service, NCM)                                                                              \
-    SUB(Service, NFC)                                                                              \
-    SUB(Service, NFP)                                                                              \
-    SUB(Service, NGC)                                                                              \
-    SUB(Service, NIFM)                                                                             \
-    SUB(Service, NIM)                                                                              \
-    SUB(Service, NOTIF)                                                                            \
-    SUB(Service, NPNS)                                                                             \
-    SUB(Service, NS)                                                                               \
-    SUB(Service, NVDRV)                                                                            \
-    SUB(Service, Nvnflinger)                                                                       \
-    SUB(Service, OLSC)                                                                             \
-    SUB(Service, PCIE)                                                                             \
-    SUB(Service, PCTL)                                                                             \
-    SUB(Service, PCV)                                                                              \
-    SUB(Service, PM)                                                                               \
-    SUB(Service, PREPO)                                                                            \
-    SUB(Service, PSC)                                                                              \
-    SUB(Service, PTM)                                                                              \
-    SUB(Service, SET)                                                                              \
-    SUB(Service, SM)                                                                               \
-    SUB(Service, SPL)                                                                              \
-    SUB(Service, SSL)                                                                              \
-    SUB(Service, TCAP)                                                                             \
-    SUB(Service, Time)                                                                             \
-    SUB(Service, USB)                                                                              \
-    SUB(Service, VI)                                                                               \
-    SUB(Service, WLAN)                                                                             \
-    CLS(HW)                                                                                        \
-    SUB(HW, Memory)                                                                                \
-    SUB(HW, LCD)                                                                                   \
-    SUB(HW, GPU)                                                                                   \
-    SUB(HW, AES)                                                                                   \
-    CLS(IPC)                                                                                       \
-    CLS(Frontend)                                                                                  \
-    CLS(Render)                                                                                    \
-    SUB(Render, Software)                                                                          \
-    SUB(Render, OpenGL)                                                                            \
-    SUB(Render, Vulkan)                                                                            \
-    CLS(Shader)                                                                                    \
-    SUB(Shader, SPIRV)                                                                             \
-    SUB(Shader, GLASM)                                                                             \
-    SUB(Shader, GLSL)                                                                              \
-    CLS(Audio)                                                                                     \
-    SUB(Audio, DSP)                                                                                \
-    SUB(Audio, Sink)                                                                               \
-    CLS(Input)                                                                                     \
-    CLS(Network)                                                                                   \
-    CLS(Loader)                                                                                    \
-    CLS(CheatEngine)                                                                               \
-    CLS(Crypto)                                                                                    \
-    CLS(WebService)
-
-// GetClassName is a macro defined by Windows.h, grrr...
-const char* GetLogClassName(Class log_class) {
-    switch (log_class) {
-#define CLS(x)                                                                                     \
-    case Class::x:                                                                                 \
-        return #x;
-#define SUB(x, y)                                                                                  \
-    case Class::x##_##y:                                                                           \
-        return #x "." #y;
-        ALL_LOG_CLASSES()
-#undef CLS
-#undef SUB
-    case Class::Count:
-        break;
-    }
-    return "Invalid";
-}
-
-const char* GetLevelName(Level log_level) {
-#define LVL(x)                                                                                     \
-    case Level::x:                                                                                 \
-        return #x
-    switch (log_level) {
-        LVL(Trace);
-        LVL(Debug);
-        LVL(Info);
-        LVL(Warning);
-        LVL(Error);
-        LVL(Critical);
-    case Level::Count:
-        break;
-    }
-#undef LVL
-    return "Invalid";
-}
-
-Filter::Filter(Level default_level) {
-    ResetAll(default_level);
-}
-
-void Filter::ResetAll(Level level) {
-    class_levels.fill(level);
-}
-
-void Filter::SetClassLevel(Class log_class, Level level) {
-    class_levels[static_cast<std::size_t>(log_class)] = level;
-}
-
-void Filter::ParseFilterString(std::string_view filter_view) {
-    auto clause_begin = filter_view.cbegin();
-    while (clause_begin != filter_view.cend()) {
-        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
-
-        // If clause isn't empty
-        if (clause_end != clause_begin) {
-            ParseFilterRule(*this, clause_begin, clause_end);
-        }
-
-        if (clause_end != filter_view.cend()) {
-            // Skip over the whitespace
-            ++clause_end;
-        }
-        clause_begin = clause_end;
-    }
-}
-
-bool Filter::CheckMessage(Class log_class, Level level) const {
-    return u8(level) >= u8(class_levels[std::size_t(log_class)]);
-}
-
-bool Filter::IsDebug() const {
-    return std::any_of(class_levels.begin(), class_levels.end(), [](const Level& l) {
-        return u8(l) <= u8(Level::Debug);
-    });
-}
-
-} // namespace Common::Log

src/common/logging/filter.h

@@ -1,64 +0,0 @@
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <array>
-#include <chrono>
-#include <cstddef>
-#include "common/logging/log.h"
-
-namespace Common::Log {
-
-/**
- * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
- * instead of underscores as in the enumeration.
- */
-const char* GetLogClassName(Class log_class);
-
-/**
- * Returns the name of the passed log level as a C-string.
- */
-const char* GetLevelName(Level log_level);
-
-/**
- * Implements a log message filter which allows different log classes to have different minimum
- * severity levels. The filter can be changed at runtime and can be parsed from a string to allow
- * editing via the interface or loading from a configuration file.
- */
-class Filter {
-public:
-    /// Initializes the filter with all classes having `default_level` as the minimum level.
-    explicit Filter(Level default_level = Level::Info);
-
-    /// Resets the filter so that all classes have `level` as the minimum displayed level.
-    void ResetAll(Level level);
-    /// Sets the minimum level of `log_class` (and not of its subclasses) to `level`.
-    void SetClassLevel(Class log_class, Level level);
-
-    /**
-     * Parses a filter string and applies it to this filter.
-     *
-     * A filter string consists of a space-separated list of filter rules, each of the format
-     * `<class>:<level>`. `<class>` is a log class name, with subclasses separated using periods.
-     * `*` is allowed as a class name and will reset all filters to the specified level. `<level>`
-     * a severity level name which will be set as the minimum logging level of the matched classes.
-     * Rules are applied left to right, with each rule overriding previous ones in the sequence.
-     *
-     * A few examples of filter rules:
-     *  - `*:Info` -- Resets the level of all classes to Info.
-     *  - `Service:Info` -- Sets the level of Service to Info.
-     *  - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace.
-     */
-    void ParseFilterString(std::string_view filter_view);
-
-    /// Matches class/level combination against the filter, returning true if it passed.
-    bool CheckMessage(Class log_class, Level level) const;
-
-    /// Returns true if any logging classes are set to debug
-    bool IsDebug() const;
-
-private:
-    std::array<Level, static_cast<std::size_t>(Class::Count)> class_levels;
-};
-} // namespace Common::Log

src/common/logging/formatter.h

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <type_traits>
-#include <fmt/ranges.h>
-#include "common/swap.h"
-
-// adapted from https://github.com/fmtlib/fmt/issues/2704
-// a generic formatter for enum classes
-#if FMT_VERSION >= 80100
-template <typename T>
-struct fmt::formatter<T, std::enable_if_t<std::is_enum_v<T>, char>>
-    : formatter<std::underlying_type_t<T>> {
-    template <typename FormatContext>
-    auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
-        return fmt::formatter<std::underlying_type_t<T>>::format(
-            static_cast<std::underlying_type_t<T>>(value), ctx);
-    }
-};
-#endif
-
-template <typename T, typename U>
-struct fmt::formatter<SwapStructT<T, U>> {
-    constexpr auto parse(format_parse_context& ctx) {
-        return ctx.begin();
-    }
-    template <typename FormatContext>
-    auto format(const SwapStructT<T, U>& reg, FormatContext& ctx) const {
-        return fmt::format_to(ctx.out(), "{}", T(reg));
-    }
-};

src/common/logging/log.h

@@ -1,61 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <algorithm>
-#include <string_view>
-
-#include <fmt/ranges.h>
-
-#include "common/logging/formatter.h"
-#include "common/logging/types.h"
-
-namespace Common::Log {
-
-/// Logs a message to the global logger, using fmt
-void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
-                       const fmt::format_args& args);
-
-template <typename... Args>
-void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, fmt::format_string<Args...> format, const Args&... args) {
-    FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
-                      fmt::make_format_args(args...));
-}
-
-} // namespace Common::Log
-
-#ifdef _DEBUG
-#define LOG_TRACE(log_class, ...)                                                                  \
-    Common::Log::FmtLogMessage(Common::Log::Class::log_class, Common::Log::Level::Trace,           \
-                               __FILE__, __LINE__, __func__,          \
-                               __VA_ARGS__)
-#else
-#define LOG_TRACE(log_class, fmt, ...) (void(0))
-#endif
-
-#define LOG_DEBUG(log_class, ...)                                                                  \
-    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Debug,           \
-                               __FILE__, __LINE__, __func__,          \
-                               __VA_ARGS__)
-#define LOG_INFO(log_class, ...)                                                                   \
-    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Info,            \
-                               __FILE__, __LINE__, __func__,          \
-                               __VA_ARGS__)
-#define LOG_WARNING(log_class, ...)                                                                \
-    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Warning,         \
-                               __FILE__, __LINE__, __func__,          \
-                               __VA_ARGS__)
-#define LOG_ERROR(log_class, ...)                                                                  \
-    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Error,           \
-                               __FILE__, __LINE__, __func__,          \
-                               __VA_ARGS__)
-#define LOG_CRITICAL(log_class, ...)                                                               \
-    ::Common::Log::FmtLogMessage(::Common::Log::Class::log_class, ::Common::Log::Level::Critical,        \
-                               __FILE__, __LINE__, __func__,          \
-                               __VA_ARGS__)

src/common/logging/log_entry.h

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <chrono>
-
-#include "common/logging/types.h"
-
-namespace Common::Log {
-
-/// @brief A log entry. Log entries are store in a structured format to permit more varied output
-/// formatting on different frontends, as well as facilitating filtering and aggregation.
-struct Entry {
-    std::chrono::microseconds timestamp;
-    Class log_class{};
-    Level log_level{};
-    const char* filename = nullptr;
-    unsigned int line_num = 0;
-    const char* function = nullptr;
-    std::string message;
-};
-
-} // namespace Common::Log

src/common/logging/text_formatter.cpp

@@ -1,110 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <array>
-#include <cstdio>
-#include <cstdint>
-#include <string>
-
-#ifdef _WIN32
-#include <windows.h>
-#elif defined(__ANDROID__)
-#include <android/log.h>
-#endif
-
-#include "common/assert.h"
-#include "common/logging/filter.h"
-#include "common/logging/log.h"
-#include "common/logging/log_entry.h"
-#include "common/logging/text_formatter.h"
-
-namespace Common::Log {
-
-// Some IDEs prefer <file>:<line> instead, so let's just do that :)
-std::string FormatLogMessage(const Entry& entry) noexcept {
-    if (!entry.filename) return "";
-
-    auto const time_seconds = uint32_t(entry.timestamp.count() / 1000000);
-    auto const time_fractional = uint32_t(entry.timestamp.count() % 1000000);
-    auto const class_name = GetLogClassName(entry.log_class);
-    auto const level_name = GetLevelName(entry.log_level);
-    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}", time_seconds, time_fractional,
-                       class_name, level_name, entry.filename, entry.line_num, entry.function,
-                       entry.message);
-}
-
-/// @brief Formats and prints a log entry to stderr.
-static void PrintMessage(const Entry& entry) noexcept {
-#ifdef _WIN32
-    auto const str = FormatLogMessage(entry).append(1, '\n');
-    fwrite(str.c_str(), 1, str.size(), stderr);
-#else
-#define ESC "\x1b"
-    auto const color_str = [&entry]() -> const char* {
-        switch (entry.log_level) {
-        case Level::Debug: return ESC "[0;36m"; // Cyan
-        case Level::Info: return ESC "[0;37m"; // Bright gray
-        case Level::Warning: return ESC "[1;33m"; // Bright yellow
-        case Level::Error: return ESC "[1;31m"; // Bright red
-        case Level::Critical: return ESC "[1;35m"; // Bright magenta
-        default: return ESC "[1;30m"; // Grey
-        }
-    }();
-    auto const time_seconds = uint32_t(entry.timestamp.count() / 1000000);
-    auto const time_fractional = uint32_t(entry.timestamp.count() % 1000000);
-    auto const class_name = GetLogClassName(entry.log_class);
-    auto const level_name = GetLevelName(entry.log_level);
-    fprintf(stderr, "%s[%4d.%06d] %s <%s> %s:%u:%s: %s" ESC "[0m\n", color_str,
-        time_seconds, time_fractional, class_name, level_name, entry.filename,
-        entry.line_num, entry.function, entry.message.c_str());
-#undef ESC
-#endif
-}
-
-void PrintColoredMessage(const Entry& entry) noexcept {
-#ifdef _WIN32
-    HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
-    if (console_handle == INVALID_HANDLE_VALUE)
-        return;
-    CONSOLE_SCREEN_BUFFER_INFO original_info = {};
-    GetConsoleScreenBufferInfo(console_handle, &original_info);
-    WORD color = WORD([&entry]() {
-        switch (entry.log_level) {
-        case Level::Debug: return FOREGROUND_GREEN | FOREGROUND_BLUE; // Cyan
-        case Level::Info: return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // Bright gray
-        case Level::Warning: return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
-        case Level::Error: return FOREGROUND_RED | FOREGROUND_INTENSITY;
-        case Level::Critical: return FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
-        default: break;
-        }
-        return FOREGROUND_INTENSITY; // Grey
-    }());
-    SetConsoleTextAttribute(console_handle, color);
-#endif
-    PrintMessage(entry);
-#ifdef _WIN32
-    SetConsoleTextAttribute(console_handle, original_info.wAttributes);
-#endif
-}
-
-void PrintMessageToLogcat(const Entry& entry) noexcept {
-#ifdef ANDROID
-    android_LogPriority android_log_priority = [&]() {
-        switch (entry.log_level) {
-        case Level::Debug: return ANDROID_LOG_DEBUG;
-        case Level::Info: return ANDROID_LOG_INFO;
-        case Level::Warning: return ANDROID_LOG_WARN;
-        case Level::Error: return ANDROID_LOG_ERROR;
-        case Level::Critical: return ANDROID_LOG_FATAL;
-        case Level::Count:
-        case Level::Trace: return ANDROID_LOG_VERBOSE;
-        }
-    }();
-    auto const str = FormatLogMessage(entry);
-    __android_log_print(android_log_priority, "YuzuNative", "%s", str.c_str());
-#endif
-}
-} // namespace Common::Log

src/common/logging/text_formatter.h

@@ -1,21 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <string>
-
-namespace Common::Log {
-
-struct Entry;
-
-/// Formats a log entry into the provided text buffer.
-std::string FormatLogMessage(const Entry& entry) noexcept;
-/// Prints the same message as `PrintMessage`, but colored according to the severity level.
-void PrintColoredMessage(const Entry& entry) noexcept;
-/// Formats and prints a log entry to the android logcat.
-void PrintMessageToLogcat(const Entry& entry) noexcept;
-} // namespace Common::Log

src/common/logging/types.h

@@ -1,135 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Common::Log {
-
-/// Specifies the severity or level of detail of the log message.
-enum class Level : u8 {
-    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
-              ///< pollute logs.
-    Debug,    ///< Less detailed debugging information.
-    Info,     ///< Status information from important points during execution.
-    Warning,  ///< Minor or potential problems found during execution of a task.
-    Error,    ///< Major problems found during execution of a task that prevent it from being
-              ///< completed.
-    Critical, ///< Major problems during execution that threaten the stability of the entire
-              ///< application.
-
-    Count ///< Total number of logging levels
-};
-
-/**
- * Specifies the sub-system that generated the log message.
- *
- * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
- * filter.cpp.
- */
-enum class Class : u8 {
-    Log,                ///< Messages about the log system itself
-    Common,             ///< Library routines
-    Common_Filesystem,  ///< Filesystem interface library
-    Common_Memory,      ///< Memory mapping and management functions
-    Core,               ///< LLE emulation core
-    Core_ARM,           ///< ARM CPU core
-    Core_Timing,        ///< CoreTiming functions
-    Config,             ///< Emulator configuration (including commandline)
-    Debug,              ///< Debugging tools
-    Debug_Emulated,     ///< Debug messages from the emulated programs
-    Debug_GPU,          ///< GPU debugging tools
-    Debug_Breakpoint,   ///< Logging breakpoints and watchpoints
-    Debug_GDBStub,      ///< GDB Stub
-    Kernel,             ///< The HLE implementation of the CTR kernel
-    Kernel_SVC,         ///< Kernel system calls
-    Service,            ///< HLE implementation of system services. Each major service
-                        ///< should have its own subclass.
-    Service_ACC,        ///< The ACC (Accounts) service
-    Service_AM,         ///< The AM (Applet manager) service
-    Service_AOC,        ///< The AOC (AddOn Content) service
-    Service_APM,        ///< The APM (Performance) service
-    Service_ARP,        ///< The ARP service
-    Service_Audio,      ///< The Audio (Audio control) service
-    Service_BCAT,       ///< The BCAT service
-    Service_BGTC,       ///< The BGTC (Background Task Controller) service
-    Service_BPC,        ///< The BPC service
-    Service_BTDRV,      ///< The Bluetooth driver service
-    Service_BTM,        ///< The BTM service
-    Service_Capture,    ///< The capture service
-    Service_ERPT,       ///< The error reporting service
-    Service_ETicket,    ///< The ETicket service
-    Service_EUPLD,      ///< The error upload service
-    Service_Fatal,      ///< The Fatal service
-    Service_FGM,        ///< The FGM service
-    Service_Friend,     ///< The friend service
-    Service_FS,         ///< The FS (Filesystem) service
-    Service_GRC,        ///< The game recording service
-    Service_HID,        ///< The HID (Human interface device) service
-    Service_IRS,        ///< The IRS service
-    Service_JIT,        ///< The JIT service
-    Service_LBL,        ///< The LBL (LCD backlight) service
-    Service_LDN,        ///< The LDN (Local domain network) service
-    Service_LDR,        ///< The loader service
-    Service_LM,         ///< The LM (Logger) service
-    Service_Migration,  ///< The migration service
-    Service_Mii,        ///< The Mii service
-    Service_MM,         ///< The MM (Multimedia) service
-    Service_MNPP,       ///< The MNPP service
-    Service_NCM,        ///< The NCM service
-    Service_NFC,        ///< The NFC (Near-field communication) service
-    Service_NFP,        ///< The NFP service
-    Service_NGC,        ///< The NGC (No Good Content) service
-    Service_NIFM,       ///< The NIFM (Network interface) service
-    Service_NIM,        ///< The NIM service
-    Service_NOTIF,      ///< The NOTIF (Notification) service
-    Service_NPNS,       ///< The NPNS service
-    Service_NS,         ///< The NS services
-    Service_NVDRV,      ///< The NVDRV (Nvidia driver) service
-    Service_Nvnflinger, ///< The Nvnflinger service
-    Service_OLSC,       ///< The OLSC service
-    Service_PCIE,       ///< The PCIe service
-    Service_PCTL,       ///< The PCTL (Parental control) service
-    Service_PCV,        ///< The PCV service
-    Service_PM,         ///< The PM service
-    Service_PREPO,      ///< The PREPO (Play report) service
-    Service_PSC,        ///< The PSC service
-    Service_PTM,        ///< The PTM service
-    Service_SET,        ///< The SET (Settings) service
-    Service_SM,         ///< The SM (Service manager) service
-    Service_SPL,        ///< The SPL service
-    Service_SSL,        ///< The SSL service
-    Service_TCAP,       ///< The TCAP service.
-    Service_Time,       ///< The time service
-    Service_USB,        ///< The USB (Universal Serial Bus) service
-    Service_VI,         ///< The VI (Video interface) service
-    Service_WLAN,       ///< The WLAN (Wireless local area network) service
-    HW,                 ///< Low-level hardware emulation
-    HW_Memory,          ///< Memory-map and address translation
-    HW_LCD,             ///< LCD register emulation
-    HW_GPU,             ///< GPU control emulation
-    HW_AES,             ///< AES engine emulation
-    IPC,                ///< IPC interface
-    Frontend,           ///< Emulator UI
-    Render,             ///< Emulator video output and hardware acceleration
-    Render_Software,    ///< Software renderer backend
-    Render_OpenGL,      ///< OpenGL backend
-    Render_Vulkan,      ///< Vulkan backend
-    Shader,             ///< Shader recompiler
-    Shader_SPIRV,       ///< Shader SPIR-V code generation
-    Shader_GLASM,       ///< Shader GLASM code generation
-    Shader_GLSL,        ///< Shader GLSL code generation
-    Audio,              ///< Audio emulation
-    Audio_DSP,          ///< The HLE implementation of the DSP
-    Audio_Sink,         ///< Emulator audio output backend
-    Loader,             ///< ROM loader
-    CheatEngine,        ///< Memory manipulation and engine VM functions
-    Crypto,             ///< Cryptographic engine/functions
-    Input,              ///< Input emulation
-    Network,            ///< Network emulation
-    WebService,         ///< Interface to yuzu Web Services
-    Count               ///< Total number of logging classes
-};
-
-} // namespace Common::Log

src/common/param_package.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,7 +9,7 @@
 #include <utility>
 #include <vector>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/param_package.h"
 #include "common/string_util.h"
 

src/common/settings.cpp

@@ -23,7 +23,7 @@
 #include "common/assert.h"
 #include "common/fs/fs_util.h"
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "common/time_zone.h"
 

src/common/thread.cpp

@@ -8,7 +8,7 @@
 #include <thread>
 
 #include "common/error.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/assert.h"
 #include "common/thread.h"
 #ifdef __APPLE__

src/common/time_zone.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,7 +13,7 @@
 #include <fmt/chrono.h>
 #include <fmt/core.h>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/time_zone.h"
 
 namespace Common::TimeZone {

src/common/x64/cpu_detect.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-FileCopyrightText: Copyright 2013 Dolphin Emulator Project / 2015 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -12,7 +15,7 @@
 #include <vector>
 #include "common/bit_util.h"
 #include "common/common_types.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/x64/cpu_detect.h"
 #include "common/x64/rdtsc.h"
 

src/core/arm/arm_interface.cpp

@@ -1,9 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/debug.h"
 #include "core/core.h"

src/core/arm/dynarmic/dynarmic_cp15.cpp

@@ -1,11 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <fmt/ranges.h>
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/arm/dynarmic/arm_dynarmic_32.h"
 #include "core/arm/dynarmic/dynarmic_cp15.h"
 #include "core/core.h"

src/core/arm/nce/interpreter_visitor.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -14,7 +14,7 @@
 
 #include "core/hle/kernel/k_thread.h"
 #include "core/memory.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/arm/nce/visitor_base.h"
 
 namespace Core {

src/core/arm/nce/patcher.h

@@ -9,7 +9,7 @@
 #include <oaknut/code_block.hpp>
 #include <oaknut/oaknut.hpp>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/common_types.h"
 #include "common/settings.h"
 #include "core/hle/kernel/code_set.h"

src/core/core.cpp

@@ -9,7 +9,7 @@
 #include "game_settings.h"
 #include "audio_core/audio_core.h"
 #include "common/fs/fs.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "common/settings_enums.h"
 #include "common/string_util.h"

src/core/crypto/aes_util.cpp

@@ -9,7 +9,7 @@
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include "common/assert.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
 

src/core/crypto/key_manager.cpp

@@ -20,7 +20,7 @@
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "common/string_util.h"
 #include "core/crypto/aes_util.h"

src/core/debugger/debugger.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -19,7 +19,7 @@
 #include <boost/process/async_pipe.hpp>
 #endif
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/core.h"

src/core/debugger/gdbstub.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -14,7 +14,7 @@
 #include <boost/algorithm/string.hpp>
 
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"
 #include "common/string_util.h"

src/core/file_sys/card_image.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,7 +9,7 @@
 
 #include <fmt/ostream.h>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"

src/core/file_sys/content_archive.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -9,7 +9,7 @@
 #include <optional>
 #include <utility>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include <ranges>
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"

src/core/file_sys/ips_layer.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include <algorithm>
@@ -9,7 +9,7 @@
 #include <utility>
 
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/swap.h"
 #include "core/file_sys/ips_layer.h"
 #include "core/file_sys/vfs/vfs_vector.h"

src/core/file_sys/nca_metadata.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -6,7 +6,7 @@
 
 #include <cstring>
 #include "common/common_types.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/swap.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/vfs/vfs.h"

src/core/file_sys/partition_filesystem.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,7 +10,7 @@
 #include <iterator>
 #include <utility>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/vfs/vfs_offset.h"
 #include "core/loader/loader.h"

src/core/file_sys/patch_manager.cpp

@@ -10,7 +10,7 @@
 #include <cstring>
 
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #ifndef _WIN32
 #include "common/string_util.h"

src/core/file_sys/program_metadata.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -7,7 +7,7 @@
 #include <cstddef>
 #include <vector>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scope_exit.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/file_sys/vfs/vfs.h"

src/core/file_sys/registered_cache.cpp

@@ -11,7 +11,7 @@
 #include "common/assert.h"
 #include "common/fs/path_util.h"
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/string_util.h"
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/card_image.h"

src/core/file_sys/romfs_factory.cpp

@@ -1,10 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <memory>
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"

src/core/file_sys/savedata_factory.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -6,7 +6,7 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/uuid.h"
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"

src/core/file_sys/submission_package.cpp

@@ -10,7 +10,7 @@
 #include <fmt/ostream.h>
 
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"

src/core/file_sys/system_archive/system_archive.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/system_archive/mii_model.h"
 #include "core/file_sys/system_archive/ng_word.h"

src/core/file_sys/system_archive/system_version.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/file_sys/system_archive/system_version.h"
 #include "core/file_sys/vfs/vfs_vector.h"
 #include "core/hle/api_version.h"

src/core/file_sys/vfs/vfs_real.cpp

@@ -12,7 +12,7 @@
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/file_sys/vfs/vfs.h"
 #include "core/file_sys/vfs/vfs_real.h"
 

src/core/frontend/applets/cabinet.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/frontend/applets/cabinet.h"
 
 #include <thread>

src/core/frontend/applets/controller.cpp

@@ -1,8 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "common/settings_enums.h"
 #include "core/frontend/applets/controller.h"

src/core/frontend/applets/error.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/frontend/applets/error.h"
 
 namespace Core::Frontend {

src/core/frontend/applets/general.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/frontend/applets/general.h"
 
 namespace Core::Frontend {

src/core/frontend/applets/mii_edit.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/frontend/applets/mii_edit.h"
 
 namespace Core::Frontend {

src/core/frontend/applets/net_connect.cpp

@@ -1,7 +1,7 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/frontend/applets/net_connect.h"
 
 namespace Core::Frontend {

src/core/frontend/applets/software_keyboard.cpp

@@ -1,9 +1,12 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <thread>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/string_util.h"
 #include "core/frontend/applets/software_keyboard.h"
 

src/core/frontend/applets/web_browser.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/frontend/applets/web_browser.h"
 
 namespace Core::Frontend {

src/core/game_settings.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/game_settings.h"
@@ -6,7 +6,7 @@
 #include <algorithm>
 #include <cctype>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "video_core/renderer_base.h"
 

src/core/hle/kernel/k_scheduler.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -9,7 +9,7 @@
 #include "common/assert.h"
 #include "common/bit_util.h"
 #include "common/fiber.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/core_timing.h"

src/core/hle/kernel/k_server_session.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,7 +9,7 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scope_exit.h"
 #include "common/scratch_buffer.h"
 #include "core/core.h"

src/core/hle/kernel/k_thread.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -18,7 +18,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/fiber.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/cpu_manager.h"

src/core/hle/kernel/kernel.cpp

@@ -14,7 +14,7 @@
 #include <utility>
 
 #include "common/assert.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/scope_exit.h"
 #include "common/thread.h"
 #include "common/thread_worker.h"

src/core/hle/kernel/svc/svc_processor.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/svc.h"

src/core/hle/service/acc/acc.cpp

@@ -10,7 +10,7 @@
 #include "common/common_types.h"
 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include <ranges>
 #include "common/stb.h"
 #include "common/string_util.h"

src/core/hle/service/am/frontend/applet_cabinet.cpp

@@ -1,11 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/frontend/applets/cabinet.h"
 #include "core/hle/kernel/k_event.h"

src/core/hle/service/am/frontend/applet_controller.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -8,7 +8,7 @@
 #include <cstring>
 
 #include "common/assert.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/controller.h"

src/core/hle/service/am/frontend/applet_error.cpp

@@ -7,7 +7,7 @@
 #include <array>
 #include <cstring>
 #include "common/assert.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/error.h"

src/core/hle/service/am/frontend/applet_general.cpp

@@ -1,9 +1,12 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/frontend/applets/general.h"
 #include "core/hle/result.h"

src/core/hle/service/am/frontend/applet_mii_edit.cpp

@@ -1,8 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/frontend/applets/mii_edit.h"
 #include "core/hle/service/am/am.h"

src/core/hle/service/am/frontend/applet_net_connect.cpp

@@ -1,9 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "common/assert.h"
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/frontend/applets/net_connect.h"
 #include "core/hle/result.h"

src/core/hle/service/am/frontend/applet_web_browser.cpp

@@ -8,7 +8,7 @@
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "common/string_util.h"
 #include "core/core.h"

src/core/hle/service/am/service/self_controller.cpp

@@ -1,10 +1,10 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am_results.h"
 #include "core/hle/service/am/frontend/applets.h"

src/core/hle/service/aoc/addon_content_manager.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -5,7 +8,7 @@
 #include <numeric>
 #include <vector>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/file_sys/common_funcs.h"

src/core/hle/service/apm/apm_controller.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -5,7 +8,7 @@
 #include <array>
 #include <utility>
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "common/settings.h"
 #include "common/settings_enums.h"
 #include "core/core_timing.h"

src/core/hle/service/apm/apm_interface.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/apm/apm_interface.h"

src/core/hle/service/bcat/backend/backend.cpp

@@ -1,8 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/bcat/backend/backend.h"

src/core/hle/service/bcat/news/builtin_news.cpp

@@ -7,7 +7,7 @@
 
 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/regex.hpp>

src/core/hle/service/bcat/news/news_data_service.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -9,7 +9,7 @@
 #include "core/hle/service/bcat/news/news_storage.h"
 #include "core/hle/service/cmif_serialization.h"
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 
 #include <cstring>
 

src/core/hle/service/btdrv/btdrv.cpp

@@ -1,7 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/logging/log.h"
+#include "common/logging.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/btdrv/btdrv.h"