29 files changed, 105 insertions, 104 deletions

diff --git a/src/core/arm/dynarmic/arm_dynarmic.cpp b/src/core/arm/dynarmic/arm_dynarmic.cpp
index 984ad853d..b5db47667 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic.cpp
@@ -55,7 +55,7 @@ public:
     }
 
     void InterpreterFallback(u64 pc, size_t num_instructions) override {
-        NGLOG_INFO(Core_ARM, "Unicorn fallback @ {:#X} for {} instructions (instr = {:08X})", pc,
+        NGLOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
                    num_instructions, MemoryReadCode(pc));
 
         ARM_Interface::ThreadContext ctx;
diff --git a/src/core/arm/unicorn/arm_unicorn.cpp b/src/core/arm/unicorn/arm_unicorn.cpp
index 4b121edb3..574922130 100644
--- a/src/core/arm/unicorn/arm_unicorn.cpp
+++ b/src/core/arm/unicorn/arm_unicorn.cpp
@@ -53,7 +53,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
                                void* user_data) {
     ARM_Interface::ThreadContext ctx{};
     Core::CPU().SaveContext(ctx);
-    ASSERT_MSG(false, "Attempted to read from unmapped memory: {:#X}, pc={:#X}, lr={:#X}", addr,
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x{:X}, pc=0x{:X}, lr=0x{:X}", addr,
                ctx.pc, ctx.cpu_registers[30]);
     return {};
 }
diff --git a/src/core/file_sys/program_metadata.cpp b/src/core/file_sys/program_metadata.cpp
index 1f5ded514..25a822891 100644
--- a/src/core/file_sys/program_metadata.cpp
+++ b/src/core/file_sys/program_metadata.cpp
@@ -77,11 +77,11 @@ u64 ProgramMetadata::GetFilesystemPermissions() const {
 
 void ProgramMetadata::Print() const {
     NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", npdm_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Main thread priority:   {:#04X}", npdm_header.main_thread_priority);
+    NGLOG_DEBUG(Service_FS, "Main thread priority:   0x{:02X}", npdm_header.main_thread_priority);
     NGLOG_DEBUG(Service_FS, "Main thread core:       {}", npdm_header.main_thread_cpu);
-    NGLOG_DEBUG(Service_FS, "Main thread stack size: {:#X} bytes", npdm_header.main_stack_size);
+    NGLOG_DEBUG(Service_FS, "Main thread stack size: 0x{:X} bytes", npdm_header.main_stack_size);
     NGLOG_DEBUG(Service_FS, "Process category:       {}", npdm_header.process_category);
-    NGLOG_DEBUG(Service_FS, "Flags:                  {:02X}", npdm_header.flags);
+    NGLOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", npdm_header.flags);
     NGLOG_DEBUG(Service_FS, " > 64-bit instructions: {}",
                 npdm_header.has_64_bit_instructions ? "YES" : "NO");
 
@@ -99,15 +99,15 @@ void ProgramMetadata::Print() const {
 
     // Begin ACID printing (potential perms, signed)
     NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", acid_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Flags:                  {:02X}", acid_header.flags);
+    NGLOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", acid_header.flags);
     NGLOG_DEBUG(Service_FS, " > Is Retail:           {}", acid_header.is_retail ? "YES" : "NO");
-    NGLOG_DEBUG(Service_FS, "Title ID Min:           {:016X}", acid_header.title_id_min);
-    NGLOG_DEBUG(Service_FS, "Title ID Max:           {:016X}", acid_header.title_id_max);
-    NGLOG_DEBUG(Service_FS, "Filesystem Access:      {:016X}\n", acid_file_access.permissions);
+    NGLOG_DEBUG(Service_FS, "Title ID Min:           0x{:016X}", acid_header.title_id_min);
+    NGLOG_DEBUG(Service_FS, "Title ID Max:           0x{:016X}", acid_header.title_id_max);
+    NGLOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", acid_file_access.permissions);
 
     // Begin ACI0 printing (actual perms, unsigned)
     NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", aci_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Title ID:               {:016X}", aci_header.title_id);
-    NGLOG_DEBUG(Service_FS, "Filesystem Access:      {:016X}\n", aci_file_access.permissions);
+    NGLOG_DEBUG(Service_FS, "Title ID:               0x{:016X}", aci_header.title_id);
+    NGLOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", aci_file_access.permissions);
 }
 } // namespace FileSys
diff --git a/src/core/hle/kernel/object_address_table.cpp b/src/core/hle/kernel/object_address_table.cpp
index b88a90f24..ec97f6f8e 100644
--- a/src/core/hle/kernel/object_address_table.cpp
+++ b/src/core/hle/kernel/object_address_table.cpp
@@ -10,12 +10,12 @@ namespace Kernel {
 ObjectAddressTable g_object_address_table;
 
 void ObjectAddressTable::Insert(VAddr addr, SharedPtr<Object> obj) {
-    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr={:#X}", addr);
+    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x{:X}", addr);
     objects[addr] = obj;
 }
 
 void ObjectAddressTable::Close(VAddr addr) {
-    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr={:#X}", addr);
+    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x{:X}", addr);
     objects.erase(addr);
 }
 
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index b423a3477..651d932d3 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -111,7 +111,7 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
             int major = (kernel_version >> 8) & 0xFF;
             NGLOG_INFO(Loader, "ExHeader kernel version: {}.{}", major, minor);
         } else {
-            NGLOG_ERROR(Loader, "Unhandled kernel caps descriptor: {:#010X}", descriptor);
+            NGLOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x{:08X}", descriptor);
         }
     }
 }
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index b1f8e771c..ad47ff9df 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -68,7 +68,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
             return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
 
         case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
-            NGLOG_DEBUG(IPC, "CloseVirtualHandle, object_id={:#010X}", object_id);
+            NGLOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x{:08X}", object_id);
 
             domain_request_handlers[object_id - 1] = nullptr;
 
diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp
index f0b65c73d..ac4921298 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -107,7 +107,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
 
     // Error out if the requested permissions don't match what the creator process allows.
     if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
-        NGLOG_ERROR(Kernel, "cannot map id={}, address={:#X} name={}, permissions don't match",
+        NGLOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
                     GetObjectId(), address, name);
         return ERR_INVALID_COMBINATION;
     }
@@ -115,7 +115,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     // Error out if the provided permissions are not compatible with what the creator process needs.
     if (other_permissions != MemoryPermission::DontCare &&
         static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
-        NGLOG_ERROR(Kernel, "cannot map id={}, address={:#X} name={}, permissions don't match",
+        NGLOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
                     GetObjectId(), address, name);
         return ERR_WRONG_PERMISSION;
     }
@@ -133,7 +133,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     if (result.Failed()) {
         NGLOG_ERROR(
             Kernel,
-            "cannot map id={}, target_address={:#X} name={}, error mapping to virtual memory",
+            "cannot map id={}, target_address=0x{:X} name={}, error mapping to virtual memory",
             GetObjectId(), target_address, name);
         return result.Code();
     }
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index e2da68227..72b5c05f2 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -31,7 +31,7 @@ namespace Kernel {
 
 /// Set the process heap to a given Size. It can both extend and shrink the heap.
 static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
-    NGLOG_TRACE(Kernel_SVC, "called, heap_size={:#X}", heap_size);
+    NGLOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", heap_size);
     auto& process = *Core::CurrentProcess();
     CASCADE_RESULT(*heap_addr,
                    process.HeapAllocate(Memory::HEAP_VADDR, heap_size, VMAPermission::ReadWrite));
@@ -39,20 +39,20 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
 }
 
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, addr={:#X}", addr);
+    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x{:X}", addr);
     return RESULT_SUCCESS;
 }
 
 /// Maps a memory range into a different range.
 static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
-    NGLOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr={:#X}, size={:#X}", dst_addr,
+    NGLOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
                 src_addr, size);
     return Core::CurrentProcess()->MirrorMemory(dst_addr, src_addr, size);
 }
 
 /// Unmaps a region that was previously mapped with svcMapMemory
 static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
-    NGLOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr={:#X}, size={:#X}", dst_addr,
+    NGLOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
                 src_addr, size);
     return Core::CurrentProcess()->UnmapMemory(dst_addr, src_addr, size);
 }
@@ -90,11 +90,11 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
 static ResultCode SendSyncRequest(Handle handle) {
     SharedPtr<ClientSession> session = g_handle_table.Get<ClientSession>(handle);
     if (!session) {
-        NGLOG_ERROR(Kernel_SVC, "called with invalid handle={:#010X}", handle);
+        NGLOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
     }
 
-    NGLOG_TRACE(Kernel_SVC, "called handle={:#010X}({})", handle, session->GetName());
+    NGLOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
 
     Core::System::GetInstance().PrepareReschedule();
 
@@ -105,7 +105,7 @@ static ResultCode SendSyncRequest(Handle handle) {
 
 /// Get the ID for the specified thread.
 static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called thread={:#010X}", thread_handle);
+    NGLOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
     const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
@@ -118,7 +118,7 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
 
 /// Get the ID of the specified process
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called process={:#010X}", process_handle);
+    NGLOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);
 
     const SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
     if (!process) {
@@ -178,7 +178,7 @@ static ResultCode WaitSynchronization1(
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
 static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64 handle_count,
                                       s64 nano_seconds) {
-    NGLOG_TRACE(Kernel_SVC, "called handles_address={:#X}, handle_count={}, nano_seconds={}",
+    NGLOG_TRACE(Kernel_SVC, "called handles_address=0x{:X}, handle_count={}, nano_seconds={}",
                 handles_address, handle_count, nano_seconds);
 
     if (!Memory::IsValidVirtualAddress(handles_address))
@@ -239,7 +239,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 
 /// Resumes a thread waiting on WaitSynchronization
 static ResultCode CancelSynchronization(Handle thread_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called thread={:#X}", thread_handle);
+    NGLOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
 
     const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
@@ -257,8 +257,8 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
 static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
                                 Handle requesting_thread_handle) {
     NGLOG_TRACE(Kernel_SVC,
-                "called holding_thread_handle={:#010X}, mutex_addr={:#X}, "
-                "requesting_current_thread_handle={:#010X}",
+                "called holding_thread_handle=0x{:08X}, mutex_addr=0x{:X}, "
+                "requesting_current_thread_handle=0x{:08X}",
                 holding_thread_handle, mutex_addr, requesting_thread_handle);
 
     return Mutex::TryAcquire(mutex_addr, holding_thread_handle, requesting_thread_handle);
@@ -266,7 +266,7 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
 
 /// Unlock a mutex
 static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
-    NGLOG_TRACE(Kernel_SVC, "called mutex_addr={:#X}", mutex_addr);
+    NGLOG_TRACE(Kernel_SVC, "called mutex_addr=0x{:X}", mutex_addr);
 
     return Mutex::Release(mutex_addr);
 }
@@ -286,7 +286,7 @@ static void OutputDebugString(VAddr address, s32 len) {
 
 /// Gets system/memory information for the current process
 static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id) {
-    NGLOG_TRACE(Kernel_SVC, "called info_id={:#X}, info_sub_id={:#X}, handle={:#010X}", info_id,
+    NGLOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
                 info_sub_id, handle);
 
     auto& vm_manager = Core::CurrentProcess()->vm_manager;
@@ -355,14 +355,14 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
 
 /// Sets the thread activity
 static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:#010X}, unknown={:#010X}", handle,
+    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, unknown=0x{:08X}", handle,
                   unknown);
     return RESULT_SUCCESS;
 }
 
 /// Gets the thread context
 static ResultCode GetThreadContext(Handle handle, VAddr addr) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:#010X}, addr={:#X}", handle, addr);
+    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, addr=0x{:X}", handle, addr);
     return RESULT_SUCCESS;
 }
 
@@ -407,9 +407,10 @@ static u32 GetCurrentProcessorNumber() {
 
 static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size,
                                   u32 permissions) {
-    NGLOG_TRACE(Kernel_SVC,
-                "called, shared_memory_handle={:#X}, addr={:#X}, size={:#X}, permissions={:#010X}",
-                shared_memory_handle, addr, size, permissions);
+    NGLOG_TRACE(
+        Kernel_SVC,
+        "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
+        shared_memory_handle, addr, size, permissions);
 
     SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
     if (!shared_memory) {
@@ -429,14 +430,14 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
         return shared_memory->Map(Core::CurrentProcess().get(), addr, permissions_type,
                                   MemoryPermission::DontCare);
     default:
-        NGLOG_ERROR(Kernel_SVC, "unknown permissions={:#010X}", permissions);
+        NGLOG_ERROR(Kernel_SVC, "unknown permissions=0x{:08X}", permissions);
     }
 
     return RESULT_SUCCESS;
 }
 
 static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
-    NGLOG_WARNING(Kernel_SVC, "called, shared_memory_handle={:#010X}, addr={:#X}, size={:#X}",
+    NGLOG_WARNING(Kernel_SVC, "called, shared_memory_handle=0x{:08X}, addr=0x{:X}, size=0x{:X}",
                   shared_memory_handle, addr, size);
 
     SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
@@ -465,7 +466,7 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_i
         memory_info->type = static_cast<u32>(vma->second.meminfo_state);
     }
 
-    NGLOG_TRACE(Kernel_SVC, "called process={:#010X} addr={:X}", process_handle, addr);
+    NGLOG_TRACE(Kernel_SVC, "called process=0x{:08X} addr={:X}", process_handle, addr);
     return RESULT_SUCCESS;
 }
 
@@ -552,8 +553,8 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     Core::System::GetInstance().PrepareReschedule();
 
     NGLOG_TRACE(Kernel_SVC,
-                "called entrypoint={:#010X} ({}), arg={:#010X}, stacktop={:#010X}, "
-                "threadpriority={:#010X}, processorid={:#010X} : created handle={:#010X}",
+                "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
+                "threadpriority=0x{:08X}, processorid=0x{:08X} : created handle=0x{:08X}",
                 entry_point, name, arg, stack_top, priority, processor_id, *out_handle);
 
     return RESULT_SUCCESS;
@@ -561,7 +562,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 
 /// Starts the thread for the provided handle
 static ResultCode StartThread(Handle thread_handle) {
-    NGLOG_TRACE(Kernel_SVC, "called thread={:#010X}", thread_handle);
+    NGLOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
     const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
@@ -575,7 +576,7 @@ static ResultCode StartThread(Handle thread_handle) {
 
 /// Called when a thread exits
 static void ExitThread() {
-    NGLOG_TRACE(Kernel_SVC, "called, pc={:#010X}", Core::CPU().GetPC());
+    NGLOG_TRACE(Kernel_SVC, "called, pc=0x{:08X}", Core::CPU().GetPC());
 
     ExitCurrentThread();
     Core::System::GetInstance().PrepareReschedule();
@@ -604,7 +605,7 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
                                            Handle thread_handle, s64 nano_seconds) {
     NGLOG_TRACE(
         Kernel_SVC,
-        "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle={:#010X}, timeout={}",
+        "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
         mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
 
     SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
@@ -629,7 +630,7 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
 
 /// Signal process wide key
 static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target) {
-    NGLOG_TRACE(Kernel_SVC, "called, condition_variable_addr={:#X}, target={:#010X}",
+    NGLOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
                 condition_variable_addr, target);
 
     u32 processed = 0;
@@ -696,13 +697,13 @@ static u64 GetSystemTick() {
 
 /// Close a handle
 static ResultCode CloseHandle(Handle handle) {
-    NGLOG_TRACE(Kernel_SVC, "Closing handle {:#010X}", handle);
+    NGLOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
     return g_handle_table.Close(handle);
 }
 
 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called handle {:#010X}", handle);
+    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);
     auto event = g_handle_table.Get<Event>(handle);
     ASSERT(event != nullptr);
     event->Clear();
@@ -711,28 +712,28 @@ static ResultCode ResetSignal(Handle handle) {
 
 /// Creates a TransferMemory object
 static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32 permissions) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called addr={:#X}, size={:#X}, perms={:010X}", addr, size,
-                  permissions);
+    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x{:X}, size=0x{:X}, perms=0x{:08X}", addr,
+                  size, permissions);
     *handle = 0;
     return RESULT_SUCCESS;
 }
 
 static ResultCode GetThreadCoreMask(Handle handle, u32* mask, u64* unknown) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:010X}", handle);
+    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}", handle);
     *mask = 0x0;
     *unknown = 0xf;
     return RESULT_SUCCESS;
 }
 
 static ResultCode SetThreadCoreMask(Handle handle, u32 mask, u64 unknown) {
-    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle={:#010X}, mask={:#010X}, unknown={:#X}",
+    NGLOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x{:08X}, mask=0x{:08X}, unknown=0x{:X}",
                   handle, mask, unknown);
     return RESULT_SUCCESS;
 }
 
 static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permissions,
                                      u32 remote_permissions) {
-    NGLOG_TRACE(Kernel_SVC, "called, size={:#X}, localPerms={:#010X}, remotePerms={:#010X}", size,
+    NGLOG_TRACE(Kernel_SVC, "called, size=0x{:X}, localPerms=0x{:08X}, remotePerms=0x{:08X}", size,
                 local_permissions, remote_permissions);
     auto sharedMemHandle =
         SharedMemory::Create(g_handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
@@ -744,7 +745,7 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
 }
 
 static ResultCode ClearEvent(Handle handle) {
-    NGLOG_TRACE(Kernel_SVC, "called, event={:010X}", handle);
+    NGLOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);
 
     SharedPtr<Event> evt = g_handle_table.Get<Event>(handle);
     if (evt == nullptr)
@@ -896,7 +897,7 @@ static const FunctionDef SVC_Table[] = {
 
 static const FunctionDef* GetSVCInfo(u32 func_num) {
     if (func_num >= std::size(SVC_Table)) {
-        NGLOG_ERROR(Kernel_SVC, "Unknown svc={:#04X}", func_num);
+        NGLOG_ERROR(Kernel_SVC, "Unknown svc=0x{:02X}", func_num);
         return nullptr;
     }
     return &SVC_Table[func_num];
@@ -918,7 +919,7 @@ void CallSVC(u32 immediate) {
             NGLOG_CRITICAL(Kernel_SVC, "Unimplemented SVC function {}(..)", info->name);
         }
     } else {
-        NGLOG_CRITICAL(Kernel_SVC, "Unknown SVC function {:#X}", immediate);
+        NGLOG_CRITICAL(Kernel_SVC, "Unknown SVC function 0x{:X}", immediate);
     }
 }
 
diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp
index 06f143fb1..2f0044c11 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -243,8 +243,8 @@ VMManager::VMAIter VMManager::StripIterConstness(const VMAHandle& iter) {
 }
 
 ResultVal<VMManager::VMAIter> VMManager::CarveVMA(VAddr base, u64 size) {
-    ASSERT_MSG((size & Memory::PAGE_MASK) == 0, "non-page aligned size: {:#018X}", size);
-    ASSERT_MSG((base & Memory::PAGE_MASK) == 0, "non-page aligned base: {:#018X}", base);
+    ASSERT_MSG((size & Memory::PAGE_MASK) == 0, "non-page aligned size: 0x{:016X}", size);
+    ASSERT_MSG((base & Memory::PAGE_MASK) == 0, "non-page aligned base: 0x{:016X}", base);
 
     VMAIter vma_handle = StripIterConstness(FindVMA(base));
     if (vma_handle == vma_map.end()) {
@@ -279,8 +279,8 @@ ResultVal<VMManager::VMAIter> VMManager::CarveVMA(VAddr base, u64 size) {
 }
 
 ResultVal<VMManager::VMAIter> VMManager::CarveVMARange(VAddr target, u64 size) {
-    ASSERT_MSG((size & Memory::PAGE_MASK) == 0, "non-page aligned size: {:#018X}", size);
-    ASSERT_MSG((target & Memory::PAGE_MASK) == 0, "non-page aligned base: {:#018X}", target);
+    ASSERT_MSG((size & Memory::PAGE_MASK) == 0, "non-page aligned size: 0x{:016X}", size);
+    ASSERT_MSG((target & Memory::PAGE_MASK) == 0, "non-page aligned base: 0x{:016X}", target);
 
     VAddr target_end = target + size;
     ASSERT(target_end >= target);
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index c123e7809..d93afbed7 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -534,7 +534,7 @@ void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 
-    NGLOG_WARNING(Service_AM, "(STUBBED) called, result={:#010}", result);
+    NGLOG_WARNING(Service_AM, "(STUBBED) called, result=0x{:08X}", result);
 }
 
 void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
diff --git a/src/core/hle/service/fatal/fatal.cpp b/src/core/hle/service/fatal/fatal.cpp
index d7ad0600a..bb75e7314 100644
--- a/src/core/hle/service/fatal/fatal.cpp
+++ b/src/core/hle/service/fatal/fatal.cpp
@@ -16,7 +16,7 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
 void Module::Interface::FatalSimple(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp(ctx);
     u32 error_code = rp.Pop<u32>();
-    NGLOG_WARNING(Service_Fatal, "(STUBBED) called, error_code={:#X}", error_code);
+    NGLOG_WARNING(Service_Fatal, "(STUBBED) called, error_code=0x{:X}", error_code);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index c2951c560..68d1c90a5 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -25,7 +25,7 @@ ResultCode RegisterFileSystem(std::unique_ptr<FileSys::FileSystemFactory>&& fact
     ASSERT_MSG(inserted, "Tried to register more than one system with same id code");
 
     auto& filesystem = result.first->second;
-    NGLOG_DEBUG(Service_FS, "Registered file system {} with id code {:#010X}",
+    NGLOG_DEBUG(Service_FS, "Registered file system {} with id code 0x{:08X}",
                 filesystem->GetName(), static_cast<u32>(type));
     return RESULT_SUCCESS;
 }
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index ed9f2ef72..8a47bb7af 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -35,7 +35,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        NGLOG_DEBUG(Service_FS, "called, offset={:#X}, length={}", offset, length);
+        NGLOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -87,7 +87,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        NGLOG_DEBUG(Service_FS, "called, offset={:#X}, length={}", offset, length);
+        NGLOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -124,7 +124,7 @@ private:
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        NGLOG_DEBUG(Service_FS, "called, offset={:#X}, length={}", offset, length);
+        NGLOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
 
         // Error checking
         if (length < 0) {
@@ -197,7 +197,7 @@ private:
         IPC::RequestParser rp{ctx};
         const u64 unk = rp.Pop<u64>();
 
-        NGLOG_DEBUG(Service_FS, "called, unk={:#X}", unk);
+        NGLOG_DEBUG(Service_FS, "called, unk=0x{:X}", unk);
 
         // Calculate how many entries we can fit in the output buffer
         u64 count_entries = ctx.GetWriteBufferSize() / sizeof(FileSys::Entry);
@@ -265,7 +265,7 @@ public:
         u64 mode = rp.Pop<u64>();
         u32 size = rp.Pop<u32>();
 
-        NGLOG_DEBUG(Service_FS, "called file {} mode {:#X} size {:#010X}", name, mode, size);
+        NGLOG_DEBUG(Service_FS, "called file {} mode 0x{:X} size 0x{:08X}", name, mode, size);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(backend->CreateFile(name, size));
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
index a7097bd23..cb4913b07 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
@@ -12,7 +12,7 @@
 namespace Service::Nvidia::Devices {
 
 u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command={:#010X}, input_size={:#X}, output_size={:#X}",
+    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
                 command.raw, input.size(), output.size());
 
     switch (static_cast<IoctlCommand>(command.raw)) {
@@ -38,7 +38,7 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vecto
 u32 nvhost_as_gpu::InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlInitalizeEx params{};
     std::memcpy(&params, input.data(), input.size());
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size={:#X}", params.big_page_size);
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, big_page_size=0x{:X}", params.big_page_size);
     return 0;
 }
 
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
index 46f0b6862..edd3f8538 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
@@ -9,7 +9,7 @@
 namespace Service::Nvidia::Devices {
 
 u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command={:#010X}, input_size={:#X}, output_size={:#X}",
+    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
                 command.raw, input.size(), output.size());
 
     switch (static_cast<IoctlCommand>(command.raw)) {
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
index 3c78ecaea..d5558f29f 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
@@ -10,7 +10,7 @@
 namespace Service::Nvidia::Devices {
 
 u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command={:#010X}, input_size={:#X}, output_size={:#X}",
+    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
                 command.raw, input.size(), output.size());
 
     switch (static_cast<IoctlCommand>(command.raw)) {
@@ -77,7 +77,7 @@ u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vecto
 u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlGpuGetTpcMasksArgs params{};
     std::memcpy(&params, input.data(), input.size());
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, mask={:#X}, mask_buf_addr={:#X}",
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, mask=0x{:X}, mask_buf_addr=0x{:X}",
                   params.mask_buf_size, params.mask_buf_addr);
     params.unk = 0xcafe; // TODO(ogniK): Needs to be non 0, what does this actually do?
     std::memcpy(output.data(), &params, sizeof(params));
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
index 9fee7d564..25e3ccef6 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp
@@ -12,7 +12,7 @@
 namespace Service::Nvidia::Devices {
 
 u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
-    NGLOG_DEBUG(Service_NVDRV, "called, command={:#010X}, input_size={:#X}, output_size={:#X}",
+    NGLOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
                 command.raw, input.size(), output.size());
 
     switch (static_cast<IoctlCommand>(command.raw)) {
diff --git a/src/core/hle/service/nvdrv/devices/nvmap.cpp b/src/core/hle/service/nvdrv/devices/nvmap.cpp
index 11df8849d..8d883209f 100644
--- a/src/core/hle/service/nvdrv/devices/nvmap.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvmap.cpp
@@ -49,7 +49,7 @@ u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
     u32 handle = next_handle++;
     handles[handle] = std::move(object);
 
-    NGLOG_DEBUG(Service_NVDRV, "size={:#010X}", params.size);
+    NGLOG_DEBUG(Service_NVDRV, "size=0x{:08X}", params.size);
 
     params.handle = handle;
 
diff --git a/src/core/hle/service/nvdrv/interface.cpp b/src/core/hle/service/nvdrv/interface.cpp
index 38b3a9a84..45d2862ef 100644
--- a/src/core/hle/service/nvdrv/interface.cpp
+++ b/src/core/hle/service/nvdrv/interface.cpp
@@ -75,7 +75,7 @@ void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     pid = rp.Pop<u64>();
 
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, pid={:#X}", pid);
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called, pid=0x{:X}", pid);
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(0);
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 7a5f08b24..dc30702c6 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -60,7 +60,7 @@ static std::string MakeFunctionString(const char* name, const char* port_name,
 
     std::string function_string = fmt::format("function '{}': port={}", name, port_name);
     for (int i = 1; i <= num_params; ++i) {
-        function_string += fmt::format(", cmd_buff[{}]={:#X}", i, cmd_buff[i]);
+        function_string += fmt::format(", cmd_buff[{}]=0x{:X}", i, cmd_buff[i]);
     }
     return function_string;
 }
@@ -113,10 +113,10 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(Kernel::HLERequestContext
     std::string function_name = info == nullptr ? fmt::format("{}", ctx.GetCommand()) : info->name;
 
     fmt::memory_buffer buf;
-    fmt::format_to(buf, "function '{}': port='{}' cmd_buf={{[0]={:#x}", function_name, service_name,
-                   cmd_buf[0]);
+    fmt::format_to(buf, "function '{}': port='{}' cmd_buf={{[0]=0x{:X}", function_name,
+                   service_name, cmd_buf[0]);
     for (int i = 1; i <= 8; ++i) {
-        fmt::format_to(buf, ", [{}]={:#x}", i, cmd_buf[i]);
+        fmt::format_to(buf, ", [{}]=0x{:X}", i, cmd_buf[i]);
     }
     buf.push_back('}');
 
diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp
index 073277ade..bded8421f 100644
--- a/src/core/hle/service/sm/sm.cpp
+++ b/src/core/hle/service/sm/sm.cpp
@@ -102,7 +102,7 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
     if (client_port.Failed()) {
         IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
         rb.Push(client_port.Code());
-        NGLOG_ERROR(Service_SM, "called service={} -> error {:#010X}", name,
+        NGLOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name,
                     client_port.Code().raw);
         if (name.length() == 0)
             return; // LibNX Fix
diff --git a/src/core/hle/service/time/time.cpp b/src/core/hle/service/time/time.cpp
index e50680356..2eb37fb42 100644
--- a/src/core/hle/service/time/time.cpp
+++ b/src/core/hle/service/time/time.cpp
@@ -111,7 +111,7 @@ private:
         IPC::RequestParser rp{ctx};
         u64 posix_time = rp.Pop<u64>();
 
-        NGLOG_WARNING(Service_Time, "(STUBBED) called, posix_time={:#018X}", posix_time);
+        NGLOG_WARNING(Service_Time, "(STUBBED) called, posix_time=0x{:016X}", posix_time);
 
         CalendarTime calendar_time{2018, 1, 1, 0, 0, 0};
         CalendarAdditionalInfo additional_info{};
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index 45f3568d2..e86556671 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -640,7 +640,7 @@ private:
         bool visibility = rp.Pop<bool>();
         IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
         rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_VI, "(STUBBED) called, layer_id={:#010X}, visibility={}", layer_id,
+        NGLOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:08X}, visibility={}", layer_id,
                       visibility);
     }
 };
@@ -762,7 +762,7 @@ private:
         bool visibility = rp.Pop<bool>();
         IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
         rb.Push(RESULT_SUCCESS);
-        NGLOG_WARNING(Service_VI, "(STUBBED) called, layer_id={:#X}, visibility={}", layer_id,
+        NGLOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:X}, visibility={}", layer_id,
                       visibility);
     }
 
diff --git a/src/core/hw/hw.cpp b/src/core/hw/hw.cpp
index f8a40390a..8fc91dc9c 100644
--- a/src/core/hw/hw.cpp
+++ b/src/core/hw/hw.cpp
@@ -33,7 +33,7 @@ inline void Read(T& var, const u32 addr) {
         LCD::Read(var, addr);
         break;
     default:
-        NGLOG_ERROR(HW_Memory, "Unknown Read{} @ {:#010X}", sizeof(var) * 8, addr);
+        NGLOG_ERROR(HW_Memory, "Unknown Read{} @ 0x{:08X}", sizeof(var) * 8, addr);
         break;
     }
 }
@@ -62,7 +62,7 @@ inline void Write(u32 addr, const T data) {
         LCD::Write(addr, data);
         break;
     default:
-        NGLOG_ERROR(HW_Memory, "Unknown Write{} {:#010X} @ {:#010X}", sizeof(data) * 8, data, addr);
+        NGLOG_ERROR(HW_Memory, "Unknown Write{} 0x{:08X} @ 0x{:08X}", sizeof(data) * 8, data, addr);
         break;
     }
 }
diff --git a/src/core/hw/lcd.cpp b/src/core/hw/lcd.cpp
index 7d0046bf3..e8525efde 100644
--- a/src/core/hw/lcd.cpp
+++ b/src/core/hw/lcd.cpp
@@ -20,7 +20,7 @@ inline void Read(T& var, const u32 raw_addr) {
 
     // Reads other than u32 are untested, so I'd rather have them abort than silently fail
     if (index >= 0x400 || !std::is_same<T, u32>::value) {
-        NGLOG_ERROR(HW_LCD, "Unknown Read{} @ {:#010X}", sizeof(var) * 8, addr);
+        NGLOG_ERROR(HW_LCD, "Unknown Read{} @ 0x{:08X}", sizeof(var) * 8, addr);
         return;
     }
 
@@ -34,7 +34,7 @@ inline void Write(u32 addr, const T data) {
 
     // Writes other than u32 are untested, so I'd rather have them abort than silently fail
     if (index >= 0x400 || !std::is_same<T, u32>::value) {
-        NGLOG_ERROR(HW_LCD, "Unknown Write{} {:#010X} @ {:#010X}", sizeof(data) * 8, data, addr);
+        NGLOG_ERROR(HW_LCD, "Unknown Write{} 0x{:08X} @ 0x{:08X}", sizeof(data) * 8, data, addr);
         return;
     }
 
diff --git a/src/core/loader/deconstructed_rom_directory.cpp b/src/core/loader/deconstructed_rom_directory.cpp
index 40a81025f..b01b2caf6 100644
--- a/src/core/loader/deconstructed_rom_directory.cpp
+++ b/src/core/loader/deconstructed_rom_directory.cpp
@@ -132,7 +132,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
         const VAddr load_addr = next_load_addr;
         next_load_addr = AppLoader_NSO::LoadModule(path, load_addr);
         if (next_load_addr) {
-            NGLOG_DEBUG(Loader, "loaded module {} @ {:#X}", module, load_addr);
+            NGLOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
         } else {
             next_load_addr = load_addr;
         }
@@ -176,8 +176,8 @@ ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(
     offset = 0;
     size = romfs_file->GetSize();
 
-    NGLOG_DEBUG(Loader, "RomFS offset:           {:#018X}", offset);
-    NGLOG_DEBUG(Loader, "RomFS size:             {:#018X}", size);
+    NGLOG_DEBUG(Loader, "RomFS offset:           0x{:016X}", offset);
+    NGLOG_DEBUG(Loader, "RomFS size:             0x{:016X}", size);
 
     // Reset read pointer
     file.Seek(0, SEEK_SET);
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 138883cc9..01be9e217 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -158,7 +158,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
 
     // Load module
     LoadModule(filepath, Memory::PROCESS_IMAGE_VADDR);
-    NGLOG_DEBUG(Loader, "loaded module {} @ {:#X}", filepath, Memory::PROCESS_IMAGE_VADDR);
+    NGLOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", filepath, Memory::PROCESS_IMAGE_VADDR);
 
     process->svc_access_mask.set();
     process->address_mappings = default_address_mappings;
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 5a27fa902..db8211463 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -168,7 +168,7 @@ T Read(const VAddr vaddr) {
     PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
     switch (type) {
     case PageType::Unmapped:
-        NGLOG_ERROR(HW_Memory, "Unmapped Read{} @ {:#010X}", sizeof(T) * 8, vaddr);
+        NGLOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
         return 0;
     case PageType::Memory:
         ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
@@ -200,8 +200,8 @@ void Write(const VAddr vaddr, const T data) {
     PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
     switch (type) {
     case PageType::Unmapped:
-        NGLOG_ERROR(HW_Memory, "Unmapped Write{} {:#010X} @ {:#018X}", sizeof(data) * 8, (u32)data,
-                    vaddr);
+        NGLOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                    static_cast<u32>(data), vaddr);
         return;
     case PageType::Memory:
         ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
@@ -250,7 +250,7 @@ u8* GetPointer(const VAddr vaddr) {
         return GetPointerFromVMA(vaddr);
     }
 
-    NGLOG_ERROR(HW_Memory, "Unknown GetPointer @ {:#018X}", vaddr);
+    NGLOG_ERROR(HW_Memory, "Unknown GetPointer @ 0x{:016X}", vaddr);
     return nullptr;
 }
 
@@ -287,12 +287,12 @@ u8* GetPhysicalPointer(PAddr address) {
         });
 
     if (area == std::end(memory_areas)) {
-        NGLOG_ERROR(HW_Memory, "Unknown GetPhysicalPointer @ {:#018X}", address);
+        NGLOG_ERROR(HW_Memory, "Unknown GetPhysicalPointer @ 0x{:016X}", address);
         return nullptr;
     }
 
     if (area->paddr_base == IO_AREA_PADDR) {
-        NGLOG_ERROR(HW_Memory, "MMIO mappings are not supported yet. phys_addr={:018X}", address);
+        NGLOG_ERROR(HW_Memory, "MMIO mappings are not supported yet. phys_addr={:016X}", address);
         return nullptr;
     }
 
@@ -476,7 +476,7 @@ void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_
         switch (page_table.attributes[page_index]) {
         case PageType::Unmapped: {
             NGLOG_ERROR(HW_Memory,
-                        "Unmapped ReadBlock @ {:#018X} (start address = {:#018X}, size = {})",
+                        "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                         current_vaddr, src_addr, size);
             std::memset(dest_buffer, 0, copy_amount);
             break;
@@ -540,7 +540,7 @@ void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const voi
         switch (page_table.attributes[page_index]) {
         case PageType::Unmapped: {
             NGLOG_ERROR(HW_Memory,
-                        "Unmapped WriteBlock @ {:#018X} (start address = {:#018X}, size = {})",
+                        "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                         current_vaddr, dest_addr, size);
             break;
         }
@@ -588,7 +588,7 @@ void ZeroBlock(const Kernel::Process& process, const VAddr dest_addr, const size
         switch (page_table.attributes[page_index]) {
         case PageType::Unmapped: {
             NGLOG_ERROR(HW_Memory,
-                        "Unmapped ZeroBlock @ {:#018X} (start address = {#:018X}, size = {})",
+                        "Unmapped ZeroBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                         current_vaddr, dest_addr, size);
             break;
         }
@@ -629,7 +629,7 @@ void CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
         switch (page_table.attributes[page_index]) {
         case PageType::Unmapped: {
             NGLOG_ERROR(HW_Memory,
-                        "Unmapped CopyBlock @ {:#018X} (start address = {:#018X}, size = {})",
+                        "Unmapped CopyBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                         current_vaddr, src_addr, size);
             ZeroBlock(process, dest_addr, copy_amount);
             break;
@@ -683,7 +683,7 @@ boost::optional<PAddr> TryVirtualToPhysicalAddress(const VAddr addr) {
 PAddr VirtualToPhysicalAddress(const VAddr addr) {
     auto paddr = TryVirtualToPhysicalAddress(addr);
     if (!paddr) {
-        NGLOG_ERROR(HW_Memory, "Unknown virtual address @ {:#018X}", addr);
+        NGLOG_ERROR(HW_Memory, "Unknown virtual address @ 0x{:016X}", addr);
         // To help with debugging, set bit on address so that it's obviously invalid.
         return addr | 0x80000000;
     }
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 9b3542e10..907236136 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -252,7 +252,7 @@ void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
             break;
         }
         default:
-            NGLOG_CRITICAL(HW_GPU, "Unimplemented shader index={}, enable={}, offset={:#010X}",
+            NGLOG_CRITICAL(HW_GPU, "Unimplemented shader index={}, enable={}, offset=0x{:08X}",
                            index, shader_config.enable.Value(), shader_config.offset);
             UNREACHABLE();
         }