Fix OSUTF8to32

Restore C++17 compatibility
Fix compile errors/typos; update logvisor
2025-12-08 13:14:59 +00:00 · 2021-07-10 19:40:39 -07:00 · 2021-06-30 17:00:42 -04:00 · 2021-06-30 16:22:50 -04:00 · 2021-06-30 13:47:10 -04:00 · 2021-06-27 10:56:43 -07:00
29 changed files with 4018 additions and 630 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,7 @@ version.h
 .DS_Store
 *.autosave
 docs/*
+.idea/
+cmake-build-*
+build/
+out/
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,4 @@
 [submodule "logvisor"]
 	path = logvisor
 	url = ../logvisor.git
+	branch = master
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,20 +1,64 @@
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
  cmake_minimum_required(VERSION 3.10 FATAL_ERROR) # because of c++17
  project(nod VERSION 0.1)
-  if (NOT MSVC)
-    set(CMAKE_CXX_STANDARD 20)
+
+  if (MSVC)
+    # Shaddup MSVC
+    add_compile_definitions(UNICODE=1 _UNICODE=1 __SSE__=1
+        _CRT_SECURE_NO_WARNINGS=1 D_SCL_SECURE_NO_WARNINGS=1
+        _SCL_SECURE_NO_DEPRECATE=1 _CRT_NONSTDC_NO_WARNINGS=1
+        _ENABLE_EXTENDED_ALIGNED_STORAGE=1 NOMINMAX=1)
+    add_compile_options(/IGNORE:4221 /wd4018 /wd4800 /wd4005 /wd4311 /wd4068
+        /wd4267 /wd4244 /wd4200 /wd4305 /wd4067 /wd4146 /wd4309 /wd4805 /utf-8 ${VS_OPTIONS})
+
+    add_compile_options(
+      # Disable exceptions
+      $<$<COMPILE_LANGUAGE:CXX>:/EHsc->
+
+      # Disable RTTI
+      $<$<COMPILE_LANGUAGE:CXX>:/GR->
+
+      # Enforce various standards compliant behavior.
+      $<$<COMPILE_LANGUAGE:CXX>:/permissive->
+
+      # Enable standard volatile semantics.
+      $<$<COMPILE_LANGUAGE:CXX>:/volatile:iso>
+
+      # Reports the proper value for the __cplusplus preprocessor macro.
+      $<$<COMPILE_LANGUAGE:CXX>:/Zc:__cplusplus>
+
+      # Use latest C++ standard.
+      $<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>
+    )
+    add_compile_definitions(FMT_EXCEPTIONS=0 _HAS_EXCEPTIONS=0)
+
+    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+      # Flags for MSVC (not clang-cl)
+      add_compile_options(
+        # Allow constexpr variables to have explicit external linkage.
+        $<$<COMPILE_LANGUAGE:CXX>:/Zc:externConstexpr>
+
+        # Assume that new throws exceptions, allowing better code generation.
+        $<$<COMPILE_LANGUAGE:CXX>:/Zc:throwingNew>
+
+        # Link-time Code Generation for Release builds
+        $<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>>:/GL>
+      )
+
+      # Link-time Code Generation for Release builds
+      set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "/LTCG")
+      set(CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "/LTCG")
+      set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/RELEASE /LTCG /OPT:REF /OPT:ICF /INCREMENTAL:NO")
+      set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "/DEBUG /RELEASE /LTCG /OPT:REF /OPT:ICF /INCREMENTAL:NO /DEBUGTYPE:cv,fixup")
+    endif()
+  else()
+    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
  endif()
 endif()

 include (CMakePackageConfigHelpers)

-if (MSVC)
-  # Shaddup MSVC
-  add_definitions(-DUNICODE=1 -D_UNICODE=1 -D__SSE__=1 -D_CRT_SECURE_NO_WARNINGS=1 -DD_SCL_SECURE_NO_WARNINGS=1
-      /IGNORE:4221 /wd4018 /wd4800 /wd4005 /wd4311 /wd4267 /wd4244 /wd4200 /wd4305 /wd4067 /wd4146 ${VS_DEFINES})
-endif()
-
 if (NOT TARGET logvisor)
  add_subdirectory(logvisor)
 endif()
@@ -22,6 +66,7 @@ endif()
 add_subdirectory(lib)
 add_subdirectory(driver)

+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 set(version_config_file "${PROJECT_BINARY_DIR}/nodConfigVersion.cmake")
 set(config_file "${PROJECT_BINARY_DIR}/nodConfig.cmake")
 set(config_install_dir "lib/cmake/nod")
@@ -51,3 +96,4 @@ install(
    FILES "${config_file}" "${version_config_file}"
    DESTINATION ${config_install_dir}
 )
+endif()
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ a content pipeline using the `nod::DiscBuilderBase` interface.
 ```cpp
 /* Sample logging lambda for progress feedback */
 size_t lastIdx = -1;
-auto progFunc = [&](size_t idx, const nod::SystemString& name, size_t bytes)
+auto progFunc = [&](size_t idx, const std::string& name, size_t bytes)
 {
    if (idx != lastIdx)
    {
--- a/driver/CMakeLists.txt
+++ b/driver/CMakeLists.txt
@@ -3,9 +3,11 @@ add_executable(nodtool main.cpp)
 target_link_libraries(nodtool nod logvisor)
 if (NOT WIN32)
    target_link_libraries(nodtool pthread)
-    if(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+    if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
        target_link_libraries(nodtool execinfo)
-    else()
+    else ()
        target_link_libraries(nodtool dl)
-    endif()
-endif()
+    endif ()
+else ()
+    target_sources(nodtool PRIVATE app.manifest)
+endif ()
--- a/driver/app.manifest
+++ b/driver/app.manifest
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity type="win32" name="..." version="6.0.0.0"/>
+  <application>
+    <windowsSettings>
+      <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
+    </windowsSettings>
+  </application>
+</assembly>
--- a/driver/main.cpp
+++ b/driver/main.cpp
@@ -1,7 +1,12 @@
+#include <array>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#if _WIN32
+#include <fcntl.h>
+#include <io.h>
+#endif

 #include <logvisor/logvisor.hpp>

@@ -12,214 +17,294 @@

 static void printHelp() {
  fmt::print(stderr, FMT_STRING(
-          "Usage:\n"
-          "  nodtool extract [-f] <image-in> [<dir-out>]\n"
-          "  nodtool makegcn <fsroot-in> [<image-out>]\n"
-          "  nodtool makewii <fsroot-in> [<image-out>]\n"
-          "  nodtool mergegcn <fsroot-in> <image-in> [<image-out>]\n"
-          "  nodtool mergewii <fsroot-in> <image-in> [<image-out>]\n"));
+    "Usage:\n"
+    "  nodtool extract [options] <image-in> [<dir-out>]\n"
+    "  nodtool makegcn [options] <fsroot-in> [<image-out>]\n"
+    "  nodtool makewii [options] <fsroot-in> [<image-out>]\n"
+    "  nodtool mergegcn [options] <fsroot-in> <image-in> [<image-out>]\n"
+    "  nodtool mergewii [options] <fsroot-in> <image-in> [<image-out>]\n"
+    "Options:\n"
+    "  -f         Force (extract only)\n"
+    "  -v         Verbose details (extract only).\n"));
 }

-#if NOD_UCS2
-#ifdef strcasecmp
-#undef strcasecmp
-#endif
-#define strcasecmp _wcsicmp
+#if _MSC_VER
+#include <nowide/args.hpp>
+
 #define PRISize "Iu"
-int wmain(int argc, wchar_t* argv[])
+int main(int argc, char* argv[]) {
+  nowide::args _(argc, argv);
 #else
 #define PRISize "zu"
-int main(int argc, char* argv[])
+int main(int argc, char* argv[]) {
 #endif
-{
-  if (argc < 3 || (!strcasecmp(argv[1], _SYS_STR("makegcn")) && argc < 3) ||
-      (!strcasecmp(argv[1], _SYS_STR("makewii")) && argc < 3) ||
-      (!strcasecmp(argv[1], _SYS_STR("mergegcn")) && argc < 4) ||
-      (!strcasecmp(argv[1], _SYS_STR("mergewii")) && argc < 4)) {
-    printHelp();
-    return 1;
-  }
-
  /* Enable logging to console */
  logvisor::RegisterStandardExceptions();
  logvisor::RegisterConsoleLogger();

+  int argidx = 1;
+  std::string errand;
  bool verbose = false;
  nod::ExtractionContext ctx = {true, [&](std::string_view str, float c) {
                                  if (verbose)
-                                    fmt::print(stderr, FMT_STRING("Current node: {}, Extraction {:g}% Complete\n"), str,
-                                               c * 100.f);
+                                    fmt::print(stderr, FMT_STRING("Current node: {}, Extraction {:g}% Complete\n"),
+                                               str, c * 100.f);
                                }};
-  const nod::SystemChar* inDir = nullptr;
-  const nod::SystemChar* outDir = _SYS_STR(".");
-
-  for (int a = 2; a < argc; ++a) {
-    if (argv[a][0] == '-' && argv[a][1] == 'f')
+  while (argidx < argc) {
+    if (!nod::StrCaseCmp(argv[argidx], "-f")) {
      ctx.force = true;
-    else if (argv[a][0] == '-' && argv[a][1] == 'v')
+      ++argidx;
+      continue;
+    } else if (!nod::StrCaseCmp(argv[argidx], "-v")) {
      verbose = true;
-
-    else if (!inDir)
-      inDir = argv[a];
-    else
-      outDir = argv[a];
+      ++argidx;
+      continue;
+    } else if (errand.empty()) {
+      errand = argv[argidx];
+      ++argidx;
+      continue;
+    } else {
+      break;
+    }
  }

-  auto progFunc = [&](float prog, nod::SystemStringView name, size_t bytes) {
-    fmt::print(FMT_STRING(_SYS_STR("\r                                                                      ")));
+  if (errand.empty()) {
+    printHelp();
+    return 1;
+  }
+
+  auto progFunc = [&](float prog, std::string_view name, size_t bytes) {
+    fmt::print(FMT_STRING("\r                                                                      "));
    if (bytes != SIZE_MAX)
-      fmt::print(FMT_STRING(_SYS_STR("\r{:g}% {} {} B")), prog * 100.f, name, bytes);
+      fmt::print(FMT_STRING("\r{:g}% {} {} B"), prog * 100.f, name, bytes);
    else
-      fmt::print(FMT_STRING(_SYS_STR("\r{:g}% {}")), prog * 100.f, name);
+      fmt::print(FMT_STRING("\r{:g}% {}"), prog * 100.f, name);
    fflush(stdout);
  };

-  if (!strcasecmp(argv[1], _SYS_STR("extract"))) {
+  if (errand == "extract") {
+    std::string imageIn;
+    std::string dirOut;
+    while (argidx < argc) {
+      if (imageIn.empty()) {
+        imageIn = argv[argidx];
+        ++argidx;
+        continue;
+      } else if (dirOut.empty()) {
+        dirOut = argv[argidx];
+        ++argidx;
+        continue;
+      } else {
+        printHelp();
+        return 1;
+      }
+    }
+    if (dirOut.empty())
+      dirOut = ".";
+
    bool isWii;
-    std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(inDir, isWii);
+    std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(imageIn, isWii);
    if (!disc)
      return 1;

-    nod::Mkdir(outDir, 0755);
+    nod::Mkdir(dirOut.c_str(), 0755);

    nod::IPartition* dataPart = disc->getDataPartition();
    if (!dataPart)
      return 1;

-    if (!dataPart->extractToDirectory(outDir, ctx))
+    if (!dataPart->extractToDirectory(dirOut, ctx))
      return 1;
-  } else if (!strcasecmp(argv[1], _SYS_STR("makegcn"))) {
+  } else if (errand == "makegcn") {
+    std::string fsrootIn;
+    std::string imageOut;
+    while (argidx < argc) {
+      if (fsrootIn.empty()) {
+        fsrootIn = argv[argidx];
+        ++argidx;
+        continue;
+      } else if (imageOut.empty()) {
+        imageOut = argv[argidx];
+        ++argidx;
+        continue;
+      } else {
+        printHelp();
+        return 1;
+      }
+    }
+    if (imageOut.empty())
+      imageOut = fsrootIn + ".gcm";
+
    /* Pre-validate path */
    nod::Sstat theStat;
-    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as directory")), argv[2]);
+    if (nod::Stat(fsrootIn.c_str(), &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to stat {} as directory"), fsrootIn);
      return 1;
    }

-    if (!nod::DiscBuilderGCN::CalculateTotalSizeRequired(argv[2]))
+    if (!nod::DiscBuilderGCN::CalculateTotalSizeRequired(fsrootIn))
      return 1;

    nod::EBuildResult ret;

-    if (argc < 4) {
-      nod::SystemString outPath(argv[2]);
-      outPath.append(_SYS_STR(".iso"));
-      nod::DiscBuilderGCN b(outPath, progFunc);
-      ret = b.buildFromDirectory(argv[2]);
-    } else {
-      nod::DiscBuilderGCN b(argv[3], progFunc);
-      ret = b.buildFromDirectory(argv[2]);
-    }
+    nod::DiscBuilderGCN b(imageOut, progFunc);
+    ret = b.buildFromDirectory(fsrootIn);

    fmt::print(FMT_STRING("\n"));
    if (ret != nod::EBuildResult::Success)
      return 1;
-  } else if (!strcasecmp(argv[1], _SYS_STR("makewii"))) {
+  } else if (errand == "makewii") {
+    std::string fsrootIn;
+    std::string imageOut;
+    while (argidx < argc) {
+      if (fsrootIn.empty()) {
+        fsrootIn = argv[argidx];
+        ++argidx;
+        continue;
+      } else if (imageOut.empty()) {
+        imageOut = argv[argidx];
+        ++argidx;
+        continue;
+      } else {
+        printHelp();
+        return 1;
+      }
+    }
+    if (imageOut.empty())
+      imageOut = fsrootIn + ".iso";
+
    /* Pre-validate path */
    nod::Sstat theStat;
-    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as directory")), argv[4]);
+    if (nod::Stat(fsrootIn.c_str(), &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to stat {} as directory"), fsrootIn);
      return 1;
    }

    bool dual = false;
-    if (!nod::DiscBuilderWii::CalculateTotalSizeRequired(argv[2], dual))
+    if (!nod::DiscBuilderWii::CalculateTotalSizeRequired(fsrootIn, dual))
      return 1;

    nod::EBuildResult ret;

-    if (argc < 4) {
-      nod::SystemString outPath(argv[2]);
-      outPath.append(_SYS_STR(".iso"));
-      nod::DiscBuilderWii b(outPath.c_str(), dual, progFunc);
-      ret = b.buildFromDirectory(argv[2]);
-    } else {
-      nod::DiscBuilderWii b(argv[3], dual, progFunc);
-      ret = b.buildFromDirectory(argv[2]);
-    }
+    nod::DiscBuilderWii b(imageOut, dual, progFunc);
+    ret = b.buildFromDirectory(fsrootIn);

    fmt::print(FMT_STRING("\n"));
    if (ret != nod::EBuildResult::Success)
      return 1;
-  } else if (!strcasecmp(argv[1], _SYS_STR("mergegcn"))) {
+  } else if (errand == "mergegcn") {
+    std::string fsrootIn;
+    std::string imageIn;
+    std::string imageOut;
+    while (argidx < argc) {
+      if (fsrootIn.empty()) {
+        fsrootIn = argv[argidx];
+        ++argidx;
+        continue;
+      } else if (imageIn.empty()) {
+        imageIn = argv[argidx];
+        ++argidx;
+        continue;
+      } else if (imageOut.empty()) {
+        imageOut = argv[argidx];
+        ++argidx;
+        continue;
+      } else {
+        printHelp();
+        return 1;
+      }
+    }
+    if (imageOut.empty())
+      imageOut = fsrootIn + ".gcm";
+
    /* Pre-validate paths */
    nod::Sstat theStat;
-    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as directory")), argv[2]);
+    if (nod::Stat(fsrootIn.c_str(), &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to stat {} as directory"), fsrootIn);
      return 1;
    }
-    if (nod::Stat(argv[3], &theStat) || !S_ISREG(theStat.st_mode)) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as file")), argv[3]);
+    if (nod::Stat(imageIn.c_str(), &theStat) || !S_ISREG(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to stat {} as file"), imageIn);
      return 1;
    }

    bool isWii;
-    std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(argv[3], isWii);
+    std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(imageIn, isWii);
    if (!disc) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open image {}")), argv[3]);
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to open image {}"), imageIn);
      return 1;
    }
    if (isWii) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Wii images should be merged with 'mergewii'")));
+      nod::LogModule.report(logvisor::Error, FMT_STRING("Wii images should be merged with 'mergewii'"));
      return 1;
    }

-    if (!nod::DiscMergerGCN::CalculateTotalSizeRequired(static_cast<nod::DiscGCN&>(*disc), argv[2]))
+    if (!nod::DiscMergerGCN::CalculateTotalSizeRequired(static_cast<nod::DiscGCN&>(*disc), fsrootIn))
      return 1;

    nod::EBuildResult ret;

-    if (argc < 5) {
-      nod::SystemString outPath(argv[2]);
-      outPath.append(_SYS_STR(".iso"));
-      nod::DiscMergerGCN b(outPath.c_str(), static_cast<nod::DiscGCN&>(*disc), progFunc);
-      ret = b.mergeFromDirectory(argv[2]);
-    } else {
-      nod::DiscMergerGCN b(argv[4], static_cast<nod::DiscGCN&>(*disc), progFunc);
-      ret = b.mergeFromDirectory(argv[2]);
-    }
+    nod::DiscMergerGCN b(imageOut, static_cast<nod::DiscGCN&>(*disc), progFunc);
+    ret = b.mergeFromDirectory(fsrootIn);

    fmt::print(FMT_STRING("\n"));
    if (ret != nod::EBuildResult::Success)
      return 1;
-  } else if (!strcasecmp(argv[1], _SYS_STR("mergewii"))) {
+  } else if (errand == "mergewii") {
+    std::string fsrootIn;
+    std::string imageIn;
+    std::string imageOut;
+    while (argidx < argc) {
+      if (fsrootIn.empty()) {
+        fsrootIn = argv[argidx];
+        ++argidx;
+        continue;
+      } else if (imageIn.empty()) {
+        imageIn = argv[argidx];
+        ++argidx;
+        continue;
+      } else if (imageOut.empty()) {
+        imageOut = argv[argidx];
+        ++argidx;
+        continue;
+      } else {
+        printHelp();
+        return 1;
+      }
+    }
+    if (imageOut.empty())
+      imageOut = fsrootIn + ".iso";
+
    /* Pre-validate paths */
    nod::Sstat theStat;
-    if (nod::Stat(argv[2], &theStat) || !S_ISDIR(theStat.st_mode)) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as directory")), argv[2]);
+    if (nod::Stat(fsrootIn.c_str(), &theStat) || !S_ISDIR(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to stat {} as directory"), fsrootIn);
      return 1;
    }
-    if (nod::Stat(argv[3], &theStat) || !S_ISREG(theStat.st_mode)) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {} as file")), argv[3]);
+    if (nod::Stat(imageIn.c_str(), &theStat) || !S_ISREG(theStat.st_mode)) {
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to stat {} as file"), imageIn);
      return 1;
    }

    bool isWii;
-    std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(argv[3], isWii);
+    std::unique_ptr<nod::DiscBase> disc = nod::OpenDiscFromImage(imageIn, isWii);
    if (!disc) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open image {}")), argv[3]);
+      nod::LogModule.report(logvisor::Error, FMT_STRING("unable to open image {}"), argv[3]);
      return 1;
    }
    if (!isWii) {
-      nod::LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("GameCube images should be merged with 'mergegcn'")));
+      nod::LogModule.report(logvisor::Error, FMT_STRING("GameCube images should be merged with 'mergegcn'"));
      return 1;
    }

    bool dual = false;
-    if (!nod::DiscMergerWii::CalculateTotalSizeRequired(static_cast<nod::DiscWii&>(*disc), argv[2], dual))
+    if (!nod::DiscMergerWii::CalculateTotalSizeRequired(static_cast<nod::DiscWii&>(*disc), fsrootIn, dual))
      return 1;

    nod::EBuildResult ret;

-    if (argc < 5) {
-      nod::SystemString outPath(argv[2]);
-      outPath.append(_SYS_STR(".iso"));
-      nod::DiscMergerWii b(outPath.c_str(), static_cast<nod::DiscWii&>(*disc), dual, progFunc);
-      ret = b.mergeFromDirectory(argv[2]);
-    } else {
-      nod::DiscMergerWii b(argv[4], static_cast<nod::DiscWii&>(*disc), dual, progFunc);
-      ret = b.mergeFromDirectory(argv[2]);
-    }
+    nod::DiscMergerWii b(imageOut, static_cast<nod::DiscWii&>(*disc), dual, progFunc);
+    ret = b.mergeFromDirectory(fsrootIn);

    fmt::print(FMT_STRING("\n"));
    if (ret != nod::EBuildResult::Success)
@@ -229,6 +314,6 @@ int main(int argc, char* argv[])
    return 1;
  }

-  nod::LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("Success!")));
+  nod::LogModule.report(logvisor::Info, FMT_STRING("Success!"));
  return 0;
 }
--- a/include/nod/DirectoryEnumerator.hpp
+++ b/include/nod/DirectoryEnumerator.hpp
@@ -9,46 +9,44 @@

 namespace nod {

+/**
+ * @brief Case-insensitive comparator for std::map sorting
+ */
 struct CaseInsensitiveCompare {
+  // Allow heterogeneous lookup with maps that use this comparator.
+  using is_transparent = void;
+
  bool operator()(std::string_view lhs, std::string_view rhs) const {
    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), [](char lhs, char rhs) {
      return std::tolower(static_cast<unsigned char>(lhs)) < std::tolower(static_cast<unsigned char>(rhs));
    });
  }
-
-#if _WIN32
-  bool operator()(std::wstring_view lhs, std::wstring_view rhs) const {
-    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), [](wchar_t lhs, wchar_t rhs) {
-      return std::towlower(lhs) < std::towlower(rhs);
-    });
-  }
-#endif
 };

 class DirectoryEnumerator {
 public:
  enum class Mode { Native, DirsSorted, FilesSorted, DirsThenFilesSorted };
  struct Entry {
-    SystemString m_path;
-    SystemString m_name;
+    std::string m_path;
+    std::string m_name;
    size_t m_fileSz;
    bool m_isDir;

-    Entry(const SystemString& path, const SystemChar* name, size_t sz, bool isDir)
-    : m_path(path), m_name(name), m_fileSz(sz), m_isDir(isDir) {}
+    Entry(std::string path, std::string name, size_t sz, bool isDir)
+    : m_path(std::move(path)), m_name(std::move(name)), m_fileSz(sz), m_isDir(isDir) {}
  };

 private:
  std::vector<Entry> m_entries;

 public:
-  DirectoryEnumerator(SystemStringView path, Mode mode = Mode::DirsThenFilesSorted, bool sizeSort = false,
+  DirectoryEnumerator(std::string_view path, Mode mode = Mode::DirsThenFilesSorted, bool sizeSort = false,
                      bool reverse = false, bool noHidden = false);

-  operator bool() const { return m_entries.size() != 0; }
-  size_t size() const { return m_entries.size(); }
-  std::vector<Entry>::const_iterator begin() const { return m_entries.cbegin(); }
-  std::vector<Entry>::const_iterator end() const { return m_entries.cend(); }
+  explicit operator bool() const { return !m_entries.empty(); }
+  [[nodiscard]] size_t size() const { return m_entries.size(); }
+  [[nodiscard]] std::vector<Entry>::const_iterator begin() const { return m_entries.cbegin(); }
+  [[nodiscard]] std::vector<Entry>::const_iterator end() const { return m_entries.cend(); }
 };

 } // namespace nod
--- a/include/nod/DiscBase.hpp
+++ b/include/nod/DiscBase.hpp
@@ -12,16 +12,17 @@

 #include "nod/IDiscIO.hpp"
 #include "nod/IFileIO.hpp"
+#include "nod/OSUTF.h"
 #include "nod/Util.hpp"

 namespace nod {

-using FProgress = std::function<void(float totalProg, SystemStringView fileName, size_t fileBytesXfered)>;
+using FProgress = std::function<void(float totalProg, std::string_view fileName, size_t fileBytesXfered)>;

 enum class EBuildResult { Success, Failed, DiskFull };

 enum class PartitionKind : uint32_t { Data, Update, Channel };
-const SystemChar* getKindString(PartitionKind kind);
+const char* getKindString(PartitionKind kind);

 class FSTNode {
  uint32_t typeAndNameOffset;
@@ -236,7 +237,7 @@ public:
    return end();
  }

-  bool extractToDirectory(SystemStringView basePath, const ExtractionContext& ctx) const;
+  bool extractToDirectory(std::string_view basePath, const ExtractionContext& ctx) const;
 };

 class IPartition {
@@ -307,7 +308,7 @@ public:
  }
  const Node& getFSTRoot() const { return m_nodes[0]; }
  Node& getFSTRoot() { return m_nodes[0]; }
-  bool extractToDirectory(SystemStringView path, const ExtractionContext& ctx);
+  bool extractToDirectory(std::string_view path, const ExtractionContext& ctx);

  uint64_t getDOLSize() const { return m_dolSz; }
  std::unique_ptr<uint8_t[]> getDOLBuf() const {
@@ -333,8 +334,8 @@ public:
  size_t getNodeCount() const { return m_nodes.size(); }
  const Header& getHeader() const { return m_header; }
  const BI2Header& getBI2() const { return m_bi2Header; }
-  virtual bool extractCryptoFiles(SystemStringView path, const ExtractionContext& ctx) const { return true; }
-  bool extractSysFiles(SystemStringView path, const ExtractionContext& ctx) const;
+  virtual bool extractCryptoFiles(std::string_view path, const ExtractionContext& ctx) const { return true; }
+  bool extractSysFiles(std::string_view path, const ExtractionContext& ctx) const;
 };

 class DiscBase {
@@ -372,12 +373,12 @@ public:
    return nullptr;
  }

-  void extractToDirectory(SystemStringView path, const ExtractionContext& ctx) {
+  void extractToDirectory(std::string_view path, const ExtractionContext& ctx) {
    for (std::unique_ptr<IPartition>& part : m_partitions)
      part->extractToDirectory(path, ctx);
  }

-  virtual bool extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const = 0;
+  virtual bool extractDiscHeaderFiles(std::string_view path, const ExtractionContext& ctx) const = 0;
 };

 class DiscBuilderBase {
@@ -389,30 +390,30 @@ public:
    virtual ~PartitionBuilderBase() = default;

  protected:
-    std::unordered_map<SystemString, std::pair<uint64_t, uint64_t>> m_fileOffsetsSizes;
+    std::unordered_map<std::string, std::pair<uint64_t, uint64_t>> m_fileOffsetsSizes;
    std::vector<FSTNode> m_buildNodes;
    std::vector<std::string> m_buildNames;
    size_t m_buildNameOff = 0;
    virtual uint64_t userAllocate(uint64_t reqSz, IPartWriteStream& ws) = 0;
    virtual uint32_t packOffset(uint64_t offset) const = 0;

-    void recursiveBuildNodesPre(SystemStringView dirIn);
-    bool recursiveBuildNodes(IPartWriteStream& ws, bool system, SystemStringView dirIn);
+    void recursiveBuildNodesPre(std::string_view dirIn);
+    bool recursiveBuildNodes(IPartWriteStream& ws, bool system, std::string_view dirIn);

-    bool recursiveBuildFST(SystemStringView dirIn, std::function<void(void)> incParents, size_t parentDirIdx);
+    bool recursiveBuildFST(std::string_view dirIn, std::function<void(void)> incParents, size_t parentDirIdx);

-    void recursiveMergeNodesPre(const Node* nodeIn, SystemStringView dirIn);
-    bool recursiveMergeNodes(IPartWriteStream& ws, bool system, const Node* nodeIn, SystemStringView dirIn,
-                             SystemStringView keyPath);
-    bool recursiveMergeFST(const Node* nodeIn, SystemStringView dirIn, std::function<void(void)> incParents,
-                           SystemStringView keyPath);
+    void recursiveMergeNodesPre(const Node* nodeIn, std::string_view dirIn);
+    bool recursiveMergeNodes(IPartWriteStream& ws, bool system, const Node* nodeIn, std::string_view dirIn,
+                             std::string_view keyPath);
+    bool recursiveMergeFST(const Node* nodeIn, std::string_view dirIn, std::function<void(void)> incParents,
+                           size_t parentDirIdx, std::string_view keyPath);

-    static bool RecursiveCalculateTotalSize(uint64_t& totalSz, const Node* nodeIn, SystemStringView dirIn);
+    static bool RecursiveCalculateTotalSize(uint64_t& totalSz, const Node* nodeIn, std::string_view dirIn);

-    void addBuildName(SystemStringView str) {
-      SystemUTF8Conv utf8View(str);
-      m_buildNames.emplace_back(utf8View.utf8_str());
-      m_buildNameOff += str.size() + 1;
+    void addBuildName(std::string_view str) {
+      UTF8ToSJIS nameView(str);
+      m_buildNames.emplace_back(nameView.str());
+      m_buildNameOff += nameView.str().size() + 1;
    }

    DiscBuilderBase& m_parent;
@@ -425,14 +426,14 @@ public:
    PartitionBuilderBase(DiscBuilderBase& parent, PartitionKind kind, bool isWii)
    : m_parent(parent), m_kind(kind), m_isWii(isWii) {}
    virtual std::unique_ptr<IPartWriteStream> beginWriteStream(uint64_t offset) = 0;
-    bool buildFromDirectory(IPartWriteStream& ws, SystemStringView dirIn);
-    static std::optional<uint64_t> CalculateTotalSizeBuild(SystemStringView dirIn, PartitionKind kind, bool isWii);
-    bool mergeFromDirectory(IPartWriteStream& ws, const IPartition* partIn, SystemStringView dirIn);
-    static std::optional<uint64_t> CalculateTotalSizeMerge(const IPartition* partIn, SystemStringView dirIn);
+    bool buildFromDirectory(IPartWriteStream& ws, std::string_view dirIn);
+    static std::optional<uint64_t> CalculateTotalSizeBuild(std::string_view dirIn, PartitionKind kind, bool isWii);
+    bool mergeFromDirectory(IPartWriteStream& ws, const IPartition* partIn, std::string_view dirIn);
+    static std::optional<uint64_t> CalculateTotalSizeMerge(const IPartition* partIn, std::string_view dirIn);
  };

 protected:
-  SystemString m_outPath;
+  std::string m_outPath;
  std::unique_ptr<IFileIO> m_fileIO;
  std::vector<std::unique_ptr<PartitionBuilderBase>> m_partitions;
  int64_t m_discCapacity;
@@ -455,7 +456,7 @@ public:
  }

  virtual ~DiscBuilderBase() = default;
-  DiscBuilderBase(SystemStringView outPath, int64_t discCapacity, FProgress progressCB)
+  DiscBuilderBase(std::string_view outPath, int64_t discCapacity, FProgress progressCB)
  : m_outPath(outPath)
  , m_fileIO(NewFileIO(outPath, discCapacity))
  , m_discCapacity(discCapacity)
--- a/include/nod/DiscGCN.hpp
+++ b/include/nod/DiscGCN.hpp
@@ -7,20 +7,20 @@ class DiscBuilderGCN;

 class DiscGCN : public DiscBase {
  friend class DiscMergerGCN;
-  DiscBuilderGCN makeMergeBuilder(SystemStringView outPath, FProgress progressCB);
+  DiscBuilderGCN makeMergeBuilder(std::string_view outPath, FProgress progressCB);

 public:
  DiscGCN(std::unique_ptr<IDiscIO>&& dio, bool& err);
-  bool extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const override;
+  bool extractDiscHeaderFiles(std::string_view path, const ExtractionContext& ctx) const override;
 };

 class DiscBuilderGCN : public DiscBuilderBase {
  friend class DiscMergerGCN;

 public:
-  DiscBuilderGCN(SystemStringView outPath, FProgress progressCB);
-  EBuildResult buildFromDirectory(SystemStringView dirIn);
-  static std::optional<uint64_t> CalculateTotalSizeRequired(SystemStringView dirIn);
+  DiscBuilderGCN(std::string_view outPath, FProgress progressCB);
+  EBuildResult buildFromDirectory(std::string_view dirIn);
+  static std::optional<uint64_t> CalculateTotalSizeRequired(std::string_view dirIn);
 };

 class DiscMergerGCN {
@@ -28,9 +28,9 @@ class DiscMergerGCN {
  DiscBuilderGCN m_builder;

 public:
-  DiscMergerGCN(SystemStringView outPath, DiscGCN& sourceDisc, FProgress progressCB);
-  EBuildResult mergeFromDirectory(SystemStringView dirIn);
-  static std::optional<uint64_t> CalculateTotalSizeRequired(DiscGCN& sourceDisc, SystemStringView dirIn);
+  DiscMergerGCN(std::string_view outPath, DiscGCN& sourceDisc, FProgress progressCB);
+  EBuildResult mergeFromDirectory(std::string_view dirIn);
+  static std::optional<uint64_t> CalculateTotalSizeRequired(DiscGCN& sourceDisc, std::string_view dirIn);
 };

 } // namespace nod
--- a/include/nod/DiscWii.hpp
+++ b/include/nod/DiscWii.hpp
@@ -8,15 +8,15 @@ class DiscBuilderWii;
 class DiscWii : public DiscBase {
 public:
  DiscWii(std::unique_ptr<IDiscIO>&& dio, bool& err);
-  DiscBuilderWii makeMergeBuilder(SystemStringView outPath, bool dualLayer, FProgress progressCB);
-  bool extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const override;
+  DiscBuilderWii makeMergeBuilder(std::string_view outPath, bool dualLayer, FProgress progressCB);
+  bool extractDiscHeaderFiles(std::string_view path, const ExtractionContext& ctx) const override;
 };

 class DiscBuilderWii : public DiscBuilderBase {
 public:
-  DiscBuilderWii(SystemStringView outPath, bool dualLayer, FProgress progressCB);
-  EBuildResult buildFromDirectory(SystemStringView dirIn);
-  static std::optional<uint64_t> CalculateTotalSizeRequired(SystemStringView dirIn, bool& dualLayer);
+  DiscBuilderWii(std::string_view outPath, bool dualLayer, FProgress progressCB);
+  EBuildResult buildFromDirectory(std::string_view dirIn);
+  static std::optional<uint64_t> CalculateTotalSizeRequired(std::string_view dirIn, bool& dualLayer);
 };

 class DiscMergerWii {
@@ -24,9 +24,9 @@ class DiscMergerWii {
  DiscBuilderWii m_builder;

 public:
-  DiscMergerWii(SystemStringView outPath, DiscWii& sourceDisc, bool dualLayer, FProgress progressCB);
-  EBuildResult mergeFromDirectory(SystemStringView dirIn);
-  static std::optional<uint64_t> CalculateTotalSizeRequired(DiscWii& sourceDisc, SystemStringView dirIn, bool& dualLayer);
+  DiscMergerWii(std::string_view outPath, DiscWii& sourceDisc, bool dualLayer, FProgress progressCB);
+  EBuildResult mergeFromDirectory(std::string_view dirIn);
+  static std::optional<uint64_t> CalculateTotalSizeRequired(DiscWii& sourceDisc, std::string_view dirIn, bool& dualLayer);
 };

 } // namespace nod
--- a/include/nod/IFileIO.hpp
+++ b/include/nod/IFileIO.hpp
@@ -69,6 +69,6 @@ public:
  virtual std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const = 0;
 };

-std::unique_ptr<IFileIO> NewFileIO(SystemStringView path, int64_t maxWriteSize = -1);
+std::unique_ptr<IFileIO> NewFileIO(std::string_view path, int64_t maxWriteSize = -1);

 } // namespace nod
--- a/include/nod/OSUTF.h
+++ b/include/nod/OSUTF.h
@@ -0,0 +1,113 @@
+#ifdef __cplusplus
+#include <array>
+#include <cstdint>
+
+#if !__cpp_char8_t
+using char8_t = uint8_t;
+#endif
+
+#define OS_CONSTEXPR constexpr
+
+extern "C" {
+#else
+#include <stdint.h>
+#include <stdbool.h>
+
+#define OS_CONSTEXPR
+
+typedef uint8_t char8_t;
+typedef uint16_t char16_t;
+typedef uint32_t char32_t;
+#endif
+
+OS_CONSTEXPR inline bool IsSjisLeadByte(char8_t c) { return (c > 0x80 && c < 0xa0) || (c > 0xdf && c < 0xfd); }
+
+OS_CONSTEXPR inline bool IsSjisTrailByte(char8_t c) { return c > 0x3f && c < 0xfd && c != 0x7f; }
+
+char32_t OSSJISToUTF32(char16_t sjis);
+
+char16_t OSUTF32ToSJIS(char32_t utf32);
+
+char8_t OSUTF32ToAnsi(char32_t utf32);
+
+char16_t* OSUTF32To16(char32_t utf32, char16_t* utf16);
+
+char8_t* OSUTF32To8(char32_t utf32, char8_t* utf8);
+
+const char16_t* OSUTF16To32(const char16_t* utf16, char32_t* utf32);
+
+const char8_t* OSUTF8To32(const char8_t* utf8, char32_t* utf32);
+
+#ifdef __cplusplus
+}
+
+class SJISToUTF8 {
+private:
+  std::string out;
+
+public:
+  SJISToUTF8(std::string_view sv) {
+    const auto* in = reinterpret_cast<const char8_t*>(sv.data());
+    const auto* end = in + sv.size();
+    std::array<char8_t, 4> u8arr{};
+    while (in < end) {
+      if (IsSjisLeadByte(*in)) {
+        char16_t sjis = static_cast<char16_t>(*in) << 8 | *(in + 1);
+        in += 2;
+        char32_t utf32 = OSSJISToUTF32(sjis);
+        if (utf32 == 0) {
+          continue;
+        }
+        char8_t* u8out = u8arr.data();
+        char8_t* u8end = OSUTF32To8(utf32, u8out);
+        if (u8end == nullptr) {
+          continue;
+        }
+        auto length = static_cast<size_t>(u8end - u8out);
+        out.append(std::string_view{reinterpret_cast<char*>(u8out), length});
+      } else {
+        out.push_back(static_cast<char>(*in++));
+      }
+    }
+  }
+
+  [[nodiscard]] const std::string& str() const { return out; }
+
+  [[nodiscard]] std::string& str() { return out; }
+
+  [[nodiscard]] const char* c_str() const { return out.c_str(); }
+};
+
+class UTF8ToSJIS {
+private:
+  std::string out;
+
+public:
+  UTF8ToSJIS(std::string_view sv) {
+    const auto* in = reinterpret_cast<const char8_t*>(sv.data());
+    const auto* end = in + sv.size();
+    while (in < end) {
+      char32_t utf32 = 0;
+      const char8_t* next = OSUTF8To32(in, &utf32);
+      if (next == nullptr) {
+        utf32 = *in;
+        in++;
+      } else {
+        in = next;
+      }
+      char16_t sjis = OSUTF32ToSJIS(utf32);
+      char8_t lead = (sjis >> 8) & 0xFF;
+      if (IsSjisLeadByte(lead)) {
+        out.push_back(static_cast<char>(lead));
+      }
+      out.push_back(static_cast<char>(sjis & 0xFF));
+    }
+  }
+
+  [[nodiscard]] const std::string& str() const { return out; }
+
+  [[nodiscard]] std::string& str() { return out; }
+
+  [[nodiscard]] const char* c_str() const { return out.c_str(); }
+};
+#endif
--- a/include/nod/Util.hpp
+++ b/include/nod/Util.hpp
@@ -1,6 +1,7 @@
 #pragma once

-#if _WIN32 && UNICODE
+#if _WIN32
+#include <array>
 #include <cwctype>
 #include <direct.h>
 #ifndef WIN32_LEAN_AND_MEAN
@@ -9,6 +10,7 @@
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
+#include <nowide/stackstring.hpp>
 #include <windows.h>
 #if defined(WINAPI_FAMILY) && WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP
 #define WINDOWS_STORE 1
@@ -65,7 +67,9 @@ constexpr T max(T a, T b) {
 /* template-based div for flexible typing and avoiding a library call */
 template <typename T>
 constexpr auto div(T a, T b) {
-  struct DivTp { T quot, rem; };
+  struct DivTp {
+    T quot, rem;
+  };
  return DivTp{a / b, a % b};
 }

@@ -73,99 +77,27 @@ constexpr auto div(T a, T b) {
 extern logvisor::Module LogModule;

 /* filesystem char type */
-#if _WIN32 && UNICODE
-#define NOD_UCS2 1
-typedef struct _stat Sstat;
-static inline int Mkdir(const wchar_t* path, int) { return _wmkdir(path); }
-static inline int Stat(const wchar_t* path, Sstat* statout) { return _wstat(path, statout); }
+#if _WIN32
+static inline int Mkdir(const char* path, int) {
+  const nowide::wstackstring str(path);
+  return _wmkdir(str.get());
+}
+
+using Sstat = struct ::_stat64;
+static inline int Stat(const char* path, Sstat* statout) {
+  const nowide::wstackstring wpath(path);
+  return _wstat64(wpath.get(), statout);
+}
 #else
-typedef struct stat Sstat;
 static inline int Mkdir(const char* path, mode_t mode) { return mkdir(path, mode); }
+
+typedef struct stat Sstat;
 static inline int Stat(const char* path, Sstat* statout) { return stat(path, statout); }
 #endif

-/* String-converting views */
-#if NOD_UCS2
-typedef wchar_t SystemChar;
-typedef std::wstring SystemString;
-typedef std::wstring_view SystemStringView;
-static inline void ToLower(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), towlower); }
-static inline void ToUpper(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), towupper); }
-static inline size_t StrLen(const SystemChar* str) { return wcslen(str); }
-class SystemUTF8Conv {
-  std::string m_utf8;
-
-public:
-  explicit SystemUTF8Conv(SystemStringView str) {
-    int len = WideCharToMultiByte(CP_UTF8, 0, str.data(), str.size(), nullptr, 0, nullptr, nullptr);
-    m_utf8.assign(len, '\0');
-    WideCharToMultiByte(CP_UTF8, 0, str.data(), str.size(), &m_utf8[0], len, nullptr, nullptr);
-  }
-  std::string_view utf8_str() const { return m_utf8; }
-  const char* c_str() const { return m_utf8.c_str(); }
-};
-class SystemStringConv {
-  std::wstring m_sys;
-
-public:
-  explicit SystemStringConv(std::string_view str) {
-    int len = MultiByteToWideChar(CP_UTF8, 0, str.data(), str.size(), nullptr, 0);
-    m_sys.assign(len, L'\0');
-    MultiByteToWideChar(CP_UTF8, 0, str.data(), str.size(), &m_sys[0], len);
-  }
-  SystemStringView sys_str() const { return m_sys; }
-  const SystemChar* c_str() const { return m_sys.c_str(); }
-};
-#ifndef _SYS_STR
-#define _SYS_STR(val) L##val
-#endif
-#else
-typedef char SystemChar;
-typedef std::string SystemString;
-typedef std::string_view SystemStringView;
-static inline void ToLower(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), tolower); }
-static inline void ToUpper(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), toupper); }
-static inline size_t StrLen(const SystemChar* str) { return strlen(str); }
-class SystemUTF8Conv {
-  std::string_view m_utf8;
-
-public:
-  explicit SystemUTF8Conv(SystemStringView str) : m_utf8(str) {}
-  std::string_view utf8_str() const { return m_utf8; }
-  const char* c_str() const { return m_utf8.data(); }
-};
-class SystemStringConv {
-  SystemStringView m_sys;
-
-public:
-  explicit SystemStringConv(std::string_view str) : m_sys(str) {}
-  SystemStringView sys_str() const { return m_sys; }
-  const SystemChar* c_str() const { return m_sys.data(); }
-};
-#ifndef _SYS_STR
-#define _SYS_STR(val) val
-#endif
-#endif
-
-static inline void Unlink(const SystemChar* file) {
-#if NOD_UCS2
-  _wunlink(file);
-#else
-  unlink(file);
-#endif
-}
-
-static inline int StrCmp(const SystemChar* str1, const SystemChar* str2) {
-#if NOD_UCS2
-  return wcscmp(str1, str2);
-#else
-  return strcmp(str1, str2);
-#endif
-}
-
-static inline int StrCaseCmp(const SystemChar* str1, const SystemChar* str2) {
-#if NOD_UCS2
-  return _wcsicmp(str1, str2);
+static inline int StrCaseCmp(const char* str1, const char* str2) {
+#ifdef _MSC_VER
+  return _stricmp(str1, str2);
 #else
  return strcasecmp(str1, str2);
 #endif
@@ -249,9 +181,11 @@ static inline uint64_t SBig(uint64_t val) { return val; }
 #endif

 enum class FileLockType { None = 0, Read, Write };
-static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLockType lock = FileLockType::None) {
-#if NOD_UCS2
-  FILE* fp = _wfopen(path, mode);
+static inline FILE* Fopen(const char* path, const char* mode, FileLockType lock = FileLockType::None) {
+#if _MSC_VER
+  const nowide::wstackstring wpath(path);
+  const nowide::wshort_stackstring wmode(mode);
+  FILE* fp = _wfopen(wpath.get(), wmode.get());
  if (!fp)
    return nullptr;
 #else
@@ -265,7 +199,7 @@ static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLo
    OVERLAPPED ov = {};
    LockFileEx((HANDLE)(uintptr_t)_fileno(fp), (lock == FileLockType::Write) ? LOCKFILE_EXCLUSIVE_LOCK : 0, 0, 0, 1,
               &ov);
-#elif !defined(__SWITCH__)
+#else
    if (flock(fileno(fp), ((lock == FileLockType::Write) ? LOCK_EX : LOCK_SH) | LOCK_NB))
      LogModule.report(logvisor::Error, FMT_STRING("flock {}: {}"), path, strerror(errno));
 #endif
@@ -277,7 +211,7 @@ static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLo
 static inline int FSeek(FILE* fp, int64_t offset, int whence) {
 #if _WIN32
  return _fseeki64(fp, offset, whence);
-#elif __APPLE__ || __FreeBSD__ || __SWITCH__
+#elif __APPLE__ || __FreeBSD__
  return fseeko(fp, offset, whence);
 #else
  return fseeko64(fp, offset, whence);
@@ -287,27 +221,29 @@ static inline int FSeek(FILE* fp, int64_t offset, int whence) {
 static inline int64_t FTell(FILE* fp) {
 #if _WIN32
  return _ftelli64(fp);
-#elif __APPLE__ || __FreeBSD__ || __SWITCH__
+#elif __APPLE__ || __FreeBSD__
  return ftello(fp);
 #else
  return ftello64(fp);
 #endif
 }

-static inline bool CheckFreeSpace(const SystemChar* path, size_t reqSz) {
+static inline bool CheckFreeSpace(const char* path, size_t reqSz) {
 #if _WIN32
  ULARGE_INTEGER freeBytes;
-  wchar_t buf[1024];
-  wchar_t* end;
-  DWORD ret = GetFullPathNameW(path, 1024, buf, &end);
-  if (!ret || ret > 1024) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("GetFullPathNameW {}")), path);
+  const nowide::wstackstring wpath(path);
+  std::array<wchar_t, 1024> buf{};
+  wchar_t* end = nullptr;
+  DWORD ret = GetFullPathNameW(wpath.get(), 1024, buf.data(), &end);
+  if (ret == 0 || ret > 1024) {
+    LogModule.report(logvisor::Error, FMT_STRING("GetFullPathNameW {}"), path);
    return false;
  }
-  if (end)
+  if (end != nullptr) {
    end[0] = L'\0';
-  if (!GetDiskFreeSpaceExW(buf, &freeBytes, nullptr, nullptr)) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("GetDiskFreeSpaceExW {}: {}")), path, GetLastError());
+  }
+  if (!GetDiskFreeSpaceExW(buf.data(), &freeBytes, nullptr, nullptr)) {
+    LogModule.report(logvisor::Error, FMT_STRING("GetDiskFreeSpaceExW {}: {}"), path, GetLastError());
    return false;
  }
  return reqSz < freeBytes.QuadPart;
--- a/include/nod/nod.hpp
+++ b/include/nod/nod.hpp
@@ -15,7 +15,7 @@ struct ExtractionContext final {
  std::function<void(std::string_view, float)> progressCB;
 };

-std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path);
-std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii);
+std::unique_ptr<DiscBase> OpenDiscFromImage(std::string_view path);
+std::unique_ptr<DiscBase> OpenDiscFromImage(std::string_view path, bool& isWii);

 } // namespace nod
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -10,6 +10,7 @@ add_library(nod
  DiscIOWBFS.cpp
  DiscWii.cpp
  nod.cpp
+  OSUTF.c

  ../include/nod/aes.hpp
  ../include/nod/DirectoryEnumerator.hpp
@@ -21,13 +22,14 @@ add_library(nod
  ../include/nod/nod.hpp
  ../include/nod/sha1.h
  ../include/nod/Util.hpp
+  ../include/nod/OSUTF.h
 )

 target_include_directories(nod PUBLIC
  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
 )

-target_link_libraries(nod PUBLIC logvisor)
+target_link_libraries(nod PUBLIC $<BUILD_INTERFACE:logvisor>)

 if(WIN32)
  target_sources(nod PRIVATE FileIOWin32.cpp)
@@ -36,7 +38,7 @@ else()
  target_sources(nod PRIVATE FileIOFILE.cpp)
 endif()

-if(NOT MSVC AND NOT NX)
+if(NOT MSVC AND ${CMAKE_SYSTEM_PROCESSOR} STREQUAL x86_64)
  set_source_files_properties(aes.cpp PROPERTIES COMPILE_FLAGS -maes)
 endif()

--- a/lib/DirectoryEnumerator.cpp
+++ b/lib/DirectoryEnumerator.cpp
@@ -1,135 +1,170 @@
 #include "nod/DirectoryEnumerator.hpp"

 #ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
 #include <windows.h>
 #else
-#include <sys/stat.h>
 #include <dirent.h>
+#include <sys/stat.h>
 #endif

 #include <cstring>
 #include <map>
+#ifdef __cpp_lib_ranges
+#include <ranges>
+#endif

 namespace nod {

-DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode, bool sizeSort, bool reverse, bool noHidden) {
+DirectoryEnumerator::DirectoryEnumerator(std::string_view path, Mode mode, bool sizeSort, bool reverse, bool noHidden) {
  Sstat theStat;
-  if (Stat(path.data(), &theStat) || !S_ISDIR(theStat.st_mode))
+  if (Stat(path.data(), &theStat) || !S_ISDIR(theStat.st_mode)) {
    return;
+  }

 #if _WIN32
-  SystemString wc(path);
-  wc += _SYS_STR("/*");
+  std::wstring wc = nowide::widen(path);
+  wc += L"/*";
  WIN32_FIND_DATAW d;
  HANDLE dir = FindFirstFileW(wc.c_str(), &d);
-  if (dir == INVALID_HANDLE_VALUE)
+  if (dir == INVALID_HANDLE_VALUE) {
    return;
+  }
  switch (mode) {
  case Mode::Native:
    do {
-      if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
+      if (!wcscmp(d.cFileName, L".") || !wcscmp(d.cFileName, L"..")) {
        continue;
-      if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
+      }
+      if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) {
        continue;
-      SystemString fp(path);
-      fp += _SYS_STR('/');
-      fp += d.cFileName;
+      }
+      std::string fileName = nowide::narrow(d.cFileName);
+      std::string fp(path);
+      fp += '/';
+      fp += fileName;
      Sstat st;
      if (Stat(fp.c_str(), &st))
        continue;

      size_t sz = 0;
      bool isDir = false;
-      if (S_ISDIR(st.st_mode))
+      if (S_ISDIR(st.st_mode)) {
        isDir = true;
-      else if (S_ISREG(st.st_mode))
+      } else if (S_ISREG(st.st_mode)) {
        sz = st.st_size;
-      else
+      } else {
        continue;
+      }

-      m_entries.push_back(Entry(fp, d.cFileName, sz, isDir));
+      m_entries.emplace_back(fp, fileName, sz, isDir);
    } while (FindNextFileW(dir, &d));
    break;
  case Mode::DirsThenFilesSorted:
  case Mode::DirsSorted: {
-    std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
+    std::map<std::string, Entry, CaseInsensitiveCompare> sort;
    do {
-      if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
+      if (!wcscmp(d.cFileName, L".") || !wcscmp(d.cFileName, L"..")) {
        continue;
-      if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
+      }
+      if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) {
        continue;
-      SystemString fp(path);
-      fp += _SYS_STR('/');
-      fp += d.cFileName;
+      }
+      std::string fileName = nowide::narrow(d.cFileName);
+      std::string fp(path);
+      fp += '/';
+      fp += fileName;
      Sstat st;
-      if (Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode))
+      if (Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode)) {
        continue;
-      sort.emplace(std::make_pair(d.cFileName, Entry(fp, d.cFileName, 0, true)));
+      }
+      sort.emplace(fileName, Entry{fp, fileName, 0, true});
    } while (FindNextFileW(dir, &d));

    m_entries.reserve(sort.size());
-    if (reverse)
-      for (auto it = sort.crbegin(); it != sort.crend(); ++it)
-        m_entries.push_back(std::move(it->second));
-    else
-      for (auto& e : sort)
-        m_entries.push_back(std::move(e.second));
+    if (reverse) {
+      for (auto& it : std::ranges::reverse_view(sort)) {
+        m_entries.emplace_back(std::move(it.second));
+      }
+    } else {
+      for (auto& e : sort) {
+        m_entries.emplace_back(std::move(e.second));
+      }
+    }

-    if (mode == Mode::DirsSorted)
+    if (mode == Mode::DirsSorted) {
      break;
+    }
    FindClose(dir);
    dir = FindFirstFileW(wc.c_str(), &d);
  }
  case Mode::FilesSorted: {
-    if (mode == Mode::FilesSorted)
+    if (mode == Mode::FilesSorted) {
      m_entries.clear();
+    }

    if (sizeSort) {
      std::multimap<size_t, Entry> sort;
      do {
-        if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
+        if (!wcscmp(d.cFileName, L".") || !wcscmp(d.cFileName, L"..")) {
          continue;
-        if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
+        }
+        if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) {
          continue;
-        SystemString fp(path);
-        fp += _SYS_STR('/');
-        fp += d.cFileName;
+        }
+        std::string fileName = nowide::narrow(d.cFileName);
+        std::string fp(path);
+        fp += '/';
+        fp += fileName;
        Sstat st;
-        if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
+        if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode)) {
          continue;
-        sort.emplace(std::make_pair(st.st_size, Entry(fp, d.cFileName, st.st_size, false)));
+        }
+        sort.emplace(st.st_size, Entry{fp, fileName, static_cast<size_t>(st.st_size), false});
      } while (FindNextFileW(dir, &d));

-      m_entries.reserve(sort.size());
-      if (reverse)
-        for (auto it = sort.crbegin(); it != sort.crend(); ++it)
-          m_entries.push_back(std::move(it->second));
-      else
-        for (auto& e : sort)
-          m_entries.push_back(std::move(e.second));
+      m_entries.reserve(m_entries.size() + sort.size());
+      if (reverse) {
+        for (auto& it : std::ranges::reverse_view(sort)) {
+          m_entries.emplace_back(std::move(it.second));
+        }
+      } else {
+        for (auto& e : sort) {
+          m_entries.emplace_back(std::move(e.second));
+        }
+      }
    } else {
-      std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
+      std::map<std::string, Entry, CaseInsensitiveCompare> sort;
      do {
-        if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
+        if (!wcscmp(d.cFileName, L".") || !wcscmp(d.cFileName, L"..")) {
          continue;
-        if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
+        }
+        if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) {
          continue;
-        SystemString fp(path);
-        fp += _SYS_STR('/');
-        fp += d.cFileName;
+        }
+        std::string fileName = nowide::narrow(d.cFileName);
+        std::string fp(path);
+        fp += '/';
+        fp += fileName;
        Sstat st;
-        if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
+        if (Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode)) {
          continue;
-        sort.emplace(std::make_pair(d.cFileName, Entry(fp, d.cFileName, st.st_size, false)));
+        }
+        sort.emplace(fileName, Entry{fp, fileName, static_cast<size_t>(st.st_size), false});
      } while (FindNextFileW(dir, &d));

-      m_entries.reserve(sort.size());
-      if (reverse)
-        for (auto it = sort.crbegin(); it != sort.crend(); ++it)
-          m_entries.push_back(std::move(it->second));
-      else
-        for (auto& e : sort)
-          m_entries.push_back(std::move(e.second));
+      m_entries.reserve(m_entries.size() + sort.size());
+      if (reverse) {
+        for (auto& e : std::ranges::reverse_view(sort)) {
+          m_entries.emplace_back(std::move(e.second));
+        }
+      } else {
+        for (auto& e : sort) {
+          m_entries.emplace_back(std::move(e.second));
+        }
+      }
    }

    break;
@@ -150,7 +185,7 @@ DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode, bool
        continue;
      if (noHidden && d->d_name[0] == '.')
        continue;
-      SystemString fp(path);
+      std::string fp(path);
      fp += '/';
      fp += d->d_name;
      Sstat st;
@@ -171,13 +206,13 @@ DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode, bool
    break;
  case Mode::DirsThenFilesSorted:
  case Mode::DirsSorted: {
-    std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
+    std::map<std::string, Entry, CaseInsensitiveCompare> sort;
    while ((d = readdir(dir))) {
      if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
        continue;
      if (noHidden && d->d_name[0] == '.')
        continue;
-      SystemString fp(path);
+      std::string fp(path);
      fp += '/';
      fp += d->d_name;
      Sstat st;
@@ -210,7 +245,7 @@ DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode, bool
          continue;
        if (noHidden && d->d_name[0] == '.')
          continue;
-        SystemString fp(path);
+        std::string fp(path);
        fp += '/';
        fp += d->d_name;
        Sstat st;
@@ -227,13 +262,13 @@ DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode, bool
        for (auto& e : sort)
          m_entries.push_back(std::move(e.second));
    } else {
-      std::map<SystemString, Entry, CaseInsensitiveCompare> sort;
+      std::map<std::string, Entry, CaseInsensitiveCompare> sort;
      while ((d = readdir(dir))) {
        if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
          continue;
        if (noHidden && d->d_name[0] == '.')
          continue;
-        SystemString fp(path);
+        std::string fp(path);
        fp += '/';
        fp += d->d_name;
        Sstat st;
--- a/lib/DiscBase.cpp
+++ b/lib/DiscBase.cpp
@@ -43,14 +43,14 @@ static void* memmem(const void* haystack, size_t hlen, const void* needle, size_

 namespace nod {

-const SystemChar* getKindString(PartitionKind kind) {
+const char* getKindString(PartitionKind kind) {
  switch (kind) {
  case PartitionKind::Data:
-    return _SYS_STR("DATA");
+    return "DATA";
  case PartitionKind::Update:
-    return _SYS_STR("UPDATE");
+    return "UPDATE";
  case PartitionKind::Channel:
-    return _SYS_STR("CHANNEL");
+    return "CHANNEL";
  default:
    return nullptr;
  }
@@ -126,16 +126,16 @@ std::unique_ptr<uint8_t[]> Node::getBuf() const {
  return buf;
 }

-bool Node::extractToDirectory(SystemStringView basePath, const ExtractionContext& ctx) const {
-  SystemStringConv nameView(getName());
-  SystemString path = SystemString(basePath) + _SYS_STR('/') + nameView.sys_str().data();
+bool Node::extractToDirectory(std::string_view basePath, const ExtractionContext& ctx) const {
+  SJISToUTF8 nameView(getName());
+  std::string path = std::string(basePath) + '/' + nameView.str().data();

  if (m_kind == Kind::Directory) {
    ++m_parent.m_curNodeIdx;
    if (ctx.progressCB && !getName().empty())
-      ctx.progressCB(getName(), m_parent.m_curNodeIdx / float(m_parent.getNodeCount()));
+      ctx.progressCB(nameView.str(), m_parent.m_curNodeIdx / float(m_parent.getNodeCount()));
    if (Mkdir(path.c_str(), 0755) && errno != EEXIST) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), path);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to mkdir '{}'"), path);
      return false;
    }
    for (Node& subnode : *this)
@@ -144,7 +144,7 @@ bool Node::extractToDirectory(SystemStringView basePath, const ExtractionContext
  } else if (m_kind == Kind::File) {
    Sstat theStat;
    if (ctx.progressCB)
-      ctx.progressCB(getName(), m_parent.m_curNodeIdx / float(m_parent.getNodeCount()));
+      ctx.progressCB(nameView.str(), m_parent.m_curNodeIdx / float(m_parent.getNodeCount()));

    if (ctx.force || Stat(path.c_str(), &theStat)) {
      std::unique_ptr<IPartReadStream> rs = beginReadStream();
@@ -153,7 +153,7 @@ bool Node::extractToDirectory(SystemStringView basePath, const ExtractionContext
        return false;
      ws->copyFromDisc(*rs, m_discLength, [&](float prog) {
        if (ctx.progressCB)
-          ctx.progressCB(getName(), (m_parent.m_curNodeIdx + prog) / float(m_parent.getNodeCount()));
+          ctx.progressCB(nameView.str(), (m_parent.m_curNodeIdx + prog) / float(m_parent.getNodeCount()));
      });
    }
    ++m_parent.m_curNodeIdx;
@@ -161,17 +161,17 @@ bool Node::extractToDirectory(SystemStringView basePath, const ExtractionContext
  return true;
 }

-bool IPartition::extractToDirectory(SystemStringView path, const ExtractionContext& ctx) {
+bool IPartition::extractToDirectory(std::string_view path, const ExtractionContext& ctx) {
  m_curNodeIdx = 0;
  if (Mkdir(path.data(), 0755) && errno != EEXIST) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), path);
+    LogModule.report(logvisor::Error, FMT_STRING("unable to mkdir '{}'"), path);
    return false;
  }

-  SystemString basePath = m_isWii ? SystemString(path) + _SYS_STR("/") + getKindString(m_kind) : SystemString(path);
+  std::string basePath = m_isWii ? std::string(path) + "/" + getKindString(m_kind) : std::string(path);
  if (m_isWii) {
    if (Mkdir(basePath.c_str(), 0755) && errno != EEXIST) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), basePath);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to mkdir '{}'"), basePath);
      return false;
    }
  }
@@ -188,25 +188,25 @@ bool IPartition::extractToDirectory(SystemStringView path, const ExtractionConte
    return false;

  /* Extract Filesystem */
-  SystemString fsPath = basePath + _SYS_STR("/files");
+  std::string fsPath = basePath + "/files";
  if (Mkdir(fsPath.c_str(), 0755) && errno != EEXIST) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}'")), fsPath);
+    LogModule.report(logvisor::Error, FMT_STRING("unable to mkdir '{}'"), fsPath);
    return false;
  }

  return m_nodes[0].extractToDirectory(fsPath, ctx);
 }

-bool IPartition::extractSysFiles(SystemStringView basePath, const ExtractionContext& ctx) const {
-  SystemString basePathStr(basePath);
-  if (Mkdir((basePathStr + _SYS_STR("/sys")).c_str(), 0755) && errno != EEXIST) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}/sys'")), basePath);
+bool IPartition::extractSysFiles(std::string_view basePath, const ExtractionContext& ctx) const {
+  std::string basePathStr(basePath);
+  if (Mkdir((basePathStr + "/sys").c_str(), 0755) && errno != EEXIST) {
+    LogModule.report(logvisor::Error, FMT_STRING("unable to mkdir '{}/sys'"), basePath);
    return false;
  }

  Sstat theStat;
  /* Extract Apploader */
-  SystemString apploaderPath = basePathStr + _SYS_STR("/sys/apploader.img");
+  std::string apploaderPath = basePathStr + "/sys/apploader.img";
  if (ctx.force || Stat(apploaderPath.c_str(), &theStat)) {
    if (ctx.progressCB)
      ctx.progressCB("apploader.bin", 0.f);
@@ -218,7 +218,7 @@ bool IPartition::extractSysFiles(SystemStringView basePath, const ExtractionCont
  }

  /* Extract Dol */
-  SystemString dolPath = basePathStr + _SYS_STR("/sys/main.dol");
+  std::string dolPath = basePathStr + "/sys/main.dol";
  if (ctx.force || Stat(dolPath.c_str(), &theStat)) {
    if (ctx.progressCB)
      ctx.progressCB("main.dol", 0.f);
@@ -230,7 +230,7 @@ bool IPartition::extractSysFiles(SystemStringView basePath, const ExtractionCont
  }

  /* Extract Boot info */
-  SystemString bootPath = basePathStr + _SYS_STR("/sys/boot.bin");
+  std::string bootPath = basePathStr + "/sys/boot.bin";
  if (ctx.force || Stat(bootPath.c_str(), &theStat)) {
    if (ctx.progressCB)
      ctx.progressCB("boot.bin", 0.f);
@@ -241,7 +241,7 @@ bool IPartition::extractSysFiles(SystemStringView basePath, const ExtractionCont
  }

  /* Extract BI2 info */
-  SystemString bi2Path = basePathStr + _SYS_STR("/sys/bi2.bin");
+  std::string bi2Path = basePathStr + "/sys/bi2.bin";
  if (ctx.force || Stat(bi2Path.c_str(), &theStat)) {
    if (ctx.progressCB)
      ctx.progressCB("bi2.bin", 0.f);
@@ -255,26 +255,26 @@ bool IPartition::extractSysFiles(SystemStringView basePath, const ExtractionCont
  return true;
 }

-static bool IsSystemFile(SystemStringView name, bool& isDol) {
+static bool IsSystemFile(std::string_view name, bool& isDol) {
  isDol = false;
  if (name.size() < 4)
    return false;

-  if (!StrCaseCmp((&*(name.cend() - 4)), _SYS_STR(".dol"))) {
+  if (!StrCaseCmp((&*(name.cend() - 4)), ".dol")) {
    isDol = true;
    return true;
  }
-  if (!StrCaseCmp((&*(name.cend() - 4)), _SYS_STR(".rel")))
+  if (!StrCaseCmp((&*(name.cend() - 4)), ".rel"))
    return true;
-  if (!StrCaseCmp((&*(name.cend() - 4)), _SYS_STR(".rso")))
+  if (!StrCaseCmp((&*(name.cend() - 4)), ".rso"))
    return true;
-  if (!StrCaseCmp((&*(name.cend() - 4)), _SYS_STR(".sel")))
+  if (!StrCaseCmp((&*(name.cend() - 4)), ".sel"))
    return true;
-  if (!StrCaseCmp((&*(name.cend() - 4)), _SYS_STR(".bnr")))
+  if (!StrCaseCmp((&*(name.cend() - 4)), ".bnr"))
    return true;
-  if (!StrCaseCmp((&*(name.cend() - 4)), _SYS_STR(".elf")))
+  if (!StrCaseCmp((&*(name.cend() - 4)), ".elf"))
    return true;
-  if (!StrCaseCmp((&*(name.cend() - 4)), _SYS_STR(".wad")))
+  if (!StrCaseCmp((&*(name.cend() - 4)), ".wad"))
    return true;

  return false;
@@ -284,7 +284,6 @@ static bool IsSystemFile(SystemStringView name, bool& isDol) {
 *  This is required for multi-DOL games, but doesn't harm functionality otherwise */
 static void PatchDOL(std::unique_ptr<uint8_t[]>& buf, size_t sz, bool& patched) {
  patched = false;
-#ifndef __SWITCH__
  uint8_t* found = static_cast<uint8_t*>(memmem(buf.get(), sz,
                                                "\x3C\x03\xF8\x00\x28\x00\x00\x00\x40\x82\x00\x0C"
                                                "\x38\x60\x00\x01\x48\x00\x02\x44\x38\x61\x00\x18\x48",
@@ -293,7 +292,6 @@ static void PatchDOL(std::unique_ptr<uint8_t[]>& buf, size_t sz, bool& patched)
    found[11] = '\x04';
    patched = true;
  }
-#endif
 }

 static size_t PatchDOL(IFileIO::IReadStream& in, IPartWriteStream& out, size_t sz, bool& patched) {
@@ -303,7 +301,7 @@ static size_t PatchDOL(IFileIO::IReadStream& in, IPartWriteStream& out, size_t s
  return out.write(buf.get(), sz);
 }

-void DiscBuilderBase::PartitionBuilderBase::recursiveBuildNodesPre(SystemStringView filesIn) {
+void DiscBuilderBase::PartitionBuilderBase::recursiveBuildNodesPre(std::string_view filesIn) {
  DirectoryEnumerator dEnum(filesIn, DirectoryEnumerator::Mode::DirsThenFilesSorted, false, false, true);
  for (const DirectoryEnumerator::Entry& e : dEnum) {
    if (e.m_isDir)
@@ -314,7 +312,7 @@ void DiscBuilderBase::PartitionBuilderBase::recursiveBuildNodesPre(SystemStringV
 }

 bool DiscBuilderBase::PartitionBuilderBase::recursiveBuildNodes(IPartWriteStream& ws, bool system,
-                                                                SystemStringView filesIn) {
+                                                                std::string_view filesIn) {
  DirectoryEnumerator dEnum(filesIn, DirectoryEnumerator::Mode::DirsThenFilesSorted, false, false, true);
  for (const DirectoryEnumerator::Entry& e : dEnum) {
    if (e.m_isDir) {
@@ -339,7 +337,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveBuildNodes(IPartWriteStream
        bool patched;
        xferSz = PatchDOL(*rs, ws, e.m_fileSz, patched);
        m_parent.m_progressCB(m_parent.getProgressFactor(),
-                              e.m_name + (patched ? _SYS_STR(" [PATCHED]") : _SYS_STR("")), xferSz);
+                              e.m_name + (patched ? " [PATCHED]" : ""), xferSz);
        ++m_parent.m_progressIdx;
      } else {
        char buf[0x8000];
@@ -361,7 +359,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveBuildNodes(IPartWriteStream
  return true;
 }

-bool DiscBuilderBase::PartitionBuilderBase::recursiveBuildFST(SystemStringView filesIn,
+bool DiscBuilderBase::PartitionBuilderBase::recursiveBuildFST(std::string_view filesIn,
                                                              std::function<void(void)> incParents,
                                                              size_t parentDirIdx) {
  DirectoryEnumerator dEnum(filesIn, DirectoryEnumerator::Mode::DirsThenFilesSorted, false, false, true);
@@ -389,7 +387,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveBuildFST(SystemStringView f
  return true;
 }

-void DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodesPre(const Node* nodeIn, SystemStringView dirIn) {
+void DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodesPre(const Node* nodeIn, std::string_view dirIn) {
  /* Build map of existing nodes to write-through later */
  std::unordered_map<std::string, const Node*> fileNodes;
  std::unordered_map<std::string, const Node*> dirNodes;
@@ -408,10 +406,9 @@ void DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodesPre(const Node* n
  if (!dirIn.empty()) {
    DirectoryEnumerator dEnum(dirIn, DirectoryEnumerator::Mode::DirsThenFilesSorted, false, false, true);
    for (const DirectoryEnumerator::Entry& e : dEnum) {
-      SystemUTF8Conv nameView(e.m_name);
-
+      UTF8ToSJIS nameView(e.m_name);
      if (e.m_isDir) {
-        auto search = dirNodes.find(nameView.utf8_str().data());
+        auto search = dirNodes.find(nameView.str());
        if (search != dirNodes.cend()) {
          recursiveMergeNodesPre(search->second, e.m_path.c_str());
          dirNodes.erase(search);
@@ -419,7 +416,7 @@ void DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodesPre(const Node* n
          recursiveMergeNodesPre(nullptr, e.m_path.c_str());
        }
      } else {
-        fileNodes.erase(nameView.utf8_str().data());
+        fileNodes.erase(nameView.str());
        ++m_parent.m_progressTotal;
      }
    }
@@ -435,7 +432,7 @@ void DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodesPre(const Node* n
 }

 bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream& ws, bool system, const Node* nodeIn,
-                                                                SystemStringView dirIn, SystemStringView keyPath) {
+                                                                std::string_view dirIn, std::string_view keyPath) {
  /* Build map of existing nodes to write-through later */
  std::unordered_map<std::string, const Node*> fileNodes;
  std::unordered_map<std::string, const Node*> dirNodes;
@@ -454,11 +451,11 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream
  if (!dirIn.empty()) {
    DirectoryEnumerator dEnum(dirIn, DirectoryEnumerator::Mode::DirsThenFilesSorted, false, false, true);
    for (const DirectoryEnumerator::Entry& e : dEnum) {
-      SystemUTF8Conv nameView(e.m_name);
-      SystemString chKeyPath = SystemString(keyPath) + _SYS_STR('/') + e.m_name;
+      UTF8ToSJIS nameView(e.m_name);
+      std::string chKeyPath = std::string(keyPath) + '/' + e.m_name;

      if (e.m_isDir) {
-        auto search = dirNodes.find(nameView.utf8_str().data());
+        auto search = dirNodes.find(nameView.str());
        if (search != dirNodes.cend()) {
          if (!recursiveMergeNodes(ws, system, search->second, e.m_path.c_str(), chKeyPath))
            return false;
@@ -473,7 +470,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream
        if (system ^ isSys)
          continue;

-        fileNodes.erase(nameView.utf8_str().data());
+        fileNodes.erase(nameView.str());

        size_t fileSz = ROUND_UP_32(e.m_fileSz);
        uint64_t fileOff = userAllocate(fileSz, ws);
@@ -488,7 +485,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream
          bool patched;
          xferSz = PatchDOL(*rs, ws, e.m_fileSz, patched);
          m_parent.m_progressCB(m_parent.getProgressFactor(),
-                                e.m_name + (patched ? _SYS_STR(" [PATCHED]") : _SYS_STR("")), xferSz);
+                                e.m_name + (patched ? " [PATCHED]" : ""), xferSz);
          ++m_parent.m_progressIdx;
        } else {
          char buf[0x8000];
@@ -510,8 +507,8 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream

  /* Write-through remaining dir nodes */
  for (const auto& p : dirNodes) {
-    SystemStringConv sysName(p.second->getName());
-    SystemString chKeyPath = SystemString(keyPath) + _SYS_STR('/') + sysName.c_str();
+    SJISToUTF8 sysName(p.second->getName());
+    std::string chKeyPath = std::string(keyPath) + '/' + sysName.str();
    if (!recursiveMergeNodes(ws, system, p.second, {}, chKeyPath))
      return false;
  }
@@ -519,11 +516,11 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream
  /* Write-through remaining file nodes */
  for (const auto& p : fileNodes) {
    const Node& ch = *p.second;
-    SystemStringConv sysName(ch.getName());
-    SystemString chKeyPath = SystemString(keyPath) + _SYS_STR('/') + sysName.c_str();
+    SJISToUTF8 sysName(ch.getName());
+    std::string chKeyPath = std::string(keyPath) + '/' + sysName.str();

    bool isDol;
-    bool isSys = IsSystemFile(sysName.sys_str(), isDol);
+    bool isSys = IsSystemFile(ch.getName(), isDol);
    if (system ^ isSys)
      continue;

@@ -543,7 +540,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream
      PatchDOL(dolBuf, xferSz, patched);
      ws.write(dolBuf.get(), xferSz);
      m_parent.m_progressCB(m_parent.getProgressFactor(),
-                            SystemString(sysName.sys_str()) + (patched ? _SYS_STR(" [PATCHED]") : _SYS_STR("")),
+                            std::string(ch.getName()) + (patched ? " [PATCHED]" : ""),
                            xferSz);
      ++m_parent.m_progressIdx;
    } else {
@@ -554,7 +551,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream
          break;
        ws.write(buf, rdSz);
        xferSz += rdSz;
-        m_parent.m_progressCB(m_parent.getProgressFactorMidFile(xferSz, ch.size()), sysName.sys_str(), xferSz);
+        m_parent.m_progressCB(m_parent.getProgressFactorMidFile(xferSz, ch.size()), ch.getName(), xferSz);
      }
      ++m_parent.m_progressIdx;
    }
@@ -565,9 +562,9 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeNodes(IPartWriteStream
  return true;
 }

-bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeFST(const Node* nodeIn, SystemStringView dirIn,
+bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeFST(const Node* nodeIn, std::string_view dirIn,
                                                              std::function<void(void)> incParents,
-                                                              SystemStringView keyPath) {
+                                                              size_t parentDirIdx, std::string_view keyPath) {
  /* Build map of existing nodes to write-through later */
  std::unordered_map<std::string, const Node*> fileNodes;
  std::unordered_map<std::string, const Node*> dirNodes;
@@ -586,23 +583,23 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeFST(const Node* nodeIn
  if (!dirIn.empty()) {
    DirectoryEnumerator dEnum(dirIn, DirectoryEnumerator::Mode::DirsThenFilesSorted, false, false, true);
    for (const DirectoryEnumerator::Entry& e : dEnum) {
-      SystemUTF8Conv nameView(e.m_name);
-      SystemString chKeyPath = SystemString(keyPath) + _SYS_STR('/') + e.m_name;
+      UTF8ToSJIS nameView(e.m_name);
+      std::string chKeyPath = std::string(keyPath) + '/' + e.m_name;

      if (e.m_isDir) {
        size_t dirNodeIdx = m_buildNodes.size();
-        m_buildNodes.emplace_back(true, m_buildNameOff, 0, dirNodeIdx + 1);
+        m_buildNodes.emplace_back(true, m_buildNameOff, parentDirIdx, dirNodeIdx + 1);
        addBuildName(e.m_name);
        incParents();

-        auto search = dirNodes.find(nameView.utf8_str().data());
+        auto search = dirNodes.find(nameView.str());
        if (search != dirNodes.cend()) {
          if (!recursiveMergeFST(search->second, e.m_path.c_str(),
                                 [&]() {
                                   m_buildNodes[dirNodeIdx].incrementLength();
                                   incParents();
                                 },
-                                 chKeyPath))
+                                 dirNodeIdx, chKeyPath))
            return false;
          dirNodes.erase(search);
        } else {
@@ -611,11 +608,11 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeFST(const Node* nodeIn
                                   m_buildNodes[dirNodeIdx].incrementLength();
                                   incParents();
                                 },
-                                 chKeyPath))
+                                 dirNodeIdx, chKeyPath))
            return false;
        }
      } else {
-        fileNodes.erase(nameView.utf8_str().data());
+        fileNodes.erase(nameView.str());
        std::pair<uint64_t, uint64_t> fileOffSz = m_fileOffsetsSizes.at(chKeyPath);
        m_buildNodes.emplace_back(false, m_buildNameOff, packOffset(fileOffSz.first), fileOffSz.second);
        addBuildName(e.m_name);
@@ -626,12 +623,12 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeFST(const Node* nodeIn

  /* Write-through remaining dir nodes */
  for (const auto& p : dirNodes) {
-    SystemStringConv sysName(p.second->getName());
-    SystemString chKeyPath = SystemString(keyPath) + _SYS_STR('/') + sysName.sys_str().data();
+    SJISToUTF8 sysName(p.second->getName());
+    std::string chKeyPath = std::string(keyPath) + '/' + sysName.str();

    size_t dirNodeIdx = m_buildNodes.size();
-    m_buildNodes.emplace_back(true, m_buildNameOff, 0, dirNodeIdx + 1);
-    addBuildName(sysName.sys_str());
+    m_buildNodes.emplace_back(true, m_buildNameOff, parentDirIdx, dirNodeIdx + 1);
+    addBuildName(sysName.str());
    incParents();

    if (!recursiveMergeFST(p.second, {},
@@ -639,19 +636,19 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeFST(const Node* nodeIn
                             m_buildNodes[dirNodeIdx].incrementLength();
                             incParents();
                           },
-                           chKeyPath))
+                           dirNodeIdx, chKeyPath))
      return false;
  }

  /* Write-through remaining file nodes */
  for (const auto& p : fileNodes) {
    const Node& ch = *p.second;
-    SystemStringConv sysName(ch.getName());
-    SystemString chKeyPath = SystemString(keyPath) + _SYS_STR('/') + sysName.sys_str().data();
+    SJISToUTF8 sysName(ch.getName());
+    std::string chKeyPath = std::string(keyPath) + '/' + sysName.str();

    std::pair<uint64_t, uint64_t> fileOffSz = m_fileOffsetsSizes.at(chKeyPath);
    m_buildNodes.emplace_back(false, m_buildNameOff, packOffset(fileOffSz.first), fileOffSz.second);
-    addBuildName(sysName.sys_str());
+    addBuildName(ch.getName());
    incParents();
  }

@@ -659,7 +656,7 @@ bool DiscBuilderBase::PartitionBuilderBase::recursiveMergeFST(const Node* nodeIn
 }

 bool DiscBuilderBase::PartitionBuilderBase::RecursiveCalculateTotalSize(uint64_t& totalSz, const Node* nodeIn,
-                                                                        SystemStringView dirIn) {
+                                                                        std::string_view dirIn) {
  /* Build map of existing nodes to write-through later */
  std::unordered_map<std::string, const Node*> fileNodes;
  std::unordered_map<std::string, const Node*> dirNodes;
@@ -678,20 +675,20 @@ bool DiscBuilderBase::PartitionBuilderBase::RecursiveCalculateTotalSize(uint64_t
  if (!dirIn.empty()) {
    DirectoryEnumerator dEnum(dirIn, DirectoryEnumerator::Mode::DirsThenFilesSorted, false, false, true);
    for (const DirectoryEnumerator::Entry& e : dEnum) {
-      SystemUTF8Conv nameView(e.m_name);
+      UTF8ToSJIS nameView(e.m_name);

      if (e.m_isDir) {
-        auto search = dirNodes.find(nameView.utf8_str().data());
+        auto search = dirNodes.find(nameView.str());
        if (search != dirNodes.cend()) {
-          if (!RecursiveCalculateTotalSize(totalSz, search->second, e.m_path.c_str()))
+          if (!RecursiveCalculateTotalSize(totalSz, search->second, e.m_path))
            return false;
          dirNodes.erase(search);
        } else {
-          if (!RecursiveCalculateTotalSize(totalSz, nullptr, e.m_path.c_str()))
+          if (!RecursiveCalculateTotalSize(totalSz, nullptr, e.m_path))
            return false;
        }
      } else {
-        fileNodes.erase(nameView.utf8_str().data());
+        fileNodes.erase(nameView.str());
        totalSz += ROUND_UP_32(e.m_fileSz);
      }
    }
@@ -712,34 +709,34 @@ bool DiscBuilderBase::PartitionBuilderBase::RecursiveCalculateTotalSize(uint64_t
  return true;
 }

-bool DiscBuilderBase::PartitionBuilderBase::buildFromDirectory(IPartWriteStream& ws, SystemStringView dirIn) {
+bool DiscBuilderBase::PartitionBuilderBase::buildFromDirectory(IPartWriteStream& ws, std::string_view dirIn) {
  if (dirIn.empty()) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("all arguments must be supplied to buildFromDirectory()")));
+    LogModule.report(logvisor::Error, FMT_STRING("all arguments must be supplied to buildFromDirectory()"));
    return false;
  }

-  SystemString dirStr(dirIn);
-  SystemString basePath = m_isWii ? dirStr + _SYS_STR("/") + getKindString(m_kind) : dirStr;
-  SystemString dolIn = basePath + _SYS_STR("/sys/main.dol");
-  SystemString filesIn = basePath + _SYS_STR("/files");
+  std::string dirStr(dirIn);
+  std::string basePath = m_isWii ? dirStr + "/" + getKindString(m_kind) : dirStr;
+  std::string dolIn = basePath + "/sys/main.dol";
+  std::string filesIn = basePath + "/files";

  /* 1st pass - Tally up total progress steps */
  m_parent.m_progressTotal += 2; /* Prep and DOL */
  recursiveBuildNodesPre(filesIn.c_str());

  /* Clear file */
-  m_parent.m_progressCB(m_parent.getProgressFactor(), _SYS_STR("Preparing output image"), -1);
+  m_parent.m_progressCB(m_parent.getProgressFactor(), "Preparing output image", -1);
  ++m_parent.m_progressIdx;

  /* Add root node */
  m_buildNodes.emplace_back(true, m_buildNameOff, 0, 1);
-  addBuildName(_SYS_STR("<root>"));
+  addBuildName("<root>");

  /* Write Boot DOL first (first thing seeked to after Apploader) */
  {
    Sstat dolStat;
    if (Stat(dolIn.c_str(), &dolStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), dolIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), dolIn);
      return false;
    }
    size_t fileSz = ROUND_UP_32(dolStat.st_size);
@@ -753,7 +750,7 @@ bool DiscBuilderBase::PartitionBuilderBase::buildFromDirectory(IPartWriteStream&
      return false;
    bool patched;
    size_t xferSz = PatchDOL(*rs, ws, dolStat.st_size, patched);
-    m_parent.m_progressCB(m_parent.getProgressFactor(), dolIn + (patched ? _SYS_STR(" [PATCHED]") : _SYS_STR("")),
+    m_parent.m_progressCB(m_parent.getProgressFactor(), dolIn + (patched ? " [PATCHED]" : ""),
                          xferSz);
    ++m_parent.m_progressIdx;
    for (size_t i = 0; i < fileSz - xferSz; ++i)
@@ -771,46 +768,46 @@ bool DiscBuilderBase::PartitionBuilderBase::buildFromDirectory(IPartWriteStream&
  return true;
 }

-std::optional<uint64_t> DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeBuild(SystemStringView dirIn,
+std::optional<uint64_t> DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeBuild(std::string_view dirIn,
                                                                                       PartitionKind kind, bool isWii) {
-  SystemString dirStr(dirIn);
-  SystemString basePath = isWii ? dirStr + _SYS_STR("/") + getKindString(kind) : dirStr;
-  SystemString dolIn = basePath + _SYS_STR("/sys/main.dol");
-  SystemString filesIn = basePath + _SYS_STR("/files");
+  std::string dirStr(dirIn);
+  std::string basePath = isWii ? dirStr + "/" + getKindString(kind) : dirStr;
+  std::string dolIn = basePath + "/sys/main.dol";
+  std::string filesIn = basePath + "/files";

  Sstat dolStat;
  if (Stat(dolIn.c_str(), &dolStat)) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), dolIn);
+    LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), dolIn);
    return std::nullopt;
  }
  uint64_t totalSz = ROUND_UP_32(dolStat.st_size);
-  if (!RecursiveCalculateTotalSize(totalSz, nullptr, filesIn.c_str()))
+  if (!RecursiveCalculateTotalSize(totalSz, nullptr, filesIn))
    return std::nullopt;
  return totalSz;
 }

 bool DiscBuilderBase::PartitionBuilderBase::mergeFromDirectory(IPartWriteStream& ws, const IPartition* partIn,
-                                                               SystemStringView dirIn) {
+                                                               std::string_view dirIn) {
  if (dirIn.empty()) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("all arguments must be supplied to mergeFromDirectory()")));
+    LogModule.report(logvisor::Error, FMT_STRING("all arguments must be supplied to mergeFromDirectory()"));
    return false;
  }

-  SystemString dirStr(dirIn);
-  SystemString basePath = m_isWii ? dirStr + _SYS_STR("/") + getKindString(m_kind) : dirStr;
-  SystemString filesIn = basePath + _SYS_STR("/files");
+  std::string dirStr(dirIn);
+  std::string basePath = m_isWii ? dirStr + "/" + getKindString(m_kind) : dirStr;
+  std::string filesIn = basePath + "/files";

  /* 1st pass - Tally up total progress steps */
  m_parent.m_progressTotal += 2; /* Prep and DOL */
  recursiveMergeNodesPre(&partIn->getFSTRoot(), filesIn.c_str());

  /* Clear file */
-  m_parent.m_progressCB(m_parent.getProgressFactor(), _SYS_STR("Preparing output image"), -1);
+  m_parent.m_progressCB(m_parent.getProgressFactor(), "Preparing output image", -1);
  ++m_parent.m_progressIdx;

  /* Add root node */
  m_buildNodes.emplace_back(true, m_buildNameOff, 0, 1);
-  addBuildName(_SYS_STR("<root>"));
+  addBuildName("<root>");

  /* Write Boot DOL first (first thing seeked to after Apploader) */
  {
@@ -826,7 +823,7 @@ bool DiscBuilderBase::PartitionBuilderBase::mergeFromDirectory(IPartWriteStream&
    PatchDOL(dolBuf, xferSz, patched);
    ws.write(dolBuf.get(), xferSz);
    m_parent.m_progressCB(m_parent.getProgressFactor(),
-                          SystemString(_SYS_STR("<boot-dol>")) + (patched ? _SYS_STR(" [PATCHED]") : _SYS_STR("")),
+                          std::string("<boot-dol>") + (patched ? " [PATCHED]" : ""),
                          xferSz);
    ++m_parent.m_progressIdx;
    for (size_t i = 0; i < fileSz - xferSz; ++i)
@@ -834,25 +831,25 @@ bool DiscBuilderBase::PartitionBuilderBase::mergeFromDirectory(IPartWriteStream&
  }

  /* Gather files in root directory */
-  SystemString keyPath;
+  std::string keyPath;
  if (!recursiveMergeNodes(ws, true, &partIn->getFSTRoot(), filesIn.c_str(), keyPath))
    return false;
  if (!recursiveMergeNodes(ws, false, &partIn->getFSTRoot(), filesIn.c_str(), keyPath))
    return false;
-  if (!recursiveMergeFST(&partIn->getFSTRoot(), filesIn.c_str(), [&]() { m_buildNodes[0].incrementLength(); }, keyPath))
+  if (!recursiveMergeFST(&partIn->getFSTRoot(), filesIn.c_str(), [&]() { m_buildNodes[0].incrementLength(); }, 0, keyPath))
    return false;

  return true;
 }

 std::optional<uint64_t> DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeMerge(const IPartition* partIn,
-                                                                                       SystemStringView dirIn) {
-  SystemString dirStr(dirIn);
-  SystemString basePath = partIn->isWii() ? dirStr + _SYS_STR("/") + getKindString(partIn->getKind()) : dirStr;
-  SystemString filesIn = basePath + _SYS_STR("/files");
+                                                                                       std::string_view dirIn) {
+  std::string dirStr(dirIn);
+  std::string basePath = partIn->isWii() ? dirStr + "/" + getKindString(partIn->getKind()) : dirStr;
+  std::string filesIn = basePath + "/files";

  uint64_t totalSz = ROUND_UP_32(partIn->getDOLSize());
-  if (!RecursiveCalculateTotalSize(totalSz, &partIn->getFSTRoot(), filesIn.c_str()))
+  if (!RecursiveCalculateTotalSize(totalSz, &partIn->getFSTRoot(), filesIn))
    return std::nullopt;
  return totalSz;
 }
--- a/lib/DiscGCN.cpp
+++ b/lib/DiscGCN.cpp
@@ -126,11 +126,11 @@ DiscGCN::DiscGCN(std::unique_ptr<IDiscIO>&& dio, bool& err) : DiscBase(std::move
  m_partitions.emplace_back(std::make_unique<PartitionGCN>(*this, 0, err));
 }

-DiscBuilderGCN DiscGCN::makeMergeBuilder(SystemStringView outPath, FProgress progressCB) {
+DiscBuilderGCN DiscGCN::makeMergeBuilder(std::string_view outPath, FProgress progressCB) {
  return DiscBuilderGCN(outPath, progressCB);
 }

-bool DiscGCN::extractDiscHeaderFiles(SystemStringView path, const ExtractionContext& ctx) const { return true; }
+bool DiscGCN::extractDiscHeaderFiles(std::string_view path, const ExtractionContext& ctx) const { return true; }

 class PartitionBuilderGCN : public DiscBuilderBase::PartitionBuilderBase {
  uint64_t m_curUser = 0x57058000;
@@ -226,7 +226,7 @@ public:
    return true;
  }

-  bool buildFromDirectory(SystemStringView dirIn) {
+  bool buildFromDirectory(std::string_view dirIn) {
    std::unique_ptr<IPartWriteStream> ws = beginWriteStream(0);
    if (!ws)
      return false;
@@ -234,29 +234,29 @@ public:
    if (!result)
      return false;

-    SystemString dirStr(dirIn);
+    std::string dirStr(dirIn);

    /* Check Apploader */
-    SystemString apploaderIn = dirStr + _SYS_STR("/sys/apploader.img");
+    std::string apploaderIn = dirStr + "/sys/apploader.img";
    Sstat apploaderStat;
    if (Stat(apploaderIn.c_str(), &apploaderStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), apploaderIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), apploaderIn);
      return false;
    }

    /* Check Boot */
-    SystemString bootIn = dirStr + _SYS_STR("/sys/boot.bin");
+    std::string bootIn = dirStr + "/sys/boot.bin";
    Sstat bootStat;
    if (Stat(bootIn.c_str(), &bootStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bootIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), bootIn);
      return false;
    }

    /* Check BI2 */
-    SystemString bi2In = dirStr + _SYS_STR("/sys/bi2.bin");
+    std::string bi2In = dirStr + "/sys/bi2.bin";
    Sstat bi2Stat;
    if (Stat(bi2In.c_str(), &bi2Stat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bi2In);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), bi2In);
      return false;
    }

@@ -308,7 +308,7 @@ public:
        });
  }

-  bool mergeFromDirectory(const PartitionGCN* partIn, SystemStringView dirIn) {
+  bool mergeFromDirectory(const PartitionGCN* partIn, std::string_view dirIn) {
    std::unique_ptr<IPartWriteStream> ws = beginWriteStream(0);
    if (!ws)
      return false;
@@ -336,7 +336,7 @@ public:
        [this, partIn](IPartWriteStream& ws, size_t& xferSz) -> bool {
          std::unique_ptr<uint8_t[]> apploaderBuf = partIn->getApploaderBuf();
          size_t apploaderSz = partIn->getApploaderSize();
-          SystemString apploaderName(_SYS_STR("<apploader>"));
+          std::string apploaderName("<apploader>");
          ws.write(apploaderBuf.get(), apploaderSz);
          xferSz += apploaderSz;
          if (0x2440 + xferSz >= m_curUser) {
@@ -350,14 +350,14 @@ public:
  }
 };

-EBuildResult DiscBuilderGCN::buildFromDirectory(SystemStringView dirIn) {
+EBuildResult DiscBuilderGCN::buildFromDirectory(std::string_view dirIn) {
  if (!m_fileIO->beginWriteStream())
    return EBuildResult::Failed;
  if (!CheckFreeSpace(m_outPath.c_str(), 0x57058000)) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_outPath);
+    LogModule.report(logvisor::Error, FMT_STRING("not enough free disk space for {}"), m_outPath);
    return EBuildResult::DiskFull;
  }
-  m_progressCB(getProgressFactor(), _SYS_STR("Preallocating image"), -1);
+  m_progressCB(getProgressFactor(), "Preallocating image", -1);
  ++m_progressIdx;
  {
    auto ws = m_fileIO->beginWriteStream(0);
@@ -372,34 +372,34 @@ EBuildResult DiscBuilderGCN::buildFromDirectory(SystemStringView dirIn) {
  return pb.buildFromDirectory(dirIn) ? EBuildResult::Success : EBuildResult::Failed;
 }

-std::optional<uint64_t> DiscBuilderGCN::CalculateTotalSizeRequired(SystemStringView dirIn) {
+std::optional<uint64_t> DiscBuilderGCN::CalculateTotalSizeRequired(std::string_view dirIn) {
  std::optional<uint64_t> sz = DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeBuild(dirIn, PartitionKind::Data, false);
  if (!sz)
    return sz;
  *sz += 0x30000;
  if (sz > 0x57058000) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x57058000);
+    LogModule.report(logvisor::Error, FMT_STRING("disc capacity exceeded [{} / {}]"), *sz, 0x57058000);
    return std::nullopt;
  }
  return sz;
 }

-DiscBuilderGCN::DiscBuilderGCN(SystemStringView outPath, FProgress progressCB)
+DiscBuilderGCN::DiscBuilderGCN(std::string_view outPath, FProgress progressCB)
 : DiscBuilderBase(outPath, 0x57058000, progressCB) {
  m_partitions.emplace_back(std::make_unique<PartitionBuilderGCN>(*this));
 }

-DiscMergerGCN::DiscMergerGCN(SystemStringView outPath, DiscGCN& sourceDisc, FProgress progressCB)
+DiscMergerGCN::DiscMergerGCN(std::string_view outPath, DiscGCN& sourceDisc, FProgress progressCB)
 : m_sourceDisc(sourceDisc), m_builder(sourceDisc.makeMergeBuilder(outPath, progressCB)) {}

-EBuildResult DiscMergerGCN::mergeFromDirectory(SystemStringView dirIn) {
+EBuildResult DiscMergerGCN::mergeFromDirectory(std::string_view dirIn) {
  if (!m_builder.getFileIO().beginWriteStream())
    return EBuildResult::Failed;
  if (!CheckFreeSpace(m_builder.m_outPath.c_str(), 0x57058000)) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_builder.m_outPath);
+    LogModule.report(logvisor::Error, FMT_STRING("not enough free disk space for {}"), m_builder.m_outPath);
    return EBuildResult::DiskFull;
  }
-  m_builder.m_progressCB(m_builder.getProgressFactor(), _SYS_STR("Preallocating image"), -1);
+  m_builder.m_progressCB(m_builder.getProgressFactor(), "Preallocating image", -1);
  ++m_builder.m_progressIdx;
  {
    auto ws = m_builder.m_fileIO->beginWriteStream(0);
@@ -416,13 +416,13 @@ EBuildResult DiscMergerGCN::mergeFromDirectory(SystemStringView dirIn) {
             : EBuildResult::Failed;
 }

-std::optional<uint64_t> DiscMergerGCN::CalculateTotalSizeRequired(DiscGCN& sourceDisc, SystemStringView dirIn) {
+std::optional<uint64_t> DiscMergerGCN::CalculateTotalSizeRequired(DiscGCN& sourceDisc, std::string_view dirIn) {
  std::optional<uint64_t> sz = DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeMerge(sourceDisc.getDataPartition(), dirIn);
  if (!sz)
    return std::nullopt;
  *sz += 0x30000;
  if (sz > 0x57058000) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x57058000);
+    LogModule.report(logvisor::Error, FMT_STRING("disc capacity exceeded [{} / {}]"), *sz, 0x57058000);
    return std::nullopt;
  }
  return sz;
--- a/lib/DiscIOISO.cpp
+++ b/lib/DiscIOISO.cpp
@@ -8,7 +8,7 @@ class DiscIOISO : public IDiscIO {
  std::unique_ptr<IFileIO> m_fio;

 public:
-  DiscIOISO(SystemStringView fpin) : m_fio(NewFileIO(fpin)) {}
+  DiscIOISO(std::string_view fpin) : m_fio(NewFileIO(fpin)) {}

  class ReadStream : public IReadStream {
    friend class DiscIOISO;
@@ -57,6 +57,6 @@ public:
  }
 };

-std::unique_ptr<IDiscIO> NewDiscIOISO(SystemStringView path) { return std::make_unique<DiscIOISO>(path); }
+std::unique_ptr<IDiscIO> NewDiscIOISO(std::string_view path) { return std::make_unique<DiscIOISO>(path); }

 } // namespace nod
--- a/lib/DiscIONFS.cpp
+++ b/lib/DiscIONFS.cpp
@@ -34,8 +34,8 @@ class DiscIONFS : public IDiscIO {
    uint32_t totalBlockCount = 0;
    for (uint32_t i = 0; i < nfsHead.lbaRangeCount; ++i)
      totalBlockCount += nfsHead.lbaRanges[i].numBlocks;
-    return (uint64_t(totalBlockCount) * uint64_t(0x8000) +
-            (uint64_t(0x200) + uint64_t(0xF9FFFFF))) / uint64_t(0xFA00000);
+    return (uint64_t(totalBlockCount) * uint64_t(0x8000) + (uint64_t(0x200) + uint64_t(0xF9FFFFF))) /
+           uint64_t(0xFA00000);
  }

  struct FBO {
@@ -57,57 +57,57 @@ class DiscIONFS : public IDiscIO {
    if (block == UINT32_MAX)
      return {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
    auto fileAndRemBlocks = nod::div(block, uint32_t(8000)); /* 8000 blocks per file */
-    return {uint32_t(fileAndRemBlocks.quot), uint32_t(fileAndRemBlocks.rem),
-            uint32_t(blockAndRemBytes.quot), uint32_t(blockAndRemBytes.rem)};
+    return {uint32_t(fileAndRemBlocks.quot), uint32_t(fileAndRemBlocks.rem), uint32_t(blockAndRemBytes.quot),
+            uint32_t(blockAndRemBytes.rem)};
  }

 public:
-  DiscIONFS(SystemStringView fpin, bool& err) {
+  DiscIONFS(std::string_view fpin, bool& err) {
    /* Validate file path format */
-    using SignedSize = std::make_signed<SystemString::size_type>::type;
-    const auto dotPos = SignedSize(fpin.rfind(_SYS_STR('.')));
-    const auto slashPos = SignedSize(fpin.find_last_of(_SYS_STR("/\\")));
-    if (fpin.size() <= 4 || dotPos == -1 || dotPos <= slashPos ||
-        fpin.compare(slashPos + 1, 4, _SYS_STR("hif_")) ||
-        fpin.compare(dotPos, fpin.size() - dotPos, _SYS_STR(".nfs"))) {
+    using SignedSize = std::make_signed<std::string::size_type>::type;
+    const auto dotPos = SignedSize(fpin.rfind('.'));
+    const auto slashPos = SignedSize(fpin.find_last_of("/\\"));
+    if (fpin.size() <= 4 || dotPos == -1 || dotPos <= slashPos || fpin.compare(slashPos + 1, 4, "hif_") ||
+        fpin.compare(dotPos, fpin.size() - dotPos, ".nfs")) {
      LogModule.report(logvisor::Error,
-        FMT_STRING(_SYS_STR("'{}' must begin with 'hif_' and end with '.nfs' to be accepted as an NFS image")), fpin);
+                       FMT_STRING("'{}' must begin with 'hif_' and end with '.nfs' to be accepted as an NFS image"),
+                       fpin);
      err = true;
      return;
    }

    /* Load key file */
-    const SystemString dir(fpin.begin(), fpin.begin() + slashPos + 1);
-    auto keyFile = NewFileIO(dir + _SYS_STR("../code/htk.bin"))->beginReadStream();
+    const std::string dir(fpin.begin(), fpin.begin() + slashPos + 1);
+    auto keyFile = NewFileIO(dir + "../code/htk.bin")->beginReadStream();
    if (!keyFile)
-      keyFile = NewFileIO(dir + _SYS_STR("htk.bin"))->beginReadStream();
+      keyFile = NewFileIO(dir + "htk.bin")->beginReadStream();
    if (!keyFile) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to open '{}../code/htk.bin' or '{}htk.bin'")), dir, dir);
+      LogModule.report(logvisor::Error, FMT_STRING("Unable to open '{}../code/htk.bin' or '{}htk.bin'"), dir, dir);
      err = true;
      return;
    }
    if (keyFile->read(key, 16) != 16) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to read from '{}../code/htk.bin' or '{}htk.bin'")), dir, dir);
+      LogModule.report(logvisor::Error, FMT_STRING("Unable to read from '{}../code/htk.bin' or '{}htk.bin'"), dir, dir);
      err = true;
      return;
    }

    /* Load header from first file */
-    const SystemString firstPath = fmt::format(FMT_STRING(_SYS_STR("{}hif_{:06}.nfs")), dir, 0);
+    const std::string firstPath = fmt::format(FMT_STRING("{}hif_{:06}.nfs"), dir, 0);
    files.push_back(NewFileIO(firstPath));
    auto rs = files.back()->beginReadStream();
    if (!rs) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("'{}' does not exist")), firstPath);
+      LogModule.report(logvisor::Error, FMT_STRING("'{}' does not exist"), firstPath);
      err = true;
      return;
    }
    if (rs->read(&nfsHead, 0x200) != 0x200) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to read header from '{}'")), firstPath);
+      LogModule.report(logvisor::Error, FMT_STRING("Unable to read header from '{}'"), firstPath);
      err = true;
      return;
    }
    if (std::memcmp(&nfsHead.magic, "EGGS", 4)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Invalid magic in '{}'")), firstPath);
+      LogModule.report(logvisor::Error, FMT_STRING("Invalid magic in '{}'"), firstPath);
      err = true;
      return;
    }
@@ -122,10 +122,10 @@ public:
    const uint32_t numFiles = calculateNumFiles();
    files.reserve(numFiles);
    for (uint32_t i = 1; i < numFiles; ++i) {
-      SystemString path = fmt::format(FMT_STRING(_SYS_STR("{}hif_{:06}.nfs")), dir, i);
+      std::string path = fmt::format(FMT_STRING("{}hif_{:06}.nfs"), dir, i);
      files.push_back(NewFileIO(path));
      if (!files.back()->exists()) {
-        LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("'{}' does not exist")), path);
+        LogModule.report(logvisor::Error, FMT_STRING("'{}' does not exist"), path);
        err = true;
        return;
      }
@@ -150,8 +150,10 @@ public:
    uint32_t m_curBlock = UINT32_MAX;

    ReadStream(const DiscIONFS& parent, uint64_t offset, bool& err)
-    : m_parent(parent), m_aes(NewAES()),
-      m_physAddr({UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX}), m_offset(offset) {
+    : m_parent(parent)
+    , m_aes(NewAES())
+    , m_physAddr({UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX})
+    , m_offset(offset) {
      m_aes->setKey(m_parent.key);
      setLogicalAddr(offset);
    }
@@ -260,7 +262,7 @@ public:
  bool hasWiiCrypto() const override { return false; }
 };

-std::unique_ptr<IDiscIO> NewDiscIONFS(SystemStringView path) {
+std::unique_ptr<IDiscIO> NewDiscIONFS(std::string_view path) {
  bool err = false;
  auto ret = std::make_unique<DiscIONFS>(path, err);
  if (err)
@@ -268,4 +270,4 @@ std::unique_ptr<IDiscIO> NewDiscIONFS(SystemStringView path) {
  return ret;
 }

-}
+} // namespace nod
--- a/lib/DiscIOWBFS.cpp
+++ b/lib/DiscIOWBFS.cpp
@@ -83,7 +83,7 @@ class DiscIOWBFS : public IDiscIO {
  }

 public:
-  DiscIOWBFS(SystemStringView fpin) : m_fio(NewFileIO(fpin)) {
+  DiscIOWBFS(std::string_view fpin) : m_fio(NewFileIO(fpin)) {
    /* Temporary file handle to read LBA table */
    std::unique_ptr<IFileIO::IReadStream> rs = m_fio->beginReadStream();
    if (!rs)
@@ -275,6 +275,6 @@ public:
  std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const override { return {}; }
 };

-std::unique_ptr<IDiscIO> NewDiscIOWBFS(SystemStringView path) { return std::make_unique<DiscIOWBFS>(path); }
+std::unique_ptr<IDiscIO> NewDiscIOWBFS(std::string_view path) { return std::make_unique<DiscIOWBFS>(path); }

 } // namespace nod
--- a/lib/DiscWii.cpp
+++ b/lib/DiscWii.cpp
@@ -421,7 +421,7 @@ public:

      uint32_t h3;
      if (rs->read(&h3, 4) != 4) {
-        LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to read H3 offset apploader")));
+        LogModule.report(logvisor::Error, FMT_STRING("unable to read H3 offset apploader"));
        return nullptr;
      }
      h3 = SBig(h3);
@@ -439,12 +439,12 @@ public:
    return buf;
  }

-  bool extractCryptoFiles(SystemStringView basePath, const ExtractionContext& ctx) const override {
+  bool extractCryptoFiles(std::string_view basePath, const ExtractionContext& ctx) const override {
    Sstat theStat;
-    SystemString basePathStr(basePath);
+    std::string basePathStr(basePath);

    /* Extract Ticket */
-    SystemString ticketPath = basePathStr + _SYS_STR("/ticket.bin");
+    std::string ticketPath = basePathStr + "/ticket.bin";
    if (ctx.force || Stat(ticketPath.c_str(), &theStat)) {
      if (ctx.progressCB)
        ctx.progressCB("ticket.bin", 0.f);
@@ -455,7 +455,7 @@ public:
    }

    /* Extract TMD */
-    SystemString tmdPath = basePathStr + _SYS_STR("/tmd.bin");
+    std::string tmdPath = basePathStr + "/tmd.bin";
    if (ctx.force || Stat(tmdPath.c_str(), &theStat)) {
      if (ctx.progressCB)
        ctx.progressCB("tmd.bin", 0.f);
@@ -466,7 +466,7 @@ public:
    }

    /* Extract Certs */
-    SystemString certPath = basePathStr + _SYS_STR("/cert.bin");
+    std::string certPath = basePathStr + "/cert.bin";
    if (ctx.force || Stat(certPath.c_str(), &theStat)) {
      if (ctx.progressCB)
        ctx.progressCB("cert.bin", 0.f);
@@ -479,7 +479,7 @@ public:
    }

    /* Extract H3 */
-    SystemString h3Path = basePathStr + _SYS_STR("/h3.bin");
+    std::string h3Path = basePathStr + "/h3.bin";
    if (ctx.force || Stat(h3Path.c_str(), &theStat)) {
      if (ctx.progressCB)
        ctx.progressCB("h3.bin", 0.f);
@@ -549,22 +549,22 @@ DiscWii::DiscWii(std::unique_ptr<IDiscIO>&& dio, bool& err) : DiscBase(std::move
  }
 }

-DiscBuilderWii DiscWii::makeMergeBuilder(SystemStringView outPath, bool dualLayer, FProgress progressCB) {
+DiscBuilderWii DiscWii::makeMergeBuilder(std::string_view outPath, bool dualLayer, FProgress progressCB) {
  return DiscBuilderWii(outPath, dualLayer, progressCB);
 }

-bool DiscWii::extractDiscHeaderFiles(SystemStringView basePath, const ExtractionContext& ctx) const {
-  SystemString basePathStr(basePath);
+bool DiscWii::extractDiscHeaderFiles(std::string_view basePath, const ExtractionContext& ctx) const {
+  std::string basePathStr(basePath);

-  if (Mkdir((basePathStr + _SYS_STR("/disc")).c_str(), 0755) && errno != EEXIST) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to mkdir '{}/disc'")), basePathStr);
+  if (Mkdir((basePathStr + "/disc").c_str(), 0755) && errno != EEXIST) {
+    LogModule.report(logvisor::Error, FMT_STRING("unable to mkdir '{}/disc'"), basePathStr);
    return false;
  }

  Sstat theStat;

  /* Extract Header */
-  SystemString headerPath = basePathStr + _SYS_STR("/disc/header.bin");
+  std::string headerPath = basePathStr + "/disc/header.bin";
  if (ctx.force || Stat(headerPath.c_str(), &theStat)) {
    if (ctx.progressCB)
      ctx.progressCB("header.bin", 0.f);
@@ -580,7 +580,7 @@ bool DiscWii::extractDiscHeaderFiles(SystemStringView basePath, const Extraction
  }

  /* Extract Region info */
-  SystemString regionPath = basePathStr + _SYS_STR("/disc/region.bin");
+  std::string regionPath = basePathStr + "/disc/region.bin";
  if (ctx.force || Stat(regionPath.c_str(), &theStat)) {
    if (ctx.progressCB)
      ctx.progressCB("header.bin", 0.f);
@@ -902,7 +902,7 @@ public:
    }* bfWindow = (BFWindow*)(tmdData.get() + 0x19A);
    bool good = false;
    uint64_t attempts = 0;
-    SystemString bfName(_SYS_STR("Brute force attempts"));
+    std::string bfName("Brute force attempts");
    for (int w = 0; w < 7; ++w) {
      for (uint64_t i = 0; i < UINT64_MAX; ++i) {
        bfWindow->word[w] = i;
@@ -930,55 +930,55 @@ public:
    return m_baseOffset + dataOff + groupCount * 0x200000;
  }

-  uint64_t buildFromDirectory(SystemStringView dirIn) {
-    SystemString dirStr(dirIn);
-    SystemString basePath = dirStr + _SYS_STR("/") + getKindString(m_kind);
+  uint64_t buildFromDirectory(std::string_view dirIn) {
+    std::string dirStr(dirIn);
+    std::string basePath = dirStr + "/" + getKindString(m_kind);

    /* Check Ticket */
-    SystemString ticketIn = basePath + _SYS_STR("/ticket.bin");
+    std::string ticketIn = basePath + "/ticket.bin";
    Sstat theStat;
    if (Stat(ticketIn.c_str(), &theStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), ticketIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), ticketIn);
      return -1;
    }

    /* Check TMD */
-    SystemString tmdIn = basePath + _SYS_STR("/tmd.bin");
+    std::string tmdIn = basePath + "/tmd.bin";
    Sstat tmdStat;
    if (Stat(tmdIn.c_str(), &tmdStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), tmdIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), tmdIn);
      return -1;
    }

    /* Check Cert */
-    SystemString certIn = basePath + _SYS_STR("/cert.bin");
+    std::string certIn = basePath + "/cert.bin";
    Sstat certStat;
    if (Stat(certIn.c_str(), &certStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), certIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), certIn);
      return -1;
    }

    /* Check Apploader */
-    SystemString apploaderIn = basePath + _SYS_STR("/sys/apploader.img");
+    std::string apploaderIn = basePath + "/sys/apploader.img";
    Sstat apploaderStat;
    if (Stat(apploaderIn.c_str(), &apploaderStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), apploaderIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), apploaderIn);
      return -1;
    }

    /* Check Boot */
-    SystemString bootIn = basePath + _SYS_STR("/sys/boot.bin");
+    std::string bootIn = basePath + "/sys/boot.bin";
    Sstat bootStat;
    if (Stat(bootIn.c_str(), &bootStat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bootIn);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), bootIn);
      return -1;
    }

    /* Check BI2 */
-    SystemString bi2In = basePath + _SYS_STR("/sys/bi2.bin");
+    std::string bi2In = basePath + "/sys/bi2.bin";
    Sstat bi2Stat;
    if (Stat(bi2In.c_str(), &bi2Stat)) {
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), bi2In);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to stat {}"), bi2In);
      return -1;
    }

@@ -1085,7 +1085,7 @@ public:
        apploaderStat.st_size);
  }

-  uint64_t mergeFromDirectory(const PartitionWii* partIn, SystemStringView dirIn) {
+  uint64_t mergeFromDirectory(const PartitionWii* partIn, std::string_view dirIn) {
    size_t phSz;
    std::unique_ptr<uint8_t[]> phBuf = partIn->readPartitionHeaderBuf(phSz);

@@ -1125,7 +1125,7 @@ public:
        [this, partIn](IPartWriteStream& cws, size_t& xferSz) -> bool {
          std::unique_ptr<uint8_t[]> apploaderBuf = partIn->getApploaderBuf();
          size_t apploaderSz = partIn->getApploaderSize();
-          SystemString apploaderName(_SYS_STR("<apploader>"));
+          std::string apploaderName("<apploader>");
          cws.write(apploaderBuf.get(), apploaderSz);
          xferSz += apploaderSz;
          if (0x2440 + xferSz >= 0x1F0000) {
@@ -1143,9 +1143,9 @@ public:
  }
 };

-EBuildResult DiscBuilderWii::buildFromDirectory(SystemStringView dirIn) {
-  SystemString dirStr(dirIn);
-  SystemString basePath = SystemString(dirStr) + _SYS_STR("/") + getKindString(PartitionKind::Data);
+EBuildResult DiscBuilderWii::buildFromDirectory(std::string_view dirIn) {
+  std::string dirStr(dirIn);
+  std::string basePath = std::string(dirStr) + "/" + getKindString(PartitionKind::Data);

  PartitionBuilderWii& pb = static_cast<PartitionBuilderWii&>(*m_partitions[0]);
  uint64_t filledSz = pb.m_baseOffset;
@@ -1153,10 +1153,10 @@ EBuildResult DiscBuilderWii::buildFromDirectory(SystemStringView dirIn) {
    return EBuildResult::Failed;

  if (!CheckFreeSpace(m_outPath.c_str(), m_discCapacity)) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_outPath);
+    LogModule.report(logvisor::Error, FMT_STRING("not enough free disk space for {}"), m_outPath);
    return EBuildResult::DiskFull;
  }
-  m_progressCB(getProgressFactor(), _SYS_STR("Preallocating image"), -1);
+  m_progressCB(getProgressFactor(), "Preallocating image", -1);
  ++m_progressIdx;
  {
    std::unique_ptr<IFileIO::IWriteStream> ws = m_fileIO->beginWriteStream(0);
@@ -1176,14 +1176,14 @@ EBuildResult DiscBuilderWii::buildFromDirectory(SystemStringView dirIn) {
    return EBuildResult::Failed;
  }

-  m_progressCB(getProgressFactor(), _SYS_STR("Finishing Disc"), -1);
+  m_progressCB(getProgressFactor(), "Finishing Disc", -1);
  ++m_progressIdx;

  /* Populate disc header */
  std::unique_ptr<IFileIO::IWriteStream> ws = m_fileIO->beginWriteStream(0);
  if (!ws)
    return EBuildResult::Failed;
-  SystemString headerPath = basePath + _SYS_STR("/disc/header.bin");
+  std::string headerPath = basePath + "/disc/header.bin";
  std::unique_ptr<IFileIO::IReadStream> rs = NewFileIO(headerPath.c_str())->beginReadStream();
  if (!rs)
    return EBuildResult::Failed;
@@ -1205,7 +1205,7 @@ EBuildResult DiscBuilderWii::buildFromDirectory(SystemStringView dirIn) {
  ws->write(vals, 4);

  /* Populate region info */
-  SystemString regionPath = basePath + _SYS_STR("/disc/region.bin");
+  std::string regionPath = basePath + "/disc/region.bin";
  rs = NewFileIO(regionPath.c_str())->beginReadStream();
  if (!rs)
    return EBuildResult::Failed;
@@ -1235,7 +1235,7 @@ EBuildResult DiscBuilderWii::buildFromDirectory(SystemStringView dirIn) {
  return EBuildResult::Success;
 }

-std::optional<uint64_t> DiscBuilderWii::CalculateTotalSizeRequired(SystemStringView dirIn, bool& dualLayer) {
+std::optional<uint64_t> DiscBuilderWii::CalculateTotalSizeRequired(std::string_view dirIn, bool& dualLayer) {
  std::optional<uint64_t> sz = DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeBuild(dirIn, PartitionKind::Data, true);
  if (!sz)
    return sz;  
@@ -1246,31 +1246,31 @@ std::optional<uint64_t> DiscBuilderWii::CalculateTotalSizeRequired(SystemStringV
  *sz += 0x200000;
  dualLayer = (sz > 0x118240000);
  if (sz > 0x1FB4E0000) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x1FB4E0000);
+    LogModule.report(logvisor::Error, FMT_STRING("disc capacity exceeded [{} / {}]"), *sz, 0x1FB4E0000);
    return std::nullopt;
  }
  return sz;
 }

-DiscBuilderWii::DiscBuilderWii(SystemStringView outPath, bool dualLayer, FProgress progressCB)
+DiscBuilderWii::DiscBuilderWii(std::string_view outPath, bool dualLayer, FProgress progressCB)
 : DiscBuilderBase(outPath, dualLayer ? 0x1FB4E0000 : 0x118240000, progressCB) {
  m_partitions.emplace_back(std::make_unique<PartitionBuilderWii>(*this, PartitionKind::Data, 0x200000));
 }

-DiscMergerWii::DiscMergerWii(SystemStringView outPath, DiscWii& sourceDisc, bool dualLayer, FProgress progressCB)
+DiscMergerWii::DiscMergerWii(std::string_view outPath, DiscWii& sourceDisc, bool dualLayer, FProgress progressCB)
 : m_sourceDisc(sourceDisc), m_builder(sourceDisc.makeMergeBuilder(outPath, dualLayer, progressCB)) {}

-EBuildResult DiscMergerWii::mergeFromDirectory(SystemStringView dirIn) {
+EBuildResult DiscMergerWii::mergeFromDirectory(std::string_view dirIn) {
  PartitionBuilderWii& pb = static_cast<PartitionBuilderWii&>(*m_builder.m_partitions[0]);
  uint64_t filledSz = pb.m_baseOffset;
  if (!m_builder.m_fileIO->beginWriteStream())
    return EBuildResult::Failed;

  if (!CheckFreeSpace(m_builder.m_outPath.c_str(), m_builder.m_discCapacity)) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("not enough free disk space for {}")), m_builder.m_outPath);
+    LogModule.report(logvisor::Error, FMT_STRING("not enough free disk space for {}"), m_builder.m_outPath);
    return EBuildResult::DiskFull;
  }
-  m_builder.m_progressCB(m_builder.getProgressFactor(), _SYS_STR("Preallocating image"), -1);
+  m_builder.m_progressCB(m_builder.getProgressFactor(), "Preallocating image", -1);
  ++m_builder.m_progressIdx;
  {
    std::unique_ptr<IFileIO::IWriteStream> ws = m_builder.m_fileIO->beginWriteStream(0);
@@ -1290,7 +1290,7 @@ EBuildResult DiscMergerWii::mergeFromDirectory(SystemStringView dirIn) {
    return EBuildResult::Failed;
  }

-  m_builder.m_progressCB(m_builder.getProgressFactor(), _SYS_STR("Finishing Disc"), -1);
+  m_builder.m_progressCB(m_builder.getProgressFactor(), "Finishing Disc", -1);
  ++m_builder.m_progressIdx;

  /* Populate disc header */
@@ -1342,7 +1342,7 @@ EBuildResult DiscMergerWii::mergeFromDirectory(SystemStringView dirIn) {
  return EBuildResult::Success;
 }

-std::optional<uint64_t> DiscMergerWii::CalculateTotalSizeRequired(DiscWii& sourceDisc, SystemStringView dirIn, bool& dualLayer) {
+std::optional<uint64_t> DiscMergerWii::CalculateTotalSizeRequired(DiscWii& sourceDisc, std::string_view dirIn, bool& dualLayer) {
  std::optional<uint64_t> sz = DiscBuilderBase::PartitionBuilderBase::CalculateTotalSizeMerge(sourceDisc.getDataPartition(), dirIn);
  if (!sz)
    return std::nullopt;
@@ -1353,7 +1353,7 @@ std::optional<uint64_t> DiscMergerWii::CalculateTotalSizeRequired(DiscWii& sourc
  *sz += 0x200000;
  dualLayer = (sz > 0x118240000);
  if (sz > 0x1FB4E0000) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("disc capacity exceeded [{} / {}]")), *sz, 0x1FB4E0000);
+    LogModule.report(logvisor::Error, FMT_STRING("disc capacity exceeded [{} / {}]"), *sz, 0x1FB4E0000);
    return std::nullopt;
  }
  return sz;
--- a/lib/FileIOFILE.cpp
+++ b/lib/FileIOFILE.cpp
@@ -11,14 +11,14 @@
 namespace nod {

 class FileIOFILE : public IFileIO {
-  SystemString m_path;
+  std::string m_path;
  int64_t m_maxWriteSize;

 public:
-  FileIOFILE(SystemStringView path, int64_t maxWriteSize) : m_path(path), m_maxWriteSize(maxWriteSize) {}
+  FileIOFILE(std::string_view path, int64_t maxWriteSize) : m_path(path), m_maxWriteSize(maxWriteSize) {}

  bool exists() override {
-    FILE* fp = Fopen(m_path.c_str(), _SYS_STR("rb"));
+    FILE* fp = Fopen(m_path.c_str(), "rb");
    if (!fp)
      return false;
    fclose(fp);
@@ -26,7 +26,7 @@ public:
  }

  uint64_t size() override {
-    FILE* fp = Fopen(m_path.c_str(), _SYS_STR("rb"));
+    FILE* fp = Fopen(m_path.c_str(), "rb");
    if (!fp)
      return 0;
    FSeek(fp, 0, SEEK_END);
@@ -38,33 +38,33 @@ public:
  struct WriteStream : public IFileIO::IWriteStream {
    FILE* fp;
    int64_t m_maxWriteSize;
-    WriteStream(SystemStringView path, int64_t maxWriteSize, bool& err) : m_maxWriteSize(maxWriteSize) {
-      fp = Fopen(path.data(), _SYS_STR("wb"));
+    WriteStream(std::string_view path, int64_t maxWriteSize, bool& err) : m_maxWriteSize(maxWriteSize) {
+      fp = Fopen(path.data(), "wb");
      if (!fp) {
-        LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
+        LogModule.report(logvisor::Error, FMT_STRING("unable to open '{}' for writing"), path);
        err = true;
      }
    }
-    WriteStream(SystemStringView path, uint64_t offset, int64_t maxWriteSize, bool& err)
+    WriteStream(std::string_view path, uint64_t offset, int64_t maxWriteSize, bool& err)
    : m_maxWriteSize(maxWriteSize) {
-      fp = Fopen(path.data(), _SYS_STR("ab"));
+      fp = Fopen(path.data(), "ab");
      if (!fp)
        goto FailLoc;
      fclose(fp);
-      fp = Fopen(path.data(), _SYS_STR("r+b"));
+      fp = Fopen(path.data(), "r+b");
      if (!fp)
        goto FailLoc;
      FSeek(fp, offset, SEEK_SET);
      return;
    FailLoc:
-      LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
+      LogModule.report(logvisor::Error, FMT_STRING("unable to open '{}' for writing"), path);
      err = true;
    }
    ~WriteStream() override { fclose(fp); }
    uint64_t write(const void* buf, uint64_t length) override {
      if (m_maxWriteSize >= 0) {
        if (FTell(fp) + length > m_maxWriteSize) {
-          LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("write operation exceeds file's {}-byte limit")),
+          LogModule.report(logvisor::Error, FMT_STRING("write operation exceeds file's {}-byte limit"),
                           m_maxWriteSize);
          return 0;
        }
@@ -95,14 +95,14 @@ public:

  struct ReadStream : public IFileIO::IReadStream {
    FILE* fp;
-    ReadStream(SystemStringView path, bool& err) {
-      fp = Fopen(path.data(), _SYS_STR("rb"));
+    ReadStream(std::string_view path, bool& err) {
+      fp = Fopen(path.data(), "rb");
      if (!fp) {
        err = true;
-        LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for reading")), path);
+        LogModule.report(logvisor::Error, FMT_STRING("unable to open '{}' for reading"), path);
      }
    }
-    ReadStream(SystemStringView path, uint64_t offset, bool& err) : ReadStream(path, err) {
+    ReadStream(std::string_view path, uint64_t offset, bool& err) : ReadStream(path, err) {
      if (err)
        return;
      FSeek(fp, offset, SEEK_SET);
@@ -152,7 +152,7 @@ public:
  }
 };

-std::unique_ptr<IFileIO> NewFileIO(SystemStringView path, int64_t maxWriteSize) {
+std::unique_ptr<IFileIO> NewFileIO(std::string_view path, int64_t maxWriteSize) {
  return std::make_unique<FileIOFILE>(path, maxWriteSize);
 }

--- a/lib/FileIOWin32.cpp
+++ b/lib/FileIOWin32.cpp
@@ -8,21 +8,26 @@

 #include <logvisor/logvisor.hpp>

+#include <nowide/convert.hpp>
+#include <nowide/stackstring.hpp>
+
 namespace nod {

 class FileIOWin32 : public IFileIO {
-  SystemString m_path;
+  std::wstring m_wpath;
  int64_t m_maxWriteSize;

 public:
-  FileIOWin32(SystemStringView path, int64_t maxWriteSize) : m_path(path), m_maxWriteSize(maxWriteSize) {}
+  FileIOWin32(std::string_view path, int64_t maxWriteSize)
+  : m_wpath(nowide::widen(path))
+  , m_maxWriteSize(maxWriteSize) {}

  bool exists() override {
 #if !WINDOWS_STORE
-    HANDLE fp = CreateFileW(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+    HANDLE fp = CreateFileW(m_wpath.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
                            FILE_ATTRIBUTE_NORMAL, nullptr);
 #else
-    HANDLE fp = CreateFile2(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+    HANDLE fp = CreateFile2(m_path.get(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
 #endif
    if (fp == INVALID_HANDLE_VALUE)
      return false;
@@ -32,10 +37,10 @@ public:

  uint64_t size() override {
 #if !WINDOWS_STORE
-    HANDLE fp = CreateFileW(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+    HANDLE fp = CreateFileW(m_wpath.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
                            FILE_ATTRIBUTE_NORMAL, nullptr);
 #else
-    HANDLE fp = CreateFile2(m_path.c_str(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+    HANDLE fp = CreateFile2(m_path.get(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
 #endif
    if (fp == INVALID_HANDLE_VALUE)
      return 0;
@@ -51,28 +56,30 @@ public:
  struct WriteStream : public IFileIO::IWriteStream {
    HANDLE fp;
    int64_t m_maxWriteSize;
-    WriteStream(SystemStringView path, int64_t maxWriteSize, bool& err) : m_maxWriteSize(maxWriteSize) {
+    WriteStream(std::wstring_view wpath, int64_t maxWriteSize, bool& err) : m_maxWriteSize(maxWriteSize) {
 #if !WINDOWS_STORE
-      fp = CreateFileW(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
+      fp = CreateFileW(wpath.data(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
                       nullptr);
 #else
-      fp = CreateFile2(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, CREATE_ALWAYS, nullptr);
+      fp = CreateFile2(wpath.data(), GENERIC_WRITE, FILE_SHARE_WRITE, CREATE_ALWAYS, nullptr);
 #endif
      if (fp == INVALID_HANDLE_VALUE) {
-        LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
+        const nowide::stackstring path(wpath.data(), wpath.data() + wpath.size());
+        LogModule.report(logvisor::Error, FMT_STRING("unable to open '{}' for writing"), path.get());
        err = true;
      }
    }
-    WriteStream(SystemStringView path, uint64_t offset, int64_t maxWriteSize, bool& err)
+    WriteStream(std::wstring_view wpath, uint64_t offset, int64_t maxWriteSize, bool& err)
    : m_maxWriteSize(maxWriteSize) {
 #if !WINDOWS_STORE
-      fp = CreateFileW(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL,
+      fp = CreateFileW(wpath.data(), GENERIC_WRITE, FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL,
                       nullptr);
 #else
-      fp = CreateFile2(path.data(), GENERIC_WRITE, FILE_SHARE_WRITE, OPEN_ALWAYS, nullptr);
+      fp = CreateFile2(wpath.data(), GENERIC_WRITE, FILE_SHARE_WRITE, OPEN_ALWAYS, nullptr);
 #endif
      if (fp == INVALID_HANDLE_VALUE) {
-        LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for writing")), path);
+        const nowide::stackstring path(wpath.data(), wpath.data() + wpath.size());
+        LogModule.report(logvisor::Error, FMT_STRING("unable to open '{}' for writing"), path.get());
        err = true;
        return;
      }
@@ -87,7 +94,7 @@ public:
        LARGE_INTEGER res;
        SetFilePointerEx(fp, li, &res, FILE_CURRENT);
        if (res.QuadPart + int64_t(length) > m_maxWriteSize) {
-          LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("write operation exceeds file's {}-byte limit")),
+          LogModule.report(logvisor::Error, FMT_STRING("write operation exceeds file's {}-byte limit"),
                           m_maxWriteSize);
          return 0;
        }
@@ -100,7 +107,7 @@ public:
  };
  std::unique_ptr<IWriteStream> beginWriteStream() const override {
    bool err = false;
-    auto ret = std::make_unique<WriteStream>(m_path, m_maxWriteSize, err);
+    auto ret = std::make_unique<WriteStream>(m_wpath, m_maxWriteSize, err);

    if (err) {
      return nullptr;
@@ -110,7 +117,7 @@ public:
  }
  std::unique_ptr<IWriteStream> beginWriteStream(uint64_t offset) const override {
    bool err = false;
-    auto ret = std::make_unique<WriteStream>(m_path, offset, m_maxWriteSize, err);
+    auto ret = std::make_unique<WriteStream>(m_wpath, offset, m_maxWriteSize, err);

    if (err) {
      return nullptr;
@@ -121,19 +128,20 @@ public:

  struct ReadStream : public IFileIO::IReadStream {
    HANDLE fp;
-    ReadStream(SystemStringView path, bool& err) {
+    ReadStream(std::wstring_view wpath, bool& err) {
 #if !WINDOWS_STORE
-      fp = CreateFileW(path.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
+      fp = CreateFileW(wpath.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
                       nullptr);
 #else
-      fp = CreateFile2(path.data(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
+      fp = CreateFile2(wpath.data(), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr);
 #endif
      if (fp == INVALID_HANDLE_VALUE) {
        err = true;
-        LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open '{}' for reading")), path);
+        const nowide::stackstring path(wpath.data(), wpath.data() + wpath.size());
+        LogModule.report(logvisor::Error, FMT_STRING("unable to open '{}' for reading"), path.get());
      }
    }
-    ReadStream(SystemStringView path, uint64_t offset, bool& err) : ReadStream(path, err) {
+    ReadStream(std::wstring_view wpath, uint64_t offset, bool& err) : ReadStream(wpath, err) {
      if (err)
        return;
      LARGE_INTEGER lioffset;
@@ -179,7 +187,7 @@ public:

  std::unique_ptr<IReadStream> beginReadStream() const override {
    bool err = false;
-    auto ret = std::make_unique<ReadStream>(m_path, err);
+    auto ret = std::make_unique<ReadStream>(m_wpath, err);

    if (err) {
      return nullptr;
@@ -190,7 +198,7 @@ public:

  std::unique_ptr<IReadStream> beginReadStream(uint64_t offset) const override {
    bool err = false;
-    auto ret = std::make_unique<ReadStream>(m_path, offset, err);
+    auto ret = std::make_unique<ReadStream>(m_wpath, offset, err);

    if (err) {
      return nullptr;
@@ -200,7 +208,7 @@ public:
  }
 };

-std::unique_ptr<IFileIO> NewFileIO(SystemStringView path, int64_t maxWriteSize) {
+std::unique_ptr<IFileIO> NewFileIO(std::string_view path, int64_t maxWriteSize) {
  return std::make_unique<FileIOWin32>(path, maxWriteSize);
 }

--- a/lib/OSUTF.c
+++ b/lib/OSUTF.c
--- a/lib/nod.cpp
+++ b/lib/nod.cpp
@@ -10,15 +10,15 @@ namespace nod {

 logvisor::Module LogModule("nod");

-std::unique_ptr<IDiscIO> NewDiscIOISO(SystemStringView path);
-std::unique_ptr<IDiscIO> NewDiscIOWBFS(SystemStringView path);
-std::unique_ptr<IDiscIO> NewDiscIONFS(SystemStringView path);
+std::unique_ptr<IDiscIO> NewDiscIOISO(std::string_view path);
+std::unique_ptr<IDiscIO> NewDiscIOWBFS(std::string_view path);
+std::unique_ptr<IDiscIO> NewDiscIONFS(std::string_view path);

-std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii) {
+std::unique_ptr<DiscBase> OpenDiscFromImage(std::string_view path, bool& isWii) {
  /* Temporary file handle to determine image type */
  std::unique_ptr<IFileIO> fio = NewFileIO(path);
  if (!fio->exists()) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to open '{}'")), path);
+    LogModule.report(logvisor::Error, FMT_STRING("Unable to open '{}'"), path);
    return {};
  }
  std::unique_ptr<IFileIO::IReadStream> rs = fio->beginReadStream();
@@ -29,19 +29,19 @@ std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii)
  std::unique_ptr<IDiscIO> discIO;
  uint32_t magic = 0;
  if (rs->read(&magic, 4) != 4) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to read magic from '{}'")), path);
+    LogModule.report(logvisor::Error, FMT_STRING("Unable to read magic from '{}'"), path);
    return {};
  }

-  using SignedSize = std::make_signed<SystemString::size_type>::type;
-  const auto dotPos = SignedSize(path.rfind(_SYS_STR('.')));
-  const auto slashPos = SignedSize(path.find_last_of(_SYS_STR("/\\")));
+  using SignedSize = std::make_signed<std::string::size_type>::type;
+  const auto dotPos = SignedSize(path.rfind('.'));
+  const auto slashPos = SignedSize(path.find_last_of("/\\"));
  if (magic == nod::SBig((uint32_t)'WBFS')) {
    discIO = NewDiscIOWBFS(path);
    isWii = true;
  } else if (path.size() > 4 && dotPos != -1 && dotPos > slashPos &&
-             !path.compare(slashPos + 1, 4, _SYS_STR("hif_")) &&
-             !path.compare(dotPos, path.size() - dotPos, _SYS_STR(".nfs"))) {
+             !path.compare(slashPos + 1, 4, "hif_") &&
+             !path.compare(dotPos, path.size() - dotPos, ".nfs")) {
    discIO = NewDiscIONFS(path);
    isWii = true;
  } else {
@@ -60,7 +60,7 @@ std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii)
  }

  if (!discIO) {
-    LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("'{}' is not a valid image")), path);
+    LogModule.report(logvisor::Error, FMT_STRING("'{}' is not a valid image"), path);
    return {};
  }

@@ -79,7 +79,7 @@ std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path, bool& isWii)
  return ret;
 }

-std::unique_ptr<DiscBase> OpenDiscFromImage(SystemStringView path) {
+std::unique_ptr<DiscBase> OpenDiscFromImage(std::string_view path) {
  bool isWii;
  return OpenDiscFromImage(path, isWii);
 }
--- a/lib/sha1.c
+++ b/lib/sha1.c
@@ -17,7 +17,7 @@
 # endif
 #else // ! defined __LITTLE_ENDIAN__
 #ifndef _WIN32
-# include <machine/endian.h>
+# include <endian.h> // machine/endian.h
 #endif
 # if __BYTE_ORDER__ ==  __ORDER_BIG_ENDIAN__
 #  define SHA_BIG_ENDIAN
--- a/2
+++ b/2
Author	SHA1	Message	Date
Phillip Stephens	2288e71605	Fix OSUTF8to32	2021-07-10 19:40:39 -07:00
Luke Street	0396cf467b	Restore C++17 compatibility	2021-06-30 17:00:42 -04:00
Luke Street	0985c63958	Fix compile errors/typos; update logvisor	2021-06-30 16:22:50 -04:00
Luke Street	c1635245b8	Use UTF-8 exclusively internally; replace iconv with OSUTF Filenames are now unconditionally encoded/decoded as Shift-JIS, which provides a reasonable fallback to 7-bit ASCII.	2021-06-30 13:47:10 -04:00
Phillip Stephens	a525f60775	Assume CP_USA_ASCII by default in Node as well	2021-06-27 10:56:43 -07:00
Phillip Stephens	8127bddb97	Merge branch 'Minty-Meeo-Shift-JIS-fixes'	2021-06-27 10:46:57 -07:00
Minty-Meeo	3c25647b6e	The Encoding Update While Nintendo's own documents claim GameCube and Wii disc file symbol tables only support 7-bit ASCII, this is far from the truth. Indeed, even some first-party Nintendo games shipped with Shift-JIS encoded file symbol tables. My guess? The locale of whatever Windows machine mastered a GameCube or Wii disc influenced how wide character strings (UCS-2) were converted to narrow character strings. To account for all possibilites, this update adds extensible multi-byte character set options to NOD-Tool. A rundown of notable changes: - "-c XXXXX" option added to set the encoding of the GameCube / Wii ISO(s) being processed. - "SystemStringConv" renamed to "DiscLocToSystemConv" - "SystemUTF8Conv" renamed to "SystemToDiscLocConv" - Help message updated with new info. - Bugfix: AddBuildName had a logic error wherein the length of the SystemString was being used instead of length of the disc locale string. This would corrupt the File Symbol Table if the disc locale string's length was greater than the SystemString's length. - Bugfix: recursiveMergeFST was not keeping track of parent indexes at all, meaning nested folders and their contents would be corrupted. I simply copied the way recursiveBuildFST did things to fix this. - Bugfix (Windows): On Windows, for some reason, Sstat was a typedef for _stat (32-bit) instead of _stat64 (64-bit). This is confounding, because untrimmed Wii ISOs will always be larger than the unsigned 32-bit integer limit (4,699,979,776 bytes vs 4,294,967,295 bytes), meaning the MergeWii errand has never worked for untrimmed ISOs on Windows. Was this never tested?? - Bugfix (Windows): Did you know Windows Command Prompt fully supports Unicode? Stdio streams are now in _O_U16TEXT mode for Windows only. Previously, attempting to print any character that could not be narrowed to your locale's encoding would either silently fail (std functions), or throw an exception (fmt functions). As a minor drawback, narrow character print functions can no longer be used when stdio is in _O_U16TEXT mode, necessitating my PR for Logvisor here: (AxioDL/logvisor#7) - ExtractionContext::progressCB now uses SystemStringView because widechar printing works correctly on Windows now. - progFunc lambda no longer throws exceptions when printing unicode because widechar printing works correctly on Windows now. - Top-level constructors and functions with a Codepage_t parameter have also signatures that default to the US-ASCII codepage. - DiscGCN constructor - DiscBuilderGCN constructor - DiscBuilderGCN::CalculateTotalSizeRequired - DiscMergerGCN constructor - DiscMergerGCN::CalculateTotalSizeRequired - DiscWii constructor - DiscBuilderWii constructor - DiscBuilderWii::CalculateTotalSizeRequired - DiscMergerWii constructor - DiscMergerWii::CalculateTotalSizeRequired - OpenDiscFromImage - Conversion between system encoding and disc locale encoding has checks in place to warn the user if string conversion goes awry.	2021-06-27 03:26:20 -05:00
Phillip Stephens	3eccde013d	Update logvisor	2021-06-19 14:44:24 -07:00
Henrique Gemignani Passos Lima	ab8f4c3990	Update logvisor	2021-06-19 13:53:45 +03:00
Phillip Stephens	6a231004b1	Update logvisor	2021-05-07 23:21:10 -07:00
Luke Street	d14b798b5f	Don't install within add_subdirectory; update logvisor	2021-04-13 10:34:57 -04:00
Luke Street	1f110f3549	Update logvisor	2021-04-12 15:54:07 -04:00
Luke Street	311d20532e	Update logvisor	2021-04-06 17:57:07 -04:00
Luke Street	8fdc893c86	Update logvisor; set submodule tracking branch	2021-04-06 12:48:38 -04:00
Luke Street	fdc8be487d	Update logvisor	2021-04-05 16:31:21 -04:00
Luke Street	3a21961a4e	Update logvisor	2021-04-05 13:26:39 -04:00
Luke Street	da399b5b67	Update logvisor	2021-04-05 12:06:30 -04:00
Luke Street	11c734be47	Update logvisor	2021-04-04 18:23:33 -04:00
Phillip Stephens	364787604d	Update logivisor	2021-04-03 10:28:23 -07:00
Luke Street	02c188497a	Fixes for Apple Silicon - Only include cpuid.h for x86 - Only set -maes flag for x86	2021-01-06 20:32:21 -05:00
Phillip Stephens	d53d677038	Merge commit '5b1b6f6'	2020-12-31 13:59:27 -08:00
Phillip Stephens	5b1b6f6f80	Update logvisor	2020-12-31 13:58:57 -08:00
Luke Street	393a11ffb5	Update CMakeLists for individual build	2020-05-31 17:23:01 -04:00