[vcpkg] Push use of UTF-16 to only around Win32 call boundaries.

48 files changed, 592 insertions, 404 deletions

diff --git a/toolsrc/include/pch.h b/toolsrc/include/pch.h
index 8333eb927..5c31fbbd1 100644
--- a/toolsrc/include/pch.h
+++ b/toolsrc/include/pch.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#if defined(_WIN32)
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
 
@@ -9,6 +10,13 @@
 #pragma warning(suppress : 4768)
 #include <Shlobj.h>
 
+#include <process.h>
+#include <shellapi.h>
+#include <winhttp.h>
+#else
+#include <unistd.h>
+#endif
+
 #include <algorithm>
 #include <array>
 #include <atomic>
@@ -19,7 +27,12 @@
 #include <cstdarg>
 #include <cstddef>
 #include <cstdint>
+#if defined(_WIN32)
 #include <filesystem>
+#else
+#include <experimental/filesystem>
+#endif
+#include <cstring>
 #include <fstream>
 #include <functional>
 #include <iomanip>
@@ -28,18 +41,17 @@
 #include <map>
 #include <memory>
 #include <mutex>
-#include <process.h>
 #include <regex>
 #include <set>
-#include <shellapi.h>
 #include <stdexcept>
 #include <string>
 #include <sys/timeb.h>
+#include <sys/types.h>
 #include <system_error>
+#include <thread>
 #include <time.h>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <winhttp.h>
diff --git a/toolsrc/include/vcpkg/base/cstringview.h b/toolsrc/include/vcpkg/base/cstringview.h
index 341830f05..eac204f97 100644
--- a/toolsrc/include/vcpkg/base/cstringview.h
+++ b/toolsrc/include/vcpkg/base/cstringview.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <string.h>
 #include <string>
 
 namespace vcpkg
diff --git a/toolsrc/include/vcpkg/base/expected.h b/toolsrc/include/vcpkg/base/expected.h
index a946c442e..b3b81ae81 100644
--- a/toolsrc/include/vcpkg/base/expected.h
+++ b/toolsrc/include/vcpkg/base/expected.h
@@ -33,7 +33,7 @@ namespace vcpkg
         ErrorHolder() = default;
         ErrorHolder(const std::error_code& err) : m_err(err) {}
 
-        constexpr bool has_error() const { return bool(m_err); }
+        bool has_error() const { return bool(m_err); }
 
         const std::error_code& error() const { return m_err; }
         std::error_code& error() { return m_err; }
diff --git a/toolsrc/include/vcpkg/base/files.h b/toolsrc/include/vcpkg/base/files.h
index f4bcf742c..63cf3c6fd 100644
--- a/toolsrc/include/vcpkg/base/files.h
+++ b/toolsrc/include/vcpkg/base/files.h
@@ -2,7 +2,11 @@
 
 #include <vcpkg/base/expected.h>
 
+#if defined(_WIN32)
 #include <filesystem>
+#else
+#include <experimental/filesystem>
+#endif
 
 namespace fs
 {
@@ -19,7 +23,7 @@ namespace fs
 
 namespace vcpkg::Files
 {
-    __interface Filesystem
+    struct Filesystem
     {
         virtual Expected<std::string> read_contents(const fs::path& file_path) const = 0;
         virtual Expected<std::vector<std::string>> read_lines(const fs::path& file_path) const = 0;
@@ -40,8 +44,10 @@ namespace vcpkg::Files
         virtual bool create_directory(const fs::path& path, std::error_code& ec) = 0;
         virtual bool create_directories(const fs::path& path, std::error_code& ec) = 0;
         virtual void copy(const fs::path& oldpath, const fs::path& newpath, fs::copy_options opts) = 0;
-        virtual bool copy_file(
-            const fs::path& oldpath, const fs::path& newpath, fs::copy_options opts, std::error_code& ec) = 0;
+        virtual bool copy_file(const fs::path& oldpath,
+                               const fs::path& newpath,
+                               fs::copy_options opts,
+                               std::error_code& ec) = 0;
         virtual fs::file_status status(const fs::path& path, std::error_code& ec) const = 0;
     };
 
@@ -53,5 +59,5 @@ namespace vcpkg::Files
 
     void print_paths(const std::vector<fs::path>& paths);
 
-    std::vector<fs::path> find_from_PATH(const std::wstring& name);
+    std::vector<fs::path> find_from_PATH(const std::string& name);
 }
diff --git a/toolsrc/include/vcpkg/base/graphs.h b/toolsrc/include/vcpkg/base/graphs.h
index ff56cb298..b585d2bb9 100644
--- a/toolsrc/include/vcpkg/base/graphs.h
+++ b/toolsrc/include/vcpkg/base/graphs.h
@@ -20,11 +20,11 @@ namespace vcpkg::Graphs
     };
 
     template<class V, class U>
-    __interface AdjacencyProvider
+    struct AdjacencyProvider
     {
-        std::vector<V> adjacency_list(const U& vertex) const;
+        virtual std::vector<V> adjacency_list(const U& vertex) const = 0;
 
-        U load_vertex_data(const V& vertex) const;
+        virtual U load_vertex_data(const V& vertex) const = 0;
     };
 
     template<class V, class U>
diff --git a/toolsrc/include/vcpkg/base/strings.h b/toolsrc/include/vcpkg/base/strings.h
index 59823deb8..93b36a29d 100644
--- a/toolsrc/include/vcpkg/base/strings.h
+++ b/toolsrc/include/vcpkg/base/strings.h
@@ -16,15 +16,11 @@ namespace vcpkg::Strings::details
 
     inline const char* to_printf_arg(const char* s) { return s; }
 
-    inline int to_printf_arg(const int s) { return s; }
-
-    inline long long to_printf_arg(const long long s) { return s; }
-
-    inline unsigned long to_printf_arg(const unsigned long s) { return s; }
-
-    inline size_t to_printf_arg(const size_t s) { return s; }
-
-    inline double to_printf_arg(const double s) { return s; }
+    template<class T, class = std::enable_if_t<std::is_arithmetic<T>::value>>
+    inline T to_printf_arg(T s)
+    {
+        return s;
+    }
 
     std::string format_internal(const char* fmtstr, ...);
 
@@ -37,9 +33,6 @@ namespace vcpkg::Strings::details
 
 namespace vcpkg::Strings
 {
-    static constexpr const char* EMPTY = "";
-    static constexpr const wchar_t* WEMPTY = L"";
-
     template<class... Args>
     std::string format(const char* fmtstr, const Args&... args)
     {
@@ -62,7 +55,7 @@ namespace vcpkg::Strings
 
     bool case_insensitive_ascii_contains(const std::string& s, const std::string& pattern);
 
-    bool case_insensitive_ascii_compare(const CStringView left, const CStringView right);
+    bool case_insensitive_ascii_equals(const CStringView left, const CStringView right);
 
     std::string ascii_to_lowercase(const std::string& input);
 
diff --git a/toolsrc/include/vcpkg/base/system.h b/toolsrc/include/vcpkg/base/system.h
index a2e8f3f45..f2344c919 100644
--- a/toolsrc/include/vcpkg/base/system.h
+++ b/toolsrc/include/vcpkg/base/system.h
@@ -4,7 +4,6 @@
 #include <vcpkg/base/optional.h>
 #include <vcpkg/base/strings.h>
 
-#include <Windows.h>
 
 namespace vcpkg::System
 {
@@ -18,13 +17,13 @@ namespace vcpkg::System
         std::string output;
     };
 
-    int cmd_execute_clean(const CWStringView cmd_line);
+    int cmd_execute_clean(const CStringView cmd_line);
 
-    int cmd_execute(const CWStringView cmd_line);
+    int cmd_execute(const CStringView cmd_line);
 
-    ExitCodeAndOutput cmd_execute_and_capture_output(const CWStringView cmd_line);
+    ExitCodeAndOutput cmd_execute_and_capture_output(const CStringView cmd_line);
 
-    std::wstring create_powershell_script_cmd(const fs::path& script_path, const CWStringView args = Strings::WEMPTY);
+    std::string create_powershell_script_cmd(const fs::path& script_path, const CStringView args = "");
 
     enum class Color
     {
@@ -63,9 +62,11 @@ namespace vcpkg::System
         return System::println(c, Strings::format(messageTemplate, messageArg1, messageArgs...));
     }
 
-    Optional<std::wstring> get_environment_variable(const CWStringView varname) noexcept;
+    Optional<std::string> get_environment_variable(const CStringView varname) noexcept;
 
-    Optional<std::wstring> get_registry_string(HKEY base, const CWStringView subkey, const CWStringView valuename);
+    Optional<std::wstring> get_registry_string(void* base_hkey,
+                                               const CWStringView subkey,
+                                               const CWStringView valuename);
 
     enum class CPUArchitecture
     {
diff --git a/toolsrc/include/vcpkg/base/util.h b/toolsrc/include/vcpkg/base/util.h
index 4f06a8231..d5db6b6ee 100644
--- a/toolsrc/include/vcpkg/base/util.h
+++ b/toolsrc/include/vcpkg/base/util.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <map>
 #include <mutex>
 #include <utility>
@@ -98,7 +99,7 @@ namespace vcpkg::Util
     }
 
     template<class K, class V, class Container, class Func>
-    void group_by(const Container& cont, _Inout_ std::map<K, std::vector<const V*>>* output, Func&& f)
+    void group_by(const Container& cont, std::map<K, std::vector<const V*>>* output, Func&& f)
     {
         for (const V& element : cont)
         {
diff --git a/toolsrc/include/vcpkg/build.h b/toolsrc/include/vcpkg/build.h
index f146e9951..774e25922 100644
--- a/toolsrc/include/vcpkg/build.h
+++ b/toolsrc/include/vcpkg/build.h
@@ -96,7 +96,7 @@ namespace vcpkg::Build
         Optional<fs::path> visual_studio_path;
     };
 
-    std::wstring make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset);
+    std::string make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset);
 
     struct ExtendedBuildResult
     {
diff --git a/toolsrc/include/vcpkg/dependencies.h b/toolsrc/include/vcpkg/dependencies.h
index 2301dbc36..585338ae2 100644
--- a/toolsrc/include/vcpkg/dependencies.h
+++ b/toolsrc/include/vcpkg/dependencies.h
@@ -115,7 +115,10 @@ namespace vcpkg::Dependencies
         RequestType request_type;
     };
 
-    __interface PortFileProvider { virtual const SourceControlFile& get_control_file(const std::string& spec) const; };
+    struct PortFileProvider
+    {
+        virtual const SourceControlFile& get_control_file(const std::string& spec) const = 0;
+    };
 
     struct MapPortFile : Util::ResourceBase, PortFileProvider
     {
diff --git a/toolsrc/include/vcpkg/packagespec.h b/toolsrc/include/vcpkg/packagespec.h
index ee34f14a3..60c99782e 100644
--- a/toolsrc/include/vcpkg/packagespec.h
+++ b/toolsrc/include/vcpkg/packagespec.h
@@ -76,20 +76,23 @@ namespace vcpkg
     bool operator!=(const PackageSpec& left, const PackageSpec& right);
 }
 
-template<>
-struct std::hash<vcpkg::PackageSpec>
+namespace std
 {
-    size_t operator()(const vcpkg::PackageSpec& value) const
+    template<>
+    struct hash<vcpkg::PackageSpec>
     {
-        size_t hash = 17;
-        hash = hash * 31 + std::hash<std::string>()(value.name());
-        hash = hash * 31 + std::hash<vcpkg::Triplet>()(value.triplet());
-        return hash;
-    }
-};
-
-template<>
-struct std::equal_to<vcpkg::PackageSpec>
-{
-    bool operator()(const vcpkg::PackageSpec& left, const vcpkg::PackageSpec& right) const { return left == right; }
-};
+        size_t operator()(const vcpkg::PackageSpec& value) const
+        {
+            size_t hash = 17;
+            hash = hash * 31 + std::hash<std::string>()(value.name());
+            hash = hash * 31 + std::hash<vcpkg::Triplet>()(value.triplet());
+            return hash;
+        }
+    };
+
+    template<>
+    struct equal_to<vcpkg::PackageSpec>
+    {
+        bool operator()(const vcpkg::PackageSpec& left, const vcpkg::PackageSpec& right) const { return left == right; }
+    };
+}
diff --git a/toolsrc/include/vcpkg/packagespecparseresult.h b/toolsrc/include/vcpkg/packagespecparseresult.h
index 8a56574fd..dd91c9a67 100644
--- a/toolsrc/include/vcpkg/packagespecparseresult.h
+++ b/toolsrc/include/vcpkg/packagespecparseresult.h
@@ -20,7 +20,7 @@ namespace vcpkg
         ErrorHolder() : m_err(PackageSpecParseResult::SUCCESS) {}
         ErrorHolder(PackageSpecParseResult err) : m_err(err) {}
 
-        constexpr bool has_error() const { return m_err != PackageSpecParseResult::SUCCESS; }
+        bool has_error() const { return m_err != PackageSpecParseResult::SUCCESS; }
 
         const PackageSpecParseResult& error() const { return m_err; }
         PackageSpecParseResult& error() { return m_err; }
diff --git a/toolsrc/include/vcpkg/paragraphparseresult.h b/toolsrc/include/vcpkg/paragraphparseresult.h
index abdd9eecd..558715bbc 100644
--- a/toolsrc/include/vcpkg/paragraphparseresult.h
+++ b/toolsrc/include/vcpkg/paragraphparseresult.h
@@ -26,8 +26,11 @@ namespace vcpkg
     ParagraphParseResult to_paragraph_parse_result(std::error_code ec);
 }
 
-// Enable implicit conversion to std::error_code
-template<>
-struct std::is_error_code_enum<vcpkg::ParagraphParseResult> : ::std::true_type
+namespace std
 {
-};
+    // Enable implicit conversion to std::error_code
+    template<>
+    struct is_error_code_enum<vcpkg::ParagraphParseResult> : ::std::true_type
+    {
+    };
+}
\ No newline at end of file
diff --git a/toolsrc/include/vcpkg/sourceparagraph.h b/toolsrc/include/vcpkg/sourceparagraph.h
index 0a02e4cda..dcbbc1c3b 100644
--- a/toolsrc/include/vcpkg/sourceparagraph.h
+++ b/toolsrc/include/vcpkg/sourceparagraph.h
@@ -3,8 +3,8 @@
 #include <vcpkg/packagespec.h>
 #include <vcpkg/parse.h>
 
-#include <vcpkg/base/Span.h>
 #include <vcpkg/base/expected.h>
+#include <vcpkg/base/span.h>
 #include <vcpkg/base/system.h>
 
 #include <string>
diff --git a/toolsrc/include/vcpkg/triplet.h b/toolsrc/include/vcpkg/triplet.h
index 46a52f8e6..50d731593 100644
--- a/toolsrc/include/vcpkg/triplet.h
+++ b/toolsrc/include/vcpkg/triplet.h
@@ -36,8 +36,11 @@ namespace vcpkg
     bool operator!=(const Triplet& left, const Triplet& right);
 }
 
-template<>
-struct std::hash<vcpkg::Triplet>
+namespace std
 {
-    size_t operator()(const vcpkg::Triplet& t) const { return t.hash_code(); }
-};
+    template<>
+    struct hash<vcpkg::Triplet>
+    {
+        size_t operator()(const vcpkg::Triplet& t) const { return t.hash_code(); }
+    };
+}
\ No newline at end of file
diff --git a/toolsrc/include/vcpkg/vcpkgcmdarguments.h b/toolsrc/include/vcpkg/vcpkgcmdarguments.h
index 8b1d766b6..d9895f4b8 100644
--- a/toolsrc/include/vcpkg/vcpkgcmdarguments.h
+++ b/toolsrc/include/vcpkg/vcpkgcmdarguments.h
@@ -19,7 +19,11 @@ namespace vcpkg
 
     struct VcpkgCmdArguments
     {
+#if defined(_WIN32)
         static VcpkgCmdArguments create_from_command_line(const int argc, const wchar_t* const* const argv);
+#else
+        static VcpkgCmdArguments create_from_command_line(const int argc, const char* const* const argv);
+#endif
         static VcpkgCmdArguments create_from_arg_sequence(const std::string* arg_begin, const std::string* arg_end);
 
         std::unique_ptr<std::string> vcpkg_root_dir;
diff --git a/toolsrc/include/vcpkg/vcpkglib.h b/toolsrc/include/vcpkg/vcpkglib.h
index b2aad8d7b..9a7fdb861 100644
--- a/toolsrc/include/vcpkg/vcpkglib.h
+++ b/toolsrc/include/vcpkg/vcpkglib.h
@@ -22,17 +22,16 @@ namespace vcpkg
 
     struct CMakeVariable
     {
-        CMakeVariable(const CWStringView varname, const wchar_t* varvalue);
-        CMakeVariable(const CWStringView varname, const std::string& varvalue);
-        CMakeVariable(const CWStringView varname, const std::wstring& varvalue);
-        CMakeVariable(const CWStringView varname, const fs::path& path);
+        CMakeVariable(const CStringView varname, const char* varvalue);
+        CMakeVariable(const CStringView varname, const std::string& varvalue);
+        CMakeVariable(const CStringView varname, const fs::path& path);
 
-        std::wstring s;
+        std::string s;
     };
 
-    std::wstring make_cmake_cmd(const fs::path& cmake_exe,
-                                const fs::path& cmake_script,
-                                const std::vector<CMakeVariable>& pass_variables);
+    std::string make_cmake_cmd(const fs::path& cmake_exe,
+                               const fs::path& cmake_script,
+                               const std::vector<CMakeVariable>& pass_variables);
 
     std::string shorten_text(const std::string& desc, size_t length);
 } // namespace vcpkg
diff --git a/toolsrc/include/vcpkg/vcpkgpaths.h b/toolsrc/include/vcpkg/vcpkgpaths.h
index 32dd2e833..781dabd1a 100644
--- a/toolsrc/include/vcpkg/vcpkgpaths.h
+++ b/toolsrc/include/vcpkg/vcpkgpaths.h
@@ -3,15 +3,15 @@
 #include <vcpkg/binaryparagraph.h>
 #include <vcpkg/packagespec.h>
 
-#include <vcpkg/base/Lazy.h>
 #include <vcpkg/base/expected.h>
 #include <vcpkg/base/files.h>
+#include <vcpkg/base/lazy.h>
 
 namespace vcpkg
 {
     struct ToolsetArchOption
     {
-        CWStringView name;
+        CStringView name;
         System::CPUArchitecture host_arch;
         System::CPUArchitecture target_arch;
     };
@@ -21,8 +21,8 @@ namespace vcpkg
         fs::path visual_studio_root_path;
         fs::path dumpbin;
         fs::path vcvarsall;
-        std::vector<std::wstring> vcvarsall_options;
-        CWStringView version;
+        std::vector<std::string> vcvarsall_options;
+        CStringView version;
         std::vector<ToolsetArchOption> supported_architectures;
     };
 
diff --git a/toolsrc/src/vcpkg.cpp b/toolsrc/src/vcpkg.cpp
index f1a86ae22..e1e2240e7 100644
--- a/toolsrc/src/vcpkg.cpp
+++ b/toolsrc/src/vcpkg.cpp
@@ -1,6 +1,15 @@
+#if defined(_WIN32)
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
 
+#pragma warning(push)
+#pragma warning(disable : 4768)
+#include <Shlobj.h>
+#pragma warning(pop)
+#else
+#include <unistd.h>
+#endif
+
 #include <vcpkg/base/chrono.h>
 #include <vcpkg/base/files.h>
 #include <vcpkg/base/strings.h>
@@ -13,10 +22,6 @@
 #include <vcpkg/paragraphs.h>
 #include <vcpkg/vcpkglib.h>
 
-#pragma warning(push)
-#pragma warning(disable : 4768)
-#include <Shlobj.h>
-#pragma warning(pop)
 #include <cassert>
 #include <fstream>
 #include <memory>
@@ -44,7 +49,7 @@ static void inner(const VcpkgCmdArguments& args)
 
     static const auto find_command = [&](auto&& commands) {
         auto it = Util::find_if(commands, [&](auto&& commandc) {
-            return Strings::case_insensitive_ascii_compare(commandc.name, args.command);
+            return Strings::case_insensitive_ascii_equals(commandc.name, args.command);
         });
         using std::end;
         if (it != end(commands))
@@ -67,7 +72,7 @@ static void inner(const VcpkgCmdArguments& args)
     }
     else
     {
-        const Optional<std::wstring> vcpkg_root_dir_env = System::get_environment_variable(L"VCPKG_ROOT");
+        const auto vcpkg_root_dir_env = System::get_environment_variable("VCPKG_ROOT");
         if (const auto v = vcpkg_root_dir_env.get())
         {
             vcpkg_root_dir = fs::stdfs::absolute(*v);
@@ -95,7 +100,11 @@ static void inner(const VcpkgCmdArguments& args)
                        expected_paths.error().message());
     const VcpkgPaths paths = expected_paths.value_or_exit(VCPKG_LINE_INFO);
 
+#if defined(_WIN32)
     const int exit_code = _wchdir(paths.root.c_str());
+#else
+    const int exit_code = chdir(paths.root.c_str());
+#endif
     Checks::check_exit(VCPKG_LINE_INFO, exit_code == 0, "Changing the working dir failed");
     Commands::Version::warn_if_vcpkg_version_mismatch(paths);
 
@@ -111,11 +120,10 @@ static void inner(const VcpkgCmdArguments& args)
     }
     else
     {
-        const Optional<std::wstring> vcpkg_default_triplet_env =
-            System::get_environment_variable(L"VCPKG_DEFAULT_TRIPLET");
+        const auto vcpkg_default_triplet_env = System::get_environment_variable("VCPKG_DEFAULT_TRIPLET");
         if (const auto v = vcpkg_default_triplet_env.get())
         {
-            default_triplet = Triplet::from_canonical_name(Strings::to_utf8(*v));
+            default_triplet = Triplet::from_canonical_name(*v);
         }
         else
         {
@@ -135,6 +143,7 @@ static void inner(const VcpkgCmdArguments& args)
 
 static void load_config()
 {
+#if defined(_WIN32)
     fs::path localappdata;
     {
         // Config path in AppDataLocal
@@ -194,6 +203,7 @@ static void load_config()
     catch (...)
     {
     }
+#endif
 }
 
 static std::string trim_path_from_command_line(const std::string& full_command_line)
@@ -217,24 +227,32 @@ static std::string trim_path_from_command_line(const std::string& full_command_l
     return std::string(it, full_command_line.cend());
 }
 
+#if defined(_WIN32)
 int wmain(const int argc, const wchar_t* const* const argv)
+#else
+int main(const int argc, const char* const* const argv)
+#endif
 {
     if (argc == 0) std::abort();
 
+    *GlobalState::timer.lock() = Chrono::ElapsedTime::create_started();
+
+#if defined(_WIN32)
     GlobalState::g_init_console_cp = GetConsoleCP();
     GlobalState::g_init_console_output_cp = GetConsoleOutputCP();
 
     SetConsoleCP(65001);
     SetConsoleOutputCP(65001);
 
-    *GlobalState::timer.lock() = Chrono::ElapsedTime::create_started();
-
     const std::string trimmed_command_line = trim_path_from_command_line(Strings::to_utf8(GetCommandLineW()));
+#endif
 
     {
         auto locked_metrics = Metrics::g_metrics.lock();
         locked_metrics->track_property("version", Commands::Version::version());
+#if defined(_WIN32)
         locked_metrics->track_property("cmdline", trimmed_command_line);
+#endif
     }
     load_config();
     Metrics::g_metrics.lock()->track_property("sqmuser", Metrics::get_SQM_user());
@@ -283,6 +301,12 @@ int wmain(const int argc, const wchar_t* const* const argv)
                   exc_msg);
     fflush(stdout);
     for (int x = 0; x < argc; ++x)
+    {
+#if defined(_WIN32)
         System::println("%s|", Strings::to_utf8(argv[x]));
+#else
+        System::println("%s|", argv[x]);
+#endif
+    }
     fflush(stdout);
 }
diff --git a/toolsrc/src/vcpkg/base/checks.cpp b/toolsrc/src/vcpkg/base/checks.cpp
index 73c7b9b1a..ed28d6e2b 100644
--- a/toolsrc/src/vcpkg/base/checks.cpp
+++ b/toolsrc/src/vcpkg/base/checks.cpp
@@ -17,14 +17,21 @@ namespace vcpkg::Checks
         GlobalState::debugging = false;
         metrics->flush();
 
+#if defined(_WIN32)
         SetConsoleCP(GlobalState::g_init_console_cp);
         SetConsoleOutputCP(GlobalState::g_init_console_output_cp);
+#endif
 
         fflush(nullptr);
 
+#if defined(_WIN32)
         ::TerminateProcess(::GetCurrentProcess(), exit_code);
+#else
+        ::exit(exit_code);
+#endif
     }
 
+#if defined(_WIN32)
     static BOOL ctrl_handler(DWORD fdw_ctrl_type)
     {
         {
@@ -39,6 +46,9 @@ namespace vcpkg::Checks
     {
         SetConsoleCtrlHandler(reinterpret_cast<PHANDLER_ROUTINE>(ctrl_handler), TRUE);
     }
+#else
+    void register_console_ctrl_handler() {}
+#endif
 
     [[noreturn]] void unreachable(const LineInfo& line_info)
     {
@@ -67,7 +77,7 @@ namespace vcpkg::Checks
     {
         if (!expression)
         {
-            exit_with_message(line_info, Strings::EMPTY);
+            exit_with_message(line_info, "");
         }
     }
 
diff --git a/toolsrc/src/vcpkg/base/cofffilereader.cpp b/toolsrc/src/vcpkg/base/cofffilereader.cpp
index 5e9c86998..1927e0b5e 100644
--- a/toolsrc/src/vcpkg/base/cofffilereader.cpp
+++ b/toolsrc/src/vcpkg/base/cofffilereader.cpp
@@ -7,6 +7,7 @@ using namespace std;
 
 namespace vcpkg::CoffFileReader
 {
+#if defined(_WIN32)
     template<class T>
     static T reinterpret_bytes(const char* data)
     {
@@ -24,7 +25,7 @@ namespace vcpkg::CoffFileReader
     template<class T>
     static T peek_value_from_stream(fstream& fs)
     {
-        const fpos_t original_pos = fs.tellg().seekpos();
+        const std::streampos original_pos = fs.tellg();
         T data;
         fs.read(reinterpret_cast<char*>(&data), sizeof data);
         fs.seekg(original_pos);
@@ -305,4 +306,8 @@ namespace vcpkg::CoffFileReader
 
         return {std::vector<MachineType>(machine_types.cbegin(), machine_types.cend())};
     }
+#else
+    DllInfo read_dll(const fs::path& path) { exit(-1); }
+    LibInfo read_lib(const fs::path& path) { exit(-1); }
+#endif
 }
diff --git a/toolsrc/src/vcpkg/base/files.cpp b/toolsrc/src/vcpkg/base/files.cpp
index f8b239eaa..6e43debb1 100644
--- a/toolsrc/src/vcpkg/base/files.cpp
+++ b/toolsrc/src/vcpkg/base/files.cpp
@@ -163,7 +163,12 @@ namespace vcpkg::Files
         virtual void write_contents(const fs::path& file_path, const std::string& data) override
         {
             FILE* f = nullptr;
+#if defined(_WIN32)
             auto ec = _wfopen_s(&f, file_path.native().c_str(), L"wb");
+#else
+            f = fopen(file_path.native().c_str(), "wb");
+            int ec = f != nullptr ? 0 : 1;
+#endif
             Checks::check_exit(
                 VCPKG_LINE_INFO, ec == 0, "Error: Could not open file for writing: %s", file_path.u8string().c_str());
             auto count = fwrite(data.data(), sizeof(data[0]), data.size(), f);
@@ -194,9 +199,13 @@ namespace vcpkg::Files
         System::println();
     }
 
-    std::vector<fs::path> find_from_PATH(const std::wstring& name)
+    std::vector<fs::path> find_from_PATH(const std::string& name)
     {
-        const std::wstring cmd = Strings::wformat(L"where.exe %s", name);
+#if defined(_WIN32)
+        const std::string cmd = Strings::format("where.exe %s", name);
+#else
+        const std::string cmd = Strings::format("which %s", name);
+#endif
         auto out = System::cmd_execute_and_capture_output(cmd);
         if (out.exit_code != 0)
         {
diff --git a/toolsrc/src/vcpkg/base/strings.cpp b/toolsrc/src/vcpkg/base/strings.cpp
index 2a6d3dff2..fa04279b9 100644
--- a/toolsrc/src/vcpkg/base/strings.cpp
+++ b/toolsrc/src/vcpkg/base/strings.cpp
@@ -37,7 +37,8 @@ namespace vcpkg::Strings::details
 #if defined(_WIN32)
         _vsnprintf_s_l(&output.at(0), output.size() + 1, output.size(), fmtstr, c_locale(), args);
 #else
-        vsnprintf(&output.at(0), output.size() + 1, fmtstr, args);
+        va_start(args, fmtstr);
+        auto res = vsnprintf(&output.at(0), output.size() + 1, fmtstr, args);
 #endif
         va_end(args);
 
@@ -73,20 +74,28 @@ namespace vcpkg::Strings
 {
     std::wstring to_utf16(const CStringView s)
     {
+#if defined(_WIN32)
         const int size = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, nullptr, 0);
         std::wstring output;
         output.resize(size - 1);
         MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, output.data(), size - 1);
         return output;
+#else
+        Checks::unreachable(VCPKG_LINE_INFO);
+#endif
     }
 
     std::string to_utf8(const CWStringView w)
     {
+#if defined(_WIN32)
         const int size = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, nullptr, 0, nullptr, nullptr);
         std::string output;
         output.resize(size - 1);
         WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, output.data(), size - 1, nullptr, nullptr);
         return output;
+#else
+        Checks::unreachable(VCPKG_LINE_INFO);
+#endif
     }
 
     std::string::const_iterator case_insensitive_ascii_find(const std::string& s, const std::string& pattern)
@@ -104,9 +113,13 @@ namespace vcpkg::Strings
         return case_insensitive_ascii_find(s, pattern) != s.end();
     }
 
-    bool case_insensitive_ascii_compare(const CStringView left, const CStringView right)
+    bool case_insensitive_ascii_equals(const CStringView left, const CStringView right)
     {
+#if defined(_WIN32)
         return _stricmp(left.c_str(), right.c_str()) == 0;
+#else
+        return strcasecmp(left.c_str(), right.c_str()) == 0;
+#endif
     }
 
     std::string ascii_to_lowercase(const std::string& input)
@@ -118,7 +131,11 @@ namespace vcpkg::Strings
 
     bool case_insensitive_ascii_starts_with(const std::string& s, const std::string& pattern)
     {
+#if defined(_WIN32)
         return _strnicmp(s.c_str(), pattern.c_str(), pattern.size()) == 0;
+#else
+        return strncasecmp(s.c_str(), pattern.c_str(), pattern.size()) == 0;
+#endif
     }
 
     void trim(std::string* s)
diff --git a/toolsrc/src/vcpkg/base/system.cpp b/toolsrc/src/vcpkg/base/system.cpp
index d5d39461c..e92d06f6e 100644
--- a/toolsrc/src/vcpkg/base/system.cpp
+++ b/toolsrc/src/vcpkg/base/system.cpp
@@ -4,6 +4,8 @@
 #include <vcpkg/base/system.h>
 #include <vcpkg/globalstate.h>
 
+#include <time.h>
+
 #pragma comment(lib, "Advapi32")
 
 namespace vcpkg::System
@@ -13,35 +15,46 @@ namespace vcpkg::System
         using std::chrono::system_clock;
         std::time_t now_time = system_clock::to_time_t(system_clock::now());
         tm parts;
+#if defined(_WIN32)
         localtime_s(&parts, &now_time);
+#else
+        parts = *localtime(&now_time);
+#endif
         return parts;
     }
 
     fs::path get_exe_path_of_current_process()
     {
+#if defined(_WIN32)
         wchar_t buf[_MAX_PATH];
         const int bytes = GetModuleFileNameW(nullptr, buf, _MAX_PATH);
         if (bytes == 0) std::abort();
         return fs::path(buf, buf + bytes);
+#else
+        std::array<char, 1024 * 4> buf;
+        auto written = readlink("/proc/self/exe", buf.data(), buf.size());
+        Checks::check_exit(VCPKG_LINE_INFO, written != -1, "Could not determine current executable path.");
+        return fs::path(buf.data(), buf.data() + written);
+#endif
     }
 
     Optional<CPUArchitecture> to_cpu_architecture(CStringView arch)
     {
-        if (Strings::case_insensitive_ascii_compare(arch, "x86")) return CPUArchitecture::X86;
-        if (Strings::case_insensitive_ascii_compare(arch, "x64")) return CPUArchitecture::X64;
-        if (Strings::case_insensitive_ascii_compare(arch, "amd64")) return CPUArchitecture::X64;
-        if (Strings::case_insensitive_ascii_compare(arch, "arm")) return CPUArchitecture::ARM;
-        if (Strings::case_insensitive_ascii_compare(arch, "arm64")) return CPUArchitecture::ARM64;
+        if (Strings::case_insensitive_ascii_equals(arch, "x86")) return CPUArchitecture::X86;
+        if (Strings::case_insensitive_ascii_equals(arch, "x64")) return CPUArchitecture::X64;
+        if (Strings::case_insensitive_ascii_equals(arch, "amd64")) return CPUArchitecture::X64;
+        if (Strings::case_insensitive_ascii_equals(arch, "arm")) return CPUArchitecture::ARM;
+        if (Strings::case_insensitive_ascii_equals(arch, "arm64")) return CPUArchitecture::ARM64;
         return nullopt;
     }
 
     CPUArchitecture get_host_processor()
     {
-        auto w6432 = get_environment_variable(L"PROCESSOR_ARCHITEW6432");
-        if (const auto p = w6432.get()) return to_cpu_architecture(Strings::to_utf8(*p)).value_or_exit(VCPKG_LINE_INFO);
+        auto w6432 = get_environment_variable("PROCESSOR_ARCHITEW6432");
+        if (const auto p = w6432.get()) return to_cpu_architecture(*p).value_or_exit(VCPKG_LINE_INFO);
 
-        const auto procarch = get_environment_variable(L"PROCESSOR_ARCHITECTURE").value_or_exit(VCPKG_LINE_INFO);
-        return to_cpu_architecture(Strings::to_utf8(procarch)).value_or_exit(VCPKG_LINE_INFO);
+        const auto procarch = get_environment_variable("PROCESSOR_ARCHITECTURE").value_or_exit(VCPKG_LINE_INFO);
+        return to_cpu_architecture(procarch).value_or_exit(VCPKG_LINE_INFO);
     }
 
     std::vector<CPUArchitecture> get_supported_host_architectures()
@@ -58,12 +71,13 @@ namespace vcpkg::System
         return supported_architectures;
     }
 
-    int cmd_execute_clean(const CWStringView cmd_line)
+    int cmd_execute_clean(const CStringView cmd_line)
     {
-        static const std::wstring SYSTEM_ROOT = get_environment_variable(L"SystemRoot").value_or_exit(VCPKG_LINE_INFO);
-        static const std::wstring SYSTEM_32 = SYSTEM_ROOT + LR"(\system32)";
-        static const std::wstring NEW_PATH = Strings::wformat(
-            LR"(Path=%s;%s;%s\Wbem;%s\WindowsPowerShell\v1.0\)", SYSTEM_32, SYSTEM_ROOT, SYSTEM_32, SYSTEM_32);
+#if defined(_WIN32)
+        static const std::string SYSTEM_ROOT = get_environment_variable("SystemRoot").value_or_exit(VCPKG_LINE_INFO);
+        static const std::string SYSTEM_32 = SYSTEM_ROOT + R"(\system32)";
+        static const std::string NEW_PATH = Strings::format(
+            R"(Path=%s;%s;%s\Wbem;%s\WindowsPowerShell\v1.0\)", SYSTEM_32, SYSTEM_ROOT, SYSTEM_32, SYSTEM_32);
 
         std::vector<std::wstring> env_wstrings = {
             L"ALLUSERSPROFILE",
@@ -118,17 +132,17 @@ namespace vcpkg::System
 
         for (auto&& env_wstring : env_wstrings)
         {
-            const Optional<std::wstring> value = System::get_environment_variable(env_wstring);
+            const Optional<std::string> value = System::get_environment_variable(Strings::to_utf8(env_wstring));
             const auto v = value.get();
             if (!v || v->empty()) continue;
 
             env_cstr.append(env_wstring);
             env_cstr.push_back(L'=');
-            env_cstr.append(*v);
+            env_cstr.append(Strings::to_utf16(*v));
             env_cstr.push_back(L'\0');
         }
 
-        env_cstr.append(NEW_PATH);
+        env_cstr.append(Strings::to_utf16(NEW_PATH));
         env_cstr.push_back(L'\0');
 
         STARTUPINFOW startup_info;
@@ -139,10 +153,10 @@ namespace vcpkg::System
         memset(&process_info, 0, sizeof(PROCESS_INFORMATION));
 
         // Basically we are wrapping it in quotes
-        std::wstring actual_cmd_line = Strings::wformat(LR"###(cmd.exe /c "%s")###", cmd_line);
-        Debug::println("CreateProcessW(%s)", Strings::to_utf8(actual_cmd_line));
+        std::string actual_cmd_line = Strings::format(R"###(cmd.exe /c "%s")###", cmd_line);
+        Debug::println("CreateProcessW(%s)", actual_cmd_line);
         bool succeeded = TRUE == CreateProcessW(nullptr,
-                                                actual_cmd_line.data(),
+                                                Strings::to_utf16(actual_cmd_line).data(),
                                                 nullptr,
                                                 nullptr,
                                                 FALSE,
@@ -164,18 +178,28 @@ namespace vcpkg::System
 
         Debug::println("CreateProcessW() returned %lu", exit_code);
         return static_cast<int>(exit_code);
+#else
+        fflush(nullptr);
+        return system(cmd_line.c_str());
+#endif
     }
 
-    int cmd_execute(const CWStringView cmd_line)
+    int cmd_execute(const CStringView cmd_line)
     {
         // Flush stdout before launching external process
         fflush(nullptr);
 
         // Basically we are wrapping it in quotes
-        const std::wstring& actual_cmd_line = Strings::wformat(LR"###("%s")###", cmd_line);
-        Debug::println("_wsystem(%s)", Strings::to_utf8(actual_cmd_line));
-        const int exit_code = _wsystem(actual_cmd_line.c_str());
+        const std::string& actual_cmd_line = Strings::format(R"###("%s")###", cmd_line);
+#if defined(_WIN32)
+        Debug::println("_wsystem(%s)", actual_cmd_line);
+        const int exit_code = _wsystem(Strings::to_utf16(actual_cmd_line).c_str());
         Debug::println("_wsystem() returned %d", exit_code);
+#else
+        Debug::println("_system(%s)", actual_cmd_line);
+        const int exit_code = system(actual_cmd_line.c_str());
+        Debug::println("_system() returned %d", exit_code);
+#endif
         return exit_code;
     }
 
@@ -190,17 +214,18 @@ namespace vcpkg::System
         }
     }
 
-    ExitCodeAndOutput cmd_execute_and_capture_output(const CWStringView cmd_line)
+    ExitCodeAndOutput cmd_execute_and_capture_output(const CStringView cmd_line)
     {
         // Flush stdout before launching external process
         fflush(stdout);
 
-        const std::wstring& actual_cmd_line = Strings::wformat(LR"###("%s 2>&1")###", cmd_line);
+#if defined(_WIN32)
+        const auto actual_cmd_line = Strings::format(R"###("%s 2>&1")###", cmd_line);
 
-        Debug::println("_wpopen(%s)", Strings::to_utf8(actual_cmd_line));
+        Debug::println("_wpopen(%s)", actual_cmd_line);
         std::wstring output;
         wchar_t buf[1024];
-        const auto pipe = _wpopen(actual_cmd_line.c_str(), L"r");
+        const auto pipe = _wpopen(Strings::to_utf16(actual_cmd_line).c_str(), L"r");
         if (pipe == nullptr)
         {
             return {1, Strings::to_utf8(output)};
@@ -218,27 +243,52 @@ namespace vcpkg::System
         Debug::println("_pclose() returned %d", ec);
         remove_byte_order_marks(&output);
         return {ec, Strings::to_utf8(output)};
+#else
+        const auto actual_cmd_line = Strings::format(R"###(%s 2>&1)###", cmd_line);
+
+        Debug::println("popen(%s)", actual_cmd_line);
+        std::string output;
+        char buf[1024];
+        const auto pipe = popen(actual_cmd_line.c_str(), "r");
+        if (pipe == nullptr)
+        {
+            return {1, output};
+        }
+        while (fgets(buf, 1024, pipe))
+        {
+            output.append(buf);
+        }
+        if (!feof(pipe))
+        {
+            return {1, output};
+        }
+
+        const auto ec = pclose(pipe);
+        Debug::println("pclose() returned %d", ec);
+        return {ec, output};
+#endif
     }
 
-    std::wstring create_powershell_script_cmd(const fs::path& script_path, const CWStringView args)
+    std::string create_powershell_script_cmd(const fs::path& script_path, const CStringView args)
     {
         // TODO: switch out ExecutionPolicy Bypass with "Remove Mark Of The Web" code and restore RemoteSigned
-        return Strings::wformat(
-            LR"(powershell -NoProfile -ExecutionPolicy Bypass -Command "& {& '%s' %s}")", script_path.native(), args);
+        return Strings::format(
+            R"(powershell -NoProfile -ExecutionPolicy Bypass -Command "& {& '%s' %s}")", script_path.u8string(), args);
     }
 
-    void println() { println(Strings::EMPTY); }
+    void println() { putchar('\n'); }
 
     void print(const CStringView message) { fputs(message.c_str(), stdout); }
 
     void println(const CStringView message)
     {
         print(message);
-        putchar('\n');
+        println();
     }
 
     void print(const Color c, const CStringView message)
     {
+#if defined(_WIN32)
         const HANDLE console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
 
         CONSOLE_SCREEN_BUFFER_INFO console_screen_buffer_info{};
@@ -248,37 +298,50 @@ namespace vcpkg::System
         SetConsoleTextAttribute(console_handle, static_cast<WORD>(c) | (original_color & 0xF0));
         print(message);
         SetConsoleTextAttribute(console_handle, original_color);
+#else
+        print(message);
+#endif
     }
 
     void println(const Color c, const CStringView message)
     {
         print(c, message);
-        putchar('\n');
+        println();
     }
 
-    Optional<std::wstring> get_environment_variable(const CWStringView varname) noexcept
+    Optional<std::string> get_environment_variable(const CStringView varname) noexcept
     {
-        const auto sz = GetEnvironmentVariableW(varname.c_str(), nullptr, 0);
+#if defined(_WIN32)
+        const auto w_varname = Strings::to_utf16(varname);
+        const auto sz = GetEnvironmentVariableW(w_varname.c_str(), nullptr, 0);
         if (sz == 0) return nullopt;
 
         std::wstring ret(sz, L'\0');
 
         Checks::check_exit(VCPKG_LINE_INFO, MAXDWORD >= ret.size());
-        const auto sz2 = GetEnvironmentVariableW(varname.c_str(), ret.data(), static_cast<DWORD>(ret.size()));
+        const auto sz2 = GetEnvironmentVariableW(w_varname.c_str(), ret.data(), static_cast<DWORD>(ret.size()));
         Checks::check_exit(VCPKG_LINE_INFO, sz2 + 1 == sz);
         ret.pop_back();
-        return ret;
+        return Strings::to_utf8(ret);
+#else
+        auto v = getenv(varname.c_str());
+        if (!v) return nullopt;
+        return std::string(v);
+#endif
     }
 
+#if defined(_WIN32)
     static bool is_string_keytype(DWORD hkey_type)
     {
         return hkey_type == REG_SZ || hkey_type == REG_MULTI_SZ || hkey_type == REG_EXPAND_SZ;
     }
 
-    Optional<std::wstring> get_registry_string(HKEY base, const CWStringView sub_key, const CWStringView valuename)
+    Optional<std::wstring> get_registry_string(void* base_hkey,
+                                               const CWStringView sub_key,
+                                               const CWStringView valuename)
     {
         HKEY k = nullptr;
-        const LSTATUS ec = RegOpenKeyExW(base, sub_key.c_str(), NULL, KEY_READ, &k);
+        const LSTATUS ec = RegOpenKeyExW(reinterpret_cast<HKEY>(base_hkey), sub_key.c_str(), NULL, KEY_READ, &k);
         if (ec != ERROR_SUCCESS) return nullopt;
 
         DWORD dw_buffer_size = 0;
@@ -298,17 +361,25 @@ namespace vcpkg::System
         ret.pop_back(); // remove extra trailing null byte
         return ret;
     }
+#else
+    Optional<std::wstring> get_registry_string(void* base_hkey,
+                                               const CWStringView sub_key,
+                                               const CWStringView valuename)
+    {
+        return nullopt;
+    }
+#endif
 
     static const fs::path& get_program_files()
     {
-        static const fs::path PATH = System::get_environment_variable(L"PROGRAMFILES").value_or_exit(VCPKG_LINE_INFO);
+        static const fs::path PATH = System::get_environment_variable("PROGRAMFILES").value_or_exit(VCPKG_LINE_INFO);
         return PATH;
     }
 
     const fs::path& get_program_files_32_bit()
     {
         static const fs::path PATH = []() -> fs::path {
-            auto value = System::get_environment_variable(L"ProgramFiles(x86)");
+            auto value = System::get_environment_variable("ProgramFiles(x86)");
             if (auto v = value.get())
             {
                 return std::move(*v);
@@ -321,7 +392,7 @@ namespace vcpkg::System
     const fs::path& get_program_files_platform_bitness()
     {
         static const fs::path PATH = []() -> fs::path {
-            auto value = System::get_environment_variable(L"ProgramW6432");
+            auto value = System::get_environment_variable("ProgramW6432");
             if (auto v = value.get())
             {
                 return std::move(*v);
diff --git a/toolsrc/src/vcpkg/binaryparagraph.cpp b/toolsrc/src/vcpkg/binaryparagraph.cpp
index ef943011f..3a493eb4c 100644
--- a/toolsrc/src/vcpkg/binaryparagraph.cpp
+++ b/toolsrc/src/vcpkg/binaryparagraph.cpp
@@ -80,10 +80,10 @@ namespace vcpkg
     BinaryParagraph::BinaryParagraph(const SourceParagraph& spgh, const FeatureParagraph& fpgh, const Triplet& triplet)
     {
         this->spec = PackageSpec::from_name_and_triplet(spgh.name, triplet).value_or_exit(VCPKG_LINE_INFO);
-        this->version = Strings::EMPTY;
+        this->version = "";
         this->feature = fpgh.name;
         this->description = fpgh.description;
-        this->maintainer = Strings::EMPTY;
+        this->maintainer = "";
         this->depends = filter_dependencies(fpgh.depends, triplet);
     }
 
diff --git a/toolsrc/src/vcpkg/build.cpp b/toolsrc/src/vcpkg/build.cpp
index 99ec541c1..3d3bcb5fe 100644
--- a/toolsrc/src/vcpkg/build.cpp
+++ b/toolsrc/src/vcpkg/build.cpp
@@ -155,16 +155,16 @@ namespace vcpkg::Build
         static const std::string LIBRARY_LINKAGE = "LibraryLinkage";
     }
 
-    CWStringView to_vcvarsall_target(const std::string& cmake_system_name)
+    CStringView to_vcvarsall_target(const std::string& cmake_system_name)
     {
-        if (cmake_system_name == Strings::EMPTY) return Strings::WEMPTY;
-        if (cmake_system_name == "Windows") return Strings::WEMPTY;
-        if (cmake_system_name == "WindowsStore") return L"store";
+        if (cmake_system_name.empty()) return "";
+        if (cmake_system_name == "Windows") return "";
+        if (cmake_system_name == "WindowsStore") return "store";
 
         Checks::exit_with_message(VCPKG_LINE_INFO, "Unsupported vcvarsall target %s", cmake_system_name);
     }
 
-    CWStringView to_vcvarsall_toolchain(const std::string& target_architecture, const Toolset& toolset)
+    CStringView to_vcvarsall_toolchain(const std::string& target_architecture, const Toolset& toolset)
     {
         auto maybe_target_arch = System::to_cpu_architecture(target_architecture);
         Checks::check_exit(
@@ -183,23 +183,23 @@ namespace vcpkg::Build
         Checks::exit_with_message(VCPKG_LINE_INFO, "Unsupported toolchain combination %s", target_architecture);
     }
 
-    std::wstring make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset)
+    std::string make_build_env_cmd(const PreBuildInfo& pre_build_info, const Toolset& toolset)
     {
-        const wchar_t* tonull = L" >nul";
+        const char* tonull = " >nul";
         if (GlobalState::debugging)
         {
-            tonull = Strings::WEMPTY;
+            tonull = "";
         }
 
         const auto arch = to_vcvarsall_toolchain(pre_build_info.target_architecture, toolset);
         const auto target = to_vcvarsall_target(pre_build_info.cmake_system_name);
 
-        return Strings::wformat(LR"("%s" %s %s %s %s 2>&1)",
-                                toolset.vcvarsall.native(),
-                                Strings::join(L" ", toolset.vcvarsall_options),
-                                arch,
-                                target,
-                                tonull);
+        return Strings::format(R"("%s" %s %s %s %s 2>&1)",
+                               toolset.vcvarsall.u8string(),
+                               Strings::join(" ", toolset.vcvarsall_options),
+                               arch,
+                               target,
+                               tonull);
     }
 
     static void create_binary_feature_control_file(const SourceParagraph& source_paragraph,
@@ -265,8 +265,6 @@ namespace vcpkg::Build
 
         const fs::path ports_cmake_script_path = paths.ports_cmake;
         const auto pre_build_info = PreBuildInfo::from_triplet_file(paths, triplet);
-        const Toolset& toolset = paths.get_toolset(pre_build_info.platform_toolset, pre_build_info.visual_studio_path);
-        const auto cmd_set_environment = make_build_env_cmd(pre_build_info, toolset);
 
         std::string features;
         if (GlobalState::feature_packages)
@@ -284,22 +282,26 @@ namespace vcpkg::Build
             }
         }
 
-        const std::wstring cmd_launch_cmake = make_cmake_cmd(
+        const Toolset& toolset = paths.get_toolset(pre_build_info.platform_toolset, pre_build_info.visual_studio_path);
+
+        const std::string cmd_launch_cmake = make_cmake_cmd(
             cmake_exe_path,
             ports_cmake_script_path,
             {
-                {L"CMD", L"BUILD"},
-                {L"PORT", config.src.name},
-                {L"CURRENT_PORT_DIR", config.port_dir / "/."},
-                {L"TARGET_TRIPLET", triplet.canonical_name()},
-                {L"VCPKG_PLATFORM_TOOLSET", toolset.version.c_str()},
-                {L"VCPKG_USE_HEAD_VERSION", to_bool(config.build_package_options.use_head_version) ? L"1" : L"0"},
-                {L"_VCPKG_NO_DOWNLOADS", !to_bool(config.build_package_options.allow_downloads) ? L"1" : L"0"},
-                {L"GIT", git_exe_path},
-                {L"FEATURES", features},
+                {"CMD", "BUILD"},
+                {"PORT", config.src.name},
+                {"CURRENT_PORT_DIR", config.port_dir / "/."},
+                {"TARGET_TRIPLET", triplet.canonical_name()},
+                {"VCPKG_PLATFORM_TOOLSET", toolset.version.c_str()},
+                {"VCPKG_USE_HEAD_VERSION", to_bool(config.build_package_options.use_head_version) ? "1" : "0"},
+                {"_VCPKG_NO_DOWNLOADS", !to_bool(config.build_package_options.allow_downloads) ? "1" : "0"},
+                {"GIT", git_exe_path},
+                {"FEATURES", features},
             });
 
-        const std::wstring command = Strings::wformat(LR"(%s && %s)", cmd_set_environment, cmd_launch_cmake);
+        std::string command;
+        const auto cmd_set_environment = make_build_env_cmd(pre_build_info, toolset);
+        command = Strings::format(R"(%s && %s)", cmd_set_environment, cmd_launch_cmake);
 
         const auto timer = Chrono::ElapsedTime::create_started();
 
@@ -461,14 +463,12 @@ namespace vcpkg::Build
         const fs::path ports_cmake_script_path = paths.scripts / "get_triplet_environment.cmake";
         const fs::path triplet_file_path = paths.triplets / (triplet.canonical_name() + ".cmake");
 
-        const std::wstring cmd_launch_cmake = make_cmake_cmd(cmake_exe_path,
-                                                             ports_cmake_script_path,
-                                                             {
-                                                                 {L"CMAKE_TRIPLET_FILE", triplet_file_path},
-                                                             });
-
-        const std::wstring command = Strings::wformat(LR"(%s)", cmd_launch_cmake);
-        const auto ec_data = System::cmd_execute_and_capture_output(command);
+        const auto cmd_launch_cmake = make_cmake_cmd(cmake_exe_path,
+                                                     ports_cmake_script_path,
+                                                     {
+                                                         {"CMAKE_TRIPLET_FILE", triplet_file_path},
+                                                     });
+        const auto ec_data = System::cmd_execute_and_capture_output(cmd_launch_cmake);
         Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0);
 
         const std::vector<std::string> lines = Strings::split(ec_data.output, "\n");
@@ -491,7 +491,7 @@ namespace vcpkg::Build
 
             const bool variable_with_no_value = s.size() == 1;
             const std::string variable_name = s.at(0);
-            const std::string variable_value = variable_with_no_value ? Strings::EMPTY : s.at(1);
+            const std::string variable_value = variable_with_no_value ? "" : s.at(1);
 
             if (variable_name == "VCPKG_TARGET_ARCHITECTURE")
             {
diff --git a/toolsrc/src/vcpkg/commands.create.cpp b/toolsrc/src/vcpkg/commands.create.cpp
index d923cf555..85763f25e 100644
--- a/toolsrc/src/vcpkg/commands.create.cpp
+++ b/toolsrc/src/vcpkg/commands.create.cpp
@@ -20,7 +20,7 @@ namespace vcpkg::Commands::Create
 
         const fs::path& cmake_exe = paths.get_cmake_exe();
 
-        std::vector<CMakeVariable> cmake_args{{L"CMD", L"CREATE"}, {L"PORT", port_name}, {L"URL", url}};
+        std::vector<CMakeVariable> cmake_args{{"CMD", "CREATE"}, {"PORT", port_name}, {"URL", url}};
 
         if (args.command_arguments.size() >= 3)
         {
@@ -30,10 +30,10 @@ namespace vcpkg::Commands::Create
                                R"(Filename cannot contain invalid chars %s, but was %s)",
                                Files::FILESYSTEM_INVALID_CHARACTERS,
                                zip_file_name);
-            cmake_args.push_back({L"FILENAME", zip_file_name});
+            cmake_args.push_back({"FILENAME", zip_file_name});
         }
 
-        const std::wstring cmd_launch_cmake = make_cmake_cmd(cmake_exe, paths.ports_cmake, cmake_args);
+        const std::string cmd_launch_cmake = make_cmake_cmd(cmake_exe, paths.ports_cmake, cmake_args);
         Checks::exit_with_code(VCPKG_LINE_INFO, System::cmd_execute_clean(cmd_launch_cmake));
     }
 }
diff --git a/toolsrc/src/vcpkg/commands.edit.cpp b/toolsrc/src/vcpkg/commands.edit.cpp
index a90ae1bc3..fe6f76bd2 100644
--- a/toolsrc/src/vcpkg/commands.edit.cpp
+++ b/toolsrc/src/vcpkg/commands.edit.cpp
@@ -17,6 +17,7 @@ namespace vcpkg::Commands::Edit
         };
 
         std::vector<fs::path> output;
+#if defined(_WIN32)
         for (auto&& keypath : REGKEYS)
         {
             const Optional<std::wstring> code_installpath =
@@ -28,6 +29,7 @@ namespace vcpkg::Commands::Edit
                 output.push_back(install_path / "Code.exe");
             }
         }
+#endif
         return output;
     }
 
@@ -72,7 +74,7 @@ namespace vcpkg::Commands::Edit
         Checks::check_exit(VCPKG_LINE_INFO, fs.is_directory(portpath), R"(Could not find port named "%s")", port_name);
 
         std::vector<fs::path> candidate_paths;
-        const std::vector<fs::path> from_path = Files::find_from_PATH(L"EDITOR");
+        const std::vector<fs::path> from_path = Files::find_from_PATH("EDITOR");
         candidate_paths.insert(candidate_paths.end(), from_path.cbegin(), from_path.cend());
         candidate_paths.push_back(System::get_program_files_platform_bitness() / VS_CODE_INSIDERS);
         candidate_paths.push_back(System::get_program_files_32_bit() / VS_CODE_INSIDERS);
@@ -98,13 +100,16 @@ namespace vcpkg::Commands::Edit
         {
             const auto buildtrees_current_dir = paths.buildtrees / port_name;
 
-            const std::wstring cmd_line =
-                Strings::wformat(LR"("%s" "%s" -n)", env_editor, buildtrees_current_dir.native());
+            const auto cmd_line =
+                Strings::format(R"("%s" "%s" -n)", env_editor.u8string(), buildtrees_current_dir.u8string());
             Checks::exit_with_code(VCPKG_LINE_INFO, System::cmd_execute(cmd_line));
         }
 
-        const std::wstring cmd_line = Strings::wformat(
-            LR"("%s" "%s" "%s" -n)", env_editor, portpath.native(), (portpath / "portfile.cmake").native());
+        const auto cmd_line = Strings::format(
+            R"("%s" "%s" "%s" -n)",
+            env_editor.u8string(),
+            portpath.u8string(),
+            (portpath / "portfile.cmake").u8string());
         Checks::exit_with_code(VCPKG_LINE_INFO, System::cmd_execute(cmd_line));
     }
 }
diff --git a/toolsrc/src/vcpkg/commands.env.cpp b/toolsrc/src/vcpkg/commands.env.cpp
index 089881588..9f8ae5207 100644
--- a/toolsrc/src/vcpkg/commands.env.cpp
+++ b/toolsrc/src/vcpkg/commands.env.cpp
@@ -15,7 +15,7 @@ namespace vcpkg::Commands::Env
 
         const auto pre_build_info = Build::PreBuildInfo::from_triplet_file(paths, default_triplet);
         const Toolset& toolset = paths.get_toolset(pre_build_info.platform_toolset, pre_build_info.visual_studio_path);
-        System::cmd_execute_clean(Build::make_build_env_cmd(pre_build_info, toolset) + L" && cmd");
+        System::cmd_execute_clean(Build::make_build_env_cmd(pre_build_info, toolset) + " && cmd");
 
         Checks::exit_success(VCPKG_LINE_INFO);
     }
diff --git a/toolsrc/src/vcpkg/commands.exportifw.cpp b/toolsrc/src/vcpkg/commands.exportifw.cpp
index fbf3beb8c..682267acb 100644
--- a/toolsrc/src/vcpkg/commands.exportifw.cpp
+++ b/toolsrc/src/vcpkg/commands.exportifw.cpp
@@ -29,7 +29,7 @@ namespace vcpkg::Export::IFW
 
     std::string safe_rich_from_plain_text(const std::string& text)
     {
-        // match standalone ampersand, no HTML number or name

+        // match standalone ampersand, no HTML number or name
         std::regex standalone_ampersand(R"###(&(?!(#[0-9]+|\w+);))###");
 
         return std::regex_replace(text, standalone_ampersand, "&amp;");
@@ -350,10 +350,10 @@ namespace vcpkg::Export::IFW
         Checks::check_exit(
             VCPKG_LINE_INFO, !ec, "Could not remove outdated repository directory %s", repository_dir.generic_string());
 
-        const std::wstring cmd_line = Strings::wformat(LR"("%s" --packages "%s" "%s" > nul)",
-                                                       repogen_exe.native(),
-                                                       packages_dir.native(),
-                                                       repository_dir.native());
+        const auto cmd_line = Strings::format(R"("%s" --packages "%s" "%s" > nul)",
+                                              repogen_exe.u8string(),
+                                              packages_dir.u8string(),
+                                              repository_dir.u8string());
 
         const int exit_code = System::cmd_execute_clean(cmd_line);
         Checks::check_exit(VCPKG_LINE_INFO, exit_code == 0, "Error: IFW repository generating failed");
@@ -371,24 +371,24 @@ namespace vcpkg::Export::IFW
 
         System::println("Generating installer %s...", installer_file.generic_string());
 
-        std::wstring cmd_line;
+        std::string cmd_line;
 
         std::string ifw_repo_url = ifw_options.maybe_repository_url.value_or("");
         if (!ifw_repo_url.empty())
         {
-            cmd_line = Strings::wformat(LR"("%s" --online-only --config "%s" --repository "%s" "%s" > nul)",
-                                        binarycreator_exe.native(),
-                                        config_file.native(),
-                                        repository_dir.native(),
-                                        installer_file.native());
+            cmd_line = Strings::format(R"("%s" --online-only --config "%s" --repository "%s" "%s" > nul)",
+                                       binarycreator_exe.u8string(),
+                                       config_file.u8string(),
+                                       repository_dir.u8string(),
+                                       installer_file.u8string());
         }
         else
         {
-            cmd_line = Strings::wformat(LR"("%s" --config "%s" --packages "%s" "%s" > nul)",
-                                        binarycreator_exe.native(),
-                                        config_file.native(),
-                                        packages_dir.native(),
-                                        installer_file.native());
+            cmd_line = Strings::format(R"("%s" --config "%s" --packages "%s" "%s" > nul)",
+                                       binarycreator_exe.u8string(),
+                                       config_file.u8string(),
+                                       packages_dir.u8string(),
+                                       installer_file.u8string());
         }
 
         const int exit_code = System::cmd_execute_clean(cmd_line);
diff --git a/toolsrc/src/vcpkg/commands.hash.cpp b/toolsrc/src/vcpkg/commands.hash.cpp
index 394a02e23..4bc58b509 100644
--- a/toolsrc/src/vcpkg/commands.hash.cpp
+++ b/toolsrc/src/vcpkg/commands.hash.cpp
@@ -7,26 +7,21 @@
 
 namespace vcpkg::Commands::Hash
 {
-    static void do_file_hash(fs::path const& path, std::wstring const& hash_type)
+    static void do_file_hash(fs::path const& path, std::string const& hash_type)
     {
-        const auto cmd_line = Strings::wformat(LR"(CertUtil.exe -hashfile "%s" %s)", path.c_str(), hash_type);
+        const auto cmd_line = Strings::format(R"(CertUtil.exe -hashfile "%s" %s)", path.u8string().c_str(), hash_type);
         const auto ec_data = System::cmd_execute_and_capture_output(cmd_line);
-        Checks::check_exit(
-            VCPKG_LINE_INFO, ec_data.exit_code == 0, "Running command:\n   %s\n failed", Strings::to_utf8(cmd_line));
+        Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0, "Running command:\n   %s\n failed", cmd_line);
 
         std::string const& output = ec_data.output;
 
         const auto start = output.find_first_of("\r\n");
-        Checks::check_exit(VCPKG_LINE_INFO,
-                           start != std::string::npos,
-                           "Unexpected output format from command: %s",
-                           Strings::to_utf8(cmd_line));
+        Checks::check_exit(
+            VCPKG_LINE_INFO, start != std::string::npos, "Unexpected output format from command: %s", cmd_line);
 
         const auto end = output.find_first_of("\r\n", start + 1);
-        Checks::check_exit(VCPKG_LINE_INFO,
-                           end != std::string::npos,
-                           "Unexpected output format from command: %s",
-                           Strings::to_utf8(cmd_line));
+        Checks::check_exit(
+            VCPKG_LINE_INFO, end != std::string::npos, "Unexpected output format from command: %s", cmd_line);
 
         auto hash = output.substr(start, end - start);
         Util::erase_remove_if(hash, isspace);
@@ -43,11 +38,11 @@ namespace vcpkg::Commands::Hash
 
         if (args.command_arguments.size() == 1)
         {
-            do_file_hash(args.command_arguments[0], L"SHA512");
+            do_file_hash(args.command_arguments[0], "SHA512");
         }
         if (args.command_arguments.size() == 2)
         {
-            do_file_hash(args.command_arguments[0], Strings::to_utf16(args.command_arguments[1]));
+            do_file_hash(args.command_arguments[0], args.command_arguments[1]);
         }
 
         Checks::exit_success(VCPKG_LINE_INFO);
diff --git a/toolsrc/src/vcpkg/commands.integrate.cpp b/toolsrc/src/vcpkg/commands.integrate.cpp
index 85b567adb..0d185476e 100644
--- a/toolsrc/src/vcpkg/commands.integrate.cpp
+++ b/toolsrc/src/vcpkg/commands.integrate.cpp
@@ -8,12 +8,6 @@
 
 namespace vcpkg::Commands::Integrate
 {
-    static const std::array<fs::path, 2> OLD_SYSTEM_TARGET_FILES = {
-        System::get_program_files_32_bit() / "MSBuild/14.0/Microsoft.Common.Targets/ImportBefore/vcpkg.nuget.targets",
-        System::get_program_files_32_bit() / "MSBuild/14.0/Microsoft.Common.Targets/ImportBefore/vcpkg.system.targets"};
-    static const fs::path SYSTEM_WIDE_TARGETS_FILE =
-        System::get_program_files_32_bit() / "MSBuild/Microsoft.Cpp/v4.0/V140/ImportBefore/Default/vcpkg.system.props";
-
     static std::string create_appdata_targets_shortcut(const std::string& target_path) noexcept
     {
         return Strings::format(R"###(
@@ -111,6 +105,7 @@ namespace vcpkg::Commands::Integrate
         NO
     };
 
+#if defined(_WIN32)
     static ElevationPromptChoice elevated_cmd_execute(const std::string& param)
     {
         SHELLEXECUTEINFOW sh_ex_info = {0};
@@ -138,16 +133,29 @@ namespace vcpkg::Commands::Integrate
         CloseHandle(sh_ex_info.hProcess);
         return ElevationPromptChoice::YES;
     }
+#endif
 
+#if defined(_WIN32)
     static fs::path get_appdata_targets_path()
     {
         static const fs::path LOCAL_APP_DATA =
-            fs::path(System::get_environment_variable(L"LOCALAPPDATA").value_or_exit(VCPKG_LINE_INFO));
+            fs::path(System::get_environment_variable("LOCALAPPDATA").value_or_exit(VCPKG_LINE_INFO));
         return LOCAL_APP_DATA / "vcpkg" / "vcpkg.user.targets";
     }
+#endif
 
+#if defined(_WIN32)
     static void integrate_install(const VcpkgPaths& paths)
     {
+        static const std::array<fs::path, 2> OLD_SYSTEM_TARGET_FILES = {
+            System::get_program_files_32_bit() /
+                "MSBuild/14.0/Microsoft.Common.Targets/ImportBefore/vcpkg.nuget.targets",
+            System::get_program_files_32_bit() /
+                "MSBuild/14.0/Microsoft.Common.Targets/ImportBefore/vcpkg.system.targets"};
+        static const fs::path SYSTEM_WIDE_TARGETS_FILE =
+            System::get_program_files_32_bit() /
+            "MSBuild/Microsoft.Cpp/v4.0/V140/ImportBefore/Default/vcpkg.system.props";
+
         auto& fs = paths.get_filesystem();
 
         // TODO: This block of code should eventually be removed
@@ -262,6 +270,7 @@ CMake projects should use: "-DCMAKE_TOOLCHAIN_FILE=%s")",
 
         Checks::exit_success(VCPKG_LINE_INFO);
     }
+#endif
 
     static void integrate_project(const VcpkgPaths& paths)
     {
@@ -286,10 +295,10 @@ CMake projects should use: "-DCMAKE_TOOLCHAIN_FILE=%s")",
         fs.write_contents(nuspec_file_path, create_nuspec_file_contents(paths.root, nuget_id, nupkg_version));
 
         // Using all forward slashes for the command line
-        const std::wstring cmd_line = Strings::wformat(LR"("%s" pack -OutputDirectory "%s" "%s" > nul)",
-                                                       nuget_exe.native(),
-                                                       buildsystems_dir.native(),
-                                                       nuspec_file_path.native());
+        const std::string cmd_line = Strings::format(R"("%s" pack -OutputDirectory "%s" "%s" > nul)",
+                                                     nuget_exe.u8string(),
+                                                     buildsystems_dir.u8string(),
+                                                     nuspec_file_path.u8string());
 
         const int exit_code = System::cmd_execute_clean(cmd_line);
 
@@ -325,6 +334,7 @@ With a project open, go to Tools->NuGet Package Manager->Package Manager Console
         args.check_exact_arg_count(1, EXAMPLE);
         args.check_and_get_optional_command_arguments({});
 
+#if defined(_WIN32)
         if (args.command_arguments[0] == "install")
         {
             return integrate_install(paths);
@@ -337,6 +347,7 @@ With a project open, go to Tools->NuGet Package Manager->Package Manager Console
         {
             return integrate_project(paths);
         }
+#endif
 
         Checks::exit_with_message(VCPKG_LINE_INFO, "Unknown parameter %s for integrate", args.command_arguments[0]);
     }
diff --git a/toolsrc/src/vcpkg/commands.portsdiff.cpp b/toolsrc/src/vcpkg/commands.portsdiff.cpp
index b70ad2b80..a8c043751 100644
--- a/toolsrc/src/vcpkg/commands.portsdiff.cpp
+++ b/toolsrc/src/vcpkg/commands.portsdiff.cpp
@@ -75,28 +75,28 @@ namespace vcpkg::Commands::PortsDiff
     }
 
     static std::map<std::string, VersionT> read_ports_from_commit(const VcpkgPaths& paths,
-                                                                  const std::wstring& git_commit_id)
+                                                                  const std::string& git_commit_id)
     {
         std::error_code ec;
         auto& fs = paths.get_filesystem();
         const fs::path& git_exe = paths.get_git_exe();
         const fs::path dot_git_dir = paths.root / ".git";
-        const std::wstring ports_dir_name_as_string = paths.ports.filename().native();
+        const std::string ports_dir_name_as_string = paths.ports.filename().u8string();
         const fs::path temp_checkout_path =
-            paths.root / Strings::wformat(L"%s-%s", ports_dir_name_as_string, git_commit_id);
+            paths.root / Strings::format("%s-%s", ports_dir_name_as_string, git_commit_id);
         fs.create_directory(temp_checkout_path, ec);
-        const std::wstring checkout_this_dir =
-            Strings::wformat(LR"(.\%s)", ports_dir_name_as_string); // Must be relative to the root of the repository
-
-        const std::wstring cmd =
-            Strings::wformat(LR"("%s" --git-dir="%s" --work-tree="%s" checkout %s -f -q -- %s %s & "%s" reset >NUL)",
-                             git_exe.native(),
-                             dot_git_dir.native(),
-                             temp_checkout_path.native(),
-                             git_commit_id,
-                             checkout_this_dir,
-                             L".vcpkg-root",
-                             git_exe.native());
+        const auto checkout_this_dir =
+            Strings::format(R"(.\%s)", ports_dir_name_as_string); // Must be relative to the root of the repository
+
+        const std::string cmd =
+            Strings::format(R"("%s" --git-dir="%s" --work-tree="%s" checkout %s -f -q -- %s %s & "%s" reset >NUL)",
+                            git_exe.u8string(),
+                            dot_git_dir.u8string(),
+                            temp_checkout_path.u8string(),
+                            git_commit_id,
+                            checkout_this_dir,
+                            ".vcpkg-root",
+                            git_exe.u8string());
         System::cmd_execute_clean(cmd);
         const std::map<std::string, VersionT> names_and_versions = Paragraphs::load_all_port_names_and_versions(
             paths.get_filesystem(), temp_checkout_path / ports_dir_name_as_string);
@@ -104,16 +104,14 @@ namespace vcpkg::Commands::PortsDiff
         return names_and_versions;
     }
 
-    static void check_commit_exists(const fs::path& git_exe, const std::wstring& git_commit_id)
+    static void check_commit_exists(const fs::path& git_exe, const std::string& git_commit_id)
     {
         static const std::string VALID_COMMIT_OUTPUT = "commit\n";
 
-        const std::wstring cmd = Strings::wformat(LR"("%s" cat-file -t %s)", git_exe.native(), git_commit_id);
+        const auto cmd = Strings::format(R"("%s" cat-file -t %s)", git_exe.u8string(), git_commit_id);
         const System::ExitCodeAndOutput output = System::cmd_execute_and_capture_output(cmd);
-        Checks::check_exit(VCPKG_LINE_INFO,
-                           output.output == VALID_COMMIT_OUTPUT,
-                           "Invalid commit id %s",
-                           Strings::to_utf8(git_commit_id));
+        Checks::check_exit(
+            VCPKG_LINE_INFO, output.output == VALID_COMMIT_OUTPUT, "Invalid commit id %s", git_commit_id);
     }
 
     void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths)
@@ -126,9 +124,9 @@ namespace vcpkg::Commands::PortsDiff
 
         const fs::path& git_exe = paths.get_git_exe();
 
-        const std::wstring git_commit_id_for_previous_snapshot = Strings::to_utf16(args.command_arguments.at(0));
-        const std::wstring git_commit_id_for_current_snapshot =
-            args.command_arguments.size() < 2 ? L"HEAD" : Strings::to_utf16(args.command_arguments.at(1));
+        const std::string git_commit_id_for_previous_snapshot = args.command_arguments.at(0);
+        const std::string git_commit_id_for_current_snapshot =
+            args.command_arguments.size() < 2 ? "HEAD" : args.command_arguments.at(1);
 
         check_commit_exists(git_exe, git_commit_id_for_current_snapshot);
         check_commit_exists(git_exe, git_commit_id_for_previous_snapshot);
diff --git a/toolsrc/src/vcpkg/commands.version.cpp b/toolsrc/src/vcpkg/commands.version.cpp
index c6cc82d1f..403c355b5 100644
--- a/toolsrc/src/vcpkg/commands.version.cpp
+++ b/toolsrc/src/vcpkg/commands.version.cpp
@@ -20,20 +20,29 @@ namespace vcpkg::Commands::Version
 #ifndef NDEBUG
             + std::string("-debug")
 #endif
-            + std::string(Metrics::get_compiled_metrics_enabled() ? Strings::EMPTY : "-external");
+            + std::string(Metrics::get_compiled_metrics_enabled() ? "" : "-external");
         return S_VERSION;
     }
 
+    static int scan3(const char* input, const char* pattern, int* a, int* b, int* c)
+    {
+#if defined(_WIN32)
+        return sscanf_s(input, pattern, a, b, c);
+#else
+        return sscanf(input, pattern, a, b, c);
+#endif
+    }
+
     void warn_if_vcpkg_version_mismatch(const VcpkgPaths& paths)
     {
         auto version_file = paths.get_filesystem().read_contents(paths.root / "toolsrc" / "VERSION.txt");
         if (const auto version_contents = version_file.get())
         {
             int maj1, min1, rev1;
-            const auto num1 = sscanf_s(version_contents->c_str(), "\"%d.%d.%d\"", &maj1, &min1, &rev1);
+            const auto num1 = scan3(version_contents->c_str(), "\"%d.%d.%d\"", &maj1, &min1, &rev1);
 
             int maj2, min2, rev2;
-            const auto num2 = sscanf_s(Version::version().c_str(), "%d.%d.%d-", &maj2, &min2, &rev2);
+            const auto num2 = scan3(Version::version().c_str(), "%d.%d.%d-", &maj2, &min2, &rev2);
 
             if (num1 == 3 && num2 == 3)
             {
diff --git a/toolsrc/src/vcpkg/dependencies.cpp b/toolsrc/src/vcpkg/dependencies.cpp
index da8f1e178..02b2ec785 100644
--- a/toolsrc/src/vcpkg/dependencies.cpp
+++ b/toolsrc/src/vcpkg/dependencies.cpp
@@ -43,14 +43,17 @@ namespace vcpkg::Dependencies
     bool operator==(const ClusterPtr& l, const ClusterPtr& r) { return l.ptr == r.ptr; }
 }
 
-template<>
-struct std::hash<vcpkg::Dependencies::ClusterPtr>
+namespace std
 {
-    size_t operator()(const vcpkg::Dependencies::ClusterPtr& value) const
+    template<>
+    struct hash<vcpkg::Dependencies::ClusterPtr>
     {
-        return std::hash<vcpkg::PackageSpec>()(value.ptr->spec);
-    }
-};
+        size_t operator()(const vcpkg::Dependencies::ClusterPtr& value) const
+        {
+            return std::hash<vcpkg::PackageSpec>()(value.ptr->spec);
+        }
+    };
+}
 
 namespace vcpkg::Dependencies
 {
diff --git a/toolsrc/src/vcpkg/export.cpp b/toolsrc/src/vcpkg/export.cpp
index de6464c87..5e27d4126 100644
--- a/toolsrc/src/vcpkg/export.cpp
+++ b/toolsrc/src/vcpkg/export.cpp
@@ -137,11 +137,10 @@ namespace vcpkg::Export
         fs.write_contents(nuspec_file_path, nuspec_file_content);
 
         // -NoDefaultExcludes is needed for ".vcpkg-root"
-        const std::wstring cmd_line =
-            Strings::wformat(LR"("%s" pack -OutputDirectory "%s" "%s" -NoDefaultExcludes > nul)",
-                             nuget_exe.native(),
-                             output_dir.native(),
-                             nuspec_file_path.native());
+        const auto cmd_line = Strings::format(R"("%s" pack -OutputDirectory "%s" "%s" -NoDefaultExcludes > nul)",
+                                              nuget_exe.u8string(),
+                                              output_dir.u8string(),
+                                              nuspec_file_path.u8string());
 
         const int exit_code = System::cmd_execute_clean(cmd_line);
         Checks::check_exit(VCPKG_LINE_INFO, exit_code == 0, "Error: NuGet package creation failed");
@@ -160,25 +159,25 @@ namespace vcpkg::Export
 
         constexpr ArchiveFormat() = delete;
 
-        constexpr ArchiveFormat(BackingEnum backing_enum, const wchar_t* extension, const wchar_t* cmake_option)
+        constexpr ArchiveFormat(BackingEnum backing_enum, const char* extension, const char* cmake_option)
             : backing_enum(backing_enum), m_extension(extension), m_cmake_option(cmake_option)
         {
         }
 
         constexpr operator BackingEnum() const { return backing_enum; }
-        constexpr CWStringView extension() const { return this->m_extension; }
-        constexpr CWStringView cmake_option() const { return this->m_cmake_option; }
+        constexpr CStringView extension() const { return this->m_extension; }
+        constexpr CStringView cmake_option() const { return this->m_cmake_option; }
 
     private:
         BackingEnum backing_enum;
-        const wchar_t* m_extension;
-        const wchar_t* m_cmake_option;
+        const char* m_extension;
+        const char* m_cmake_option;
     };
 
     namespace ArchiveFormatC
     {
-        constexpr const ArchiveFormat ZIP(ArchiveFormat::BackingEnum::ZIP, L"zip", L"zip");
-        constexpr const ArchiveFormat SEVEN_ZIP(ArchiveFormat::BackingEnum::SEVEN_ZIP, L"7z", L"7zip");
+        constexpr const ArchiveFormat ZIP(ArchiveFormat::BackingEnum::ZIP, "zip", "zip");
+        constexpr const ArchiveFormat SEVEN_ZIP(ArchiveFormat::BackingEnum::SEVEN_ZIP, "7z", "7zip");
     }
 
     static fs::path do_archive_export(const VcpkgPaths& paths,
@@ -188,17 +187,17 @@ namespace vcpkg::Export
     {
         const fs::path& cmake_exe = paths.get_cmake_exe();
 
-        const std::wstring exported_dir_filename = raw_exported_dir.filename().native();
-        const std::wstring exported_archive_filename =
-            Strings::wformat(L"%s.%s", exported_dir_filename, format.extension());
+        const std::string exported_dir_filename = raw_exported_dir.filename().u8string();
+        const std::string exported_archive_filename =
+            Strings::format("%s.%s", exported_dir_filename, format.extension());
         const fs::path exported_archive_path = (output_dir / exported_archive_filename);
 
         // -NoDefaultExcludes is needed for ".vcpkg-root"
-        const std::wstring cmd_line = Strings::wformat(LR"("%s" -E tar "cf" "%s" --format=%s -- "%s")",
-                                                       cmake_exe.native(),
-                                                       exported_archive_path.native(),
-                                                       format.cmake_option(),
-                                                       raw_exported_dir.native());
+        const auto cmd_line = Strings::format(R"("%s" -E tar "cf" "%s" --format=%s -- "%s")",
+                                              cmake_exe.u8string(),
+                                              exported_archive_path.u8string(),
+                                              format.cmake_option(),
+                                              raw_exported_dir.u8string());
 
         const int exit_code = System::cmd_execute_clean(cmd_line);
         Checks::check_exit(
@@ -361,13 +360,13 @@ namespace vcpkg::Export
     static void print_next_step_info(const fs::path& prefix)
     {
         const fs::path cmake_toolchain = prefix / "scripts" / "buildsystems" / "vcpkg.cmake";
-        const CMakeVariable cmake_variable = CMakeVariable(L"CMAKE_TOOLCHAIN_FILE", cmake_toolchain.generic_string());
+        const CMakeVariable cmake_variable = CMakeVariable("CMAKE_TOOLCHAIN_FILE", cmake_toolchain.generic_string());
         System::println("\n"
                         "To use the exported libraries in CMake projects use:"
                         "\n"
                         "    %s"
                         "\n",
-                        Strings::to_utf8(cmake_variable.s));
+                        cmake_variable.s);
     };
 
     static void handle_raw_based_export(Span<const ExportPlanAction> export_plan,
diff --git a/toolsrc/src/vcpkg/globalstate.cpp b/toolsrc/src/vcpkg/globalstate.cpp
index de564d357..43230fa4b 100644
--- a/toolsrc/src/vcpkg/globalstate.cpp
+++ b/toolsrc/src/vcpkg/globalstate.cpp
@@ -5,9 +5,9 @@
 namespace vcpkg
 {
     Util::LockGuarded<Chrono::ElapsedTime> GlobalState::timer;
-    std::atomic<bool> GlobalState::debugging = false;
-    std::atomic<bool> GlobalState::feature_packages = false;
+    std::atomic<bool> GlobalState::debugging(false);
+    std::atomic<bool> GlobalState::feature_packages(false);
 
-    std::atomic<int> GlobalState::g_init_console_cp = 0;
-    std::atomic<int> GlobalState::g_init_console_output_cp = 0;
+    std::atomic<int> GlobalState::g_init_console_cp(0);
+    std::atomic<int> GlobalState::g_init_console_output_cp(0);
 }
diff --git a/toolsrc/src/vcpkg/install.cpp b/toolsrc/src/vcpkg/install.cpp
index 4a1e5537b..adbd8c943 100644
--- a/toolsrc/src/vcpkg/install.cpp
+++ b/toolsrc/src/vcpkg/install.cpp
@@ -70,9 +70,8 @@ namespace vcpkg::Install
             }
 
             const std::string filename = file.filename().generic_string();
-            if (fs::is_regular_file(status) &&
-                (Strings::case_insensitive_ascii_compare(filename.c_str(), "CONTROL") ||
-                 Strings::case_insensitive_ascii_compare(filename.c_str(), "BUILD_INFO")))
+            if (fs::is_regular_file(status) && (Strings::case_insensitive_ascii_equals(filename.c_str(), "CONTROL") ||
+                                                Strings::case_insensitive_ascii_equals(filename.c_str(), "BUILD_INFO")))
             {
                 // Do not copy the control file
                 continue;
diff --git a/toolsrc/src/vcpkg/metrics.cpp b/toolsrc/src/vcpkg/metrics.cpp
index 84c1ee208..854baa0ca 100644
--- a/toolsrc/src/vcpkg/metrics.cpp
+++ b/toolsrc/src/vcpkg/metrics.cpp
@@ -19,6 +19,7 @@ namespace vcpkg::Metrics
         std::array<char, 80> date;
         date.fill(0);
 
+#if defined(_WIN32)
         struct _timeb timebuffer;
 
         _ftime_s(&timebuffer);
@@ -26,10 +27,17 @@ namespace vcpkg::Metrics
         const int milli = timebuffer.millitm;
 
         const errno_t err = gmtime_s(&newtime, &now);
+
         if (err)
         {
-            return Strings::EMPTY;
+            return "";
         }
+#else
+        time_t now;
+        time(&now);
+        gmtime_r(&now, &newtime);
+        const int milli = 0;
+#endif
 
         strftime(&date[0], date.size(), "%Y-%m-%dT%H:%M:%S", &newtime);
         return std::string(&date[0]) + "." + std::to_string(milli) + "Z";
@@ -121,6 +129,7 @@ namespace vcpkg::Metrics
 
     static std::string get_os_version_string()
     {
+#if defined(_WIN32)
         std::wstring path;
         path.resize(MAX_PATH);
         const auto n = GetSystemDirectoryW(&path[0], static_cast<UINT>(path.size()));
@@ -128,16 +137,16 @@ namespace vcpkg::Metrics
         path += L"\\kernel32.dll";
 
         const auto versz = GetFileVersionInfoSizeW(path.c_str(), nullptr);
-        if (versz == 0) return Strings::EMPTY;
+        if (versz == 0) return "";
 
         std::vector<char> verbuf;
         verbuf.resize(versz);
 
-        if (!GetFileVersionInfoW(path.c_str(), 0, static_cast<DWORD>(verbuf.size()), &verbuf[0])) return Strings::EMPTY;
+        if (!GetFileVersionInfoW(path.c_str(), 0, static_cast<DWORD>(verbuf.size()), &verbuf[0])) return "";
 
         void* rootblock;
         UINT rootblocksize;
-        if (!VerQueryValueW(&verbuf[0], L"\\", &rootblock, &rootblocksize)) return Strings::EMPTY;
+        if (!VerQueryValueW(&verbuf[0], L"\\", &rootblock, &rootblocksize)) return "";
 
         auto rootblock_ffi = static_cast<VS_FIXEDFILEINFO*>(rootblock);
 
@@ -145,6 +154,9 @@ namespace vcpkg::Metrics
                                static_cast<int>(HIWORD(rootblock_ffi->dwProductVersionMS)),
                                static_cast<int>(LOWORD(rootblock_ffi->dwProductVersionMS)),
                                static_cast<int>(HIWORD(rootblock_ffi->dwProductVersionLS)));
+#else
+        return "unknown";
+#endif
     }
 
     struct MetricMessage
@@ -223,9 +235,13 @@ namespace vcpkg::Metrics
 
     std::wstring get_SQM_user()
     {
+#if defined(_WIN32)
         auto hkcu_sqmclient =
             System::get_registry_string(HKEY_CURRENT_USER, LR"(Software\Microsoft\SQMClient)", L"UserId");
         return hkcu_sqmclient.value_or(L"{}");
+#else
+        return L"{}";
+#endif
     }
 
     void Metrics::set_user_information(const std::string& user_id, const std::string& first_use_time)
@@ -264,6 +280,7 @@ namespace vcpkg::Metrics
 
     void Metrics::upload(const std::string& payload)
     {
+#if defined(_WIN32)
         HINTERNET connect = nullptr, request = nullptr;
         BOOL results = FALSE;
 
@@ -344,18 +361,12 @@ namespace vcpkg::Metrics
         if (request) WinHttpCloseHandle(request);
         if (connect) WinHttpCloseHandle(connect);
         if (session) WinHttpCloseHandle(session);
-    }
-
-    static fs::path get_bindir()
-    {
-        wchar_t buf[_MAX_PATH];
-        const int bytes = GetModuleFileNameW(nullptr, buf, _MAX_PATH);
-        if (bytes == 0) std::abort();
-        return fs::path(buf, buf + bytes);
+#endif
     }
 
     void Metrics::flush()
     {
+#if defined(_WIN32)
         const std::string payload = g_metricmessage.format_event_data_template();
         if (g_should_print_metrics) std::cerr << payload << "\n";
         if (!g_should_send_metrics) return;
@@ -373,14 +384,14 @@ namespace vcpkg::Metrics
         if (true)
         {
             const fs::path exe_path = [&fs]() -> fs::path {
-                auto vcpkgdir = get_bindir().parent_path();
+                auto vcpkgdir = System::get_exe_path_of_current_process().parent_path();
                 auto path = vcpkgdir / "vcpkgmetricsuploader.exe";
                 if (fs.exists(path)) return path;
 
                 path = vcpkgdir / "scripts" / "vcpkgmetricsuploader.exe";
                 if (fs.exists(path)) return path;
 
-                return Strings::WEMPTY;
+                return "";
             }();
 
             std::error_code ec;
@@ -391,8 +402,9 @@ namespace vcpkg::Metrics
         const fs::path vcpkg_metrics_txt_path = temp_folder_path / ("vcpkg" + generate_random_UUID() + ".txt");
         fs.write_contents(vcpkg_metrics_txt_path, payload);
 
-        const std::wstring cmd_line =
-            Strings::wformat(L"start %s %s", temp_folder_path_exe.native(), vcpkg_metrics_txt_path.native());
+        const std::string cmd_line =
+            Strings::format("start %s %s", temp_folder_path_exe.u8string(), vcpkg_metrics_txt_path.u8string());
         System::cmd_execute_clean(cmd_line);
+#endif
     }
 }
diff --git a/toolsrc/src/vcpkg/packagespec.cpp b/toolsrc/src/vcpkg/packagespec.cpp
index 01a09618d..6e40d70f5 100644
--- a/toolsrc/src/vcpkg/packagespec.cpp
+++ b/toolsrc/src/vcpkg/packagespec.cpp
@@ -38,7 +38,7 @@ namespace vcpkg
                 for (auto&& feature : spec->features)
                     f_specs.push_back(FeatureSpec{pspec, feature});
 
-                if (spec->features.empty()) f_specs.push_back(FeatureSpec{pspec, Strings::EMPTY});
+                if (spec->features.empty()) f_specs.push_back(FeatureSpec{pspec, ""});
             }
             else
             {
@@ -56,7 +56,7 @@ namespace vcpkg
         std::vector<FeatureSpec> ret;
         for (auto&& spec : specs)
         {
-            ret.emplace_back(spec.package_spec, Strings::EMPTY);
+            ret.emplace_back(spec.package_spec, "");
             for (auto&& feature : spec.features)
                 ret.emplace_back(spec.package_spec, feature);
         }
diff --git a/toolsrc/src/vcpkg/parse.cpp b/toolsrc/src/vcpkg/parse.cpp
index 116a7f5c8..c2670f561 100644
--- a/toolsrc/src/vcpkg/parse.cpp
+++ b/toolsrc/src/vcpkg/parse.cpp
@@ -31,7 +31,7 @@ namespace vcpkg::Parse
     }
     std::string ParagraphParser::optional_field(const std::string& fieldname) const
     {
-        return remove_field(&fields, fieldname).value_or(Strings::EMPTY);
+        return remove_field(&fields, fieldname).value_or("");
     }
     std::unique_ptr<ParseControlErrorInfo> ParagraphParser::error_info(const std::string& name) const
     {
diff --git a/toolsrc/src/vcpkg/postbuildlint.cpp b/toolsrc/src/vcpkg/postbuildlint.cpp
index 22cf67e86..0063f8d98 100644
--- a/toolsrc/src/vcpkg/postbuildlint.cpp
+++ b/toolsrc/src/vcpkg/postbuildlint.cpp
@@ -284,13 +284,10 @@ namespace vcpkg::PostBuildLint
         std::vector<fs::path> dlls_with_no_exports;
         for (const fs::path& dll : dlls)
         {
-            const std::wstring cmd_line =
-                Strings::wformat(LR"("%s" /exports "%s")", dumpbin_exe.native(), dll.native());
+            const std::string cmd_line =
+                Strings::format(R"("%s" /exports "%s")", dumpbin_exe.u8string(), dll.u8string());
             System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd_line);
-            Checks::check_exit(VCPKG_LINE_INFO,
-                               ec_data.exit_code == 0,
-                               "Running command:\n   %s\n failed",
-                               Strings::to_utf8(cmd_line));
+            Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0, "Running command:\n   %s\n failed", cmd_line);
 
             if (ec_data.output.find("ordinal hint RVA      name") == std::string::npos)
             {
@@ -321,13 +318,10 @@ namespace vcpkg::PostBuildLint
         std::vector<fs::path> dlls_with_improper_uwp_bit;
         for (const fs::path& dll : dlls)
         {
-            const std::wstring cmd_line =
-                Strings::wformat(LR"("%s" /headers "%s")", dumpbin_exe.native(), dll.native());
+            const std::string cmd_line =
+                Strings::format(R"("%s" /headers "%s")", dumpbin_exe.u8string(), dll.u8string());
             System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd_line);
-            Checks::check_exit(VCPKG_LINE_INFO,
-                               ec_data.exit_code == 0,
-                               "Running command:\n   %s\n failed",
-                               Strings::to_utf8(cmd_line));
+            Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0, "Running command:\n   %s\n failed", cmd_line);
 
             if (ec_data.output.find("App Container") == std::string::npos)
             {
@@ -599,13 +593,10 @@ namespace vcpkg::PostBuildLint
 
         for (const fs::path& lib : libs)
         {
-            const std::wstring cmd_line =
-                Strings::wformat(LR"("%s" /directives "%s")", dumpbin_exe.native(), lib.native());
+            const std::string cmd_line =
+                Strings::format(R"("%s" /directives "%s")", dumpbin_exe.u8string(), lib.u8string());
             System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd_line);
-            Checks::check_exit(VCPKG_LINE_INFO,
-                               ec_data.exit_code == 0,
-                               "Running command:\n   %s\n failed",
-                               Strings::to_utf8(cmd_line));
+            Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0, "Running command:\n   %s\n failed", cmd_line);
 
             for (const BuildType& bad_build_type : bad_build_types)
             {
@@ -655,13 +646,9 @@ namespace vcpkg::PostBuildLint
 
         for (const fs::path& dll : dlls)
         {
-            const std::wstring cmd_line =
-                Strings::wformat(LR"("%s" /dependents "%s")", dumpbin_exe.native(), dll.native());
+            const auto cmd_line = Strings::format(R"("%s" /dependents "%s")", dumpbin_exe.u8string(), dll.u8string());
             System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd_line);
-            Checks::check_exit(VCPKG_LINE_INFO,
-                               ec_data.exit_code == 0,
-                               "Running command:\n   %s\n failed",
-                               Strings::to_utf8(cmd_line));
+            Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0, "Running command:\n   %s\n failed", cmd_line);
 
             for (const OutdatedDynamicCrt& outdated_crt : get_outdated_dynamic_crts("v141"))
             {
@@ -696,8 +683,8 @@ namespace vcpkg::PostBuildLint
         std::vector<fs::path> misplaced_files = fs.get_files_non_recursive(dir);
         Util::unstable_keep_if(misplaced_files, [&fs](const fs::path& path) {
             const std::string filename = path.filename().generic_string();
-            if (Strings::case_insensitive_ascii_compare(filename.c_str(), "CONTROL") ||
-                Strings::case_insensitive_ascii_compare(filename.c_str(), "BUILD_INFO"))
+            if (Strings::case_insensitive_ascii_equals(filename.c_str(), "CONTROL") ||
+                Strings::case_insensitive_ascii_equals(filename.c_str(), "BUILD_INFO"))
                 return false;
             return !fs.is_directory(path);
         });
diff --git a/toolsrc/src/vcpkg/remove.cpp b/toolsrc/src/vcpkg/remove.cpp
index 04ddba1e4..2ec32855a 100644
--- a/toolsrc/src/vcpkg/remove.cpp
+++ b/toolsrc/src/vcpkg/remove.cpp
@@ -21,7 +21,7 @@ namespace vcpkg::Remove
     {
         auto& fs = paths.get_filesystem();
         auto spghs = status_db->find_all(spec.name(), spec.triplet());
-        const auto core_pkg = **status_db->find(spec.name(), spec.triplet(), Strings::EMPTY);
+        const auto core_pkg = **status_db->find(spec.name(), spec.triplet(), "");
 
         for (auto&& spgh : spghs)
         {
diff --git a/toolsrc/src/vcpkg/sourceparagraph.cpp b/toolsrc/src/vcpkg/sourceparagraph.cpp
index d766dcb72..2a9480538 100644
--- a/toolsrc/src/vcpkg/sourceparagraph.cpp
+++ b/toolsrc/src/vcpkg/sourceparagraph.cpp
@@ -178,11 +178,11 @@ namespace vcpkg
         return Strings::format("%s[%s]", this->depend.name, features);
     }
 
-    std::vector<Dependency> vcpkg::expand_qualified_dependencies(const std::vector<std::string>& depends)
+    std::vector<Dependency> expand_qualified_dependencies(const std::vector<std::string>& depends)
     {
         return Util::fmap(depends, [&](const std::string& depend_string) -> Dependency {
             auto pos = depend_string.find(' ');
-            if (pos == std::string::npos) return Dependency::parse_dependency(depend_string, Strings::EMPTY);
+            if (pos == std::string::npos) return Dependency::parse_dependency(depend_string, "");
             // expect of the form "\w+ \[\w+\]"
             Dependency dep;
 
@@ -190,7 +190,7 @@ namespace vcpkg
             if (depend_string.c_str()[pos + 1] != '(' || depend_string[depend_string.size() - 1] != ')')
             {
                 // Error, but for now just slurp the entire string.
-                return Dependency::parse_dependency(depend_string, Strings::EMPTY);
+                return Dependency::parse_dependency(depend_string, "");
             }
             dep.qualifier = depend_string.substr(pos + 2, depend_string.size() - pos - 3);
             return dep;
diff --git a/toolsrc/src/vcpkg/triplet.cpp b/toolsrc/src/vcpkg/triplet.cpp
index 4ebb97a9b..4cba1523d 100644
--- a/toolsrc/src/vcpkg/triplet.cpp
+++ b/toolsrc/src/vcpkg/triplet.cpp
@@ -18,11 +18,14 @@ namespace vcpkg
     const TripletInstance Triplet::DEFAULT_INSTANCE({});
 }
 
-template<>
-struct std::hash<vcpkg::TripletInstance>
+namespace std
 {
-    size_t operator()(const vcpkg::TripletInstance& t) const { return t.hash; }
-};
+    template<>
+    struct hash<vcpkg::TripletInstance>
+    {
+        size_t operator()(const vcpkg::TripletInstance& t) const { return t.hash; }
+    };
+}
 
 namespace vcpkg
 {
diff --git a/toolsrc/src/vcpkg/vcpkgcmdarguments.cpp b/toolsrc/src/vcpkg/vcpkgcmdarguments.cpp
index 522961693..209f6a3f2 100644
--- a/toolsrc/src/vcpkg/vcpkgcmdarguments.cpp
+++ b/toolsrc/src/vcpkg/vcpkgcmdarguments.cpp
@@ -45,12 +45,20 @@ namespace vcpkg
         option_field = new_setting;
     }
 
+#if defined(_WIN32)
     VcpkgCmdArguments VcpkgCmdArguments::create_from_command_line(const int argc, const wchar_t* const* const argv)
+#else
+    VcpkgCmdArguments VcpkgCmdArguments::create_from_command_line(const int argc, const char* const* const argv)
+#endif
     {
         std::vector<std::string> v;
         for (int i = 1; i < argc; ++i)
         {
+#if defined(_WIN32)
             v.push_back(Strings::to_utf8(argv[i]));
+#else
+            v.push_back(argv[i]);
+#endif
         }
 
         return VcpkgCmdArguments::create_from_arg_sequence(v.data(), v.data() + v.size());
@@ -223,17 +231,17 @@ namespace vcpkg
 
     void VcpkgCmdArguments::check_max_arg_count(const size_t expected_arg_count) const
     {
-        return check_max_arg_count(expected_arg_count, Strings::EMPTY);
+        return check_max_arg_count(expected_arg_count, "");
     }
 
     void VcpkgCmdArguments::check_min_arg_count(const size_t expected_arg_count) const
     {
-        return check_min_arg_count(expected_arg_count, Strings::EMPTY);
+        return check_min_arg_count(expected_arg_count, "");
     }
 
     void VcpkgCmdArguments::check_exact_arg_count(const size_t expected_arg_count) const
     {
-        return check_exact_arg_count(expected_arg_count, Strings::EMPTY);
+        return check_exact_arg_count(expected_arg_count, "");
     }
 
     void VcpkgCmdArguments::check_max_arg_count(const size_t expected_arg_count, const std::string& example_text) const
diff --git a/toolsrc/src/vcpkg/vcpkglib.cpp b/toolsrc/src/vcpkg/vcpkglib.cpp
index 23c774210..38b130f6f 100644
--- a/toolsrc/src/vcpkg/vcpkglib.cpp
+++ b/toolsrc/src/vcpkg/vcpkglib.cpp
@@ -212,30 +212,26 @@ namespace vcpkg
         return installed_files;
     }
 
-    CMakeVariable::CMakeVariable(const CWStringView varname, const wchar_t* varvalue)
-        : s(Strings::wformat(LR"("-D%s=%s")", varname, varvalue))
+    CMakeVariable::CMakeVariable(const CStringView varname, const char* varvalue)
+        : s(Strings::format(R"("-D%s=%s")", varname, varvalue))
     {
     }
-    CMakeVariable::CMakeVariable(const CWStringView varname, const std::string& varvalue)
-        : CMakeVariable(varname, Strings::to_utf16(varvalue).c_str())
-    {
-    }
-    CMakeVariable::CMakeVariable(const CWStringView varname, const std::wstring& varvalue)
+    CMakeVariable::CMakeVariable(const CStringView varname, const std::string& varvalue)
         : CMakeVariable(varname, varvalue.c_str())
     {
     }
-    CMakeVariable::CMakeVariable(const CWStringView varname, const fs::path& path)
-        : CMakeVariable(varname, path.generic_wstring())
+    CMakeVariable::CMakeVariable(const CStringView varname, const fs::path& path)
+        : CMakeVariable(varname, path.generic_u8string())
     {
     }
 
-    std::wstring make_cmake_cmd(const fs::path& cmake_exe,
-                                const fs::path& cmake_script,
-                                const std::vector<CMakeVariable>& pass_variables)
+    std::string make_cmake_cmd(const fs::path& cmake_exe,
+                               const fs::path& cmake_script,
+                               const std::vector<CMakeVariable>& pass_variables)
     {
-        const std::wstring cmd_cmake_pass_variables = Strings::join(L" ", pass_variables, [](auto&& v) { return v.s; });
-        return Strings::wformat(
-            LR"("%s" %s -P "%s")", cmake_exe.native(), cmd_cmake_pass_variables, cmake_script.generic_wstring());
+        const std::string cmd_cmake_pass_variables = Strings::join(" ", pass_variables, [](auto&& v) { return v.s; });
+        return Strings::format(
+            R"("%s" %s -P "%s")", cmake_exe.u8string(), cmd_cmake_pass_variables, cmake_script.generic_u8string());
     }
 
     std::string shorten_text(const std::string& desc, size_t length)
diff --git a/toolsrc/src/vcpkg/vcpkgpaths.cpp b/toolsrc/src/vcpkg/vcpkgpaths.cpp
index c57077eaa..90f9cb00b 100644
--- a/toolsrc/src/vcpkg/vcpkgpaths.cpp
+++ b/toolsrc/src/vcpkg/vcpkgpaths.cpp
@@ -10,16 +10,16 @@
 
 namespace vcpkg
 {
-    static constexpr CWStringView V_120 = L"v120";
-    static constexpr CWStringView V_140 = L"v140";
-    static constexpr CWStringView V_141 = L"v141";
+    static constexpr CStringView V_120 = "v120";
+    static constexpr CStringView V_140 = "v140";
+    static constexpr CStringView V_141 = "v141";
 
-    static bool exists_and_has_equal_or_greater_version(const std::wstring& version_cmd,
+    static bool exists_and_has_equal_or_greater_version(const std::string& version_cmd,
                                                         const std::array<int, 3>& expected_version)
     {
         static const std::regex RE(R"###((\d+)\.(\d+)\.(\d+))###");
 
-        const auto rc = System::cmd_execute_and_capture_output(Strings::wformat(LR"(%s)", version_cmd));
+        const auto rc = System::cmd_execute_and_capture_output(Strings::format(R"(%s)", version_cmd));
         if (rc.exit_code != 0)
         {
             return false;
@@ -46,11 +46,11 @@ namespace vcpkg
     }
 
     static Optional<fs::path> find_if_has_equal_or_greater_version(const std::vector<fs::path>& candidate_paths,
-                                                                   const std::wstring& version_check_arguments,
+                                                                   const std::string& version_check_arguments,
                                                                    const std::array<int, 3>& expected_version)
     {
         auto it = Util::find_if(candidate_paths, [&](const fs::path& p) {
-            const std::wstring cmd = Strings::wformat(LR"("%s" %s)", p.native(), version_check_arguments);
+            const std::string cmd = Strings::format(R"("%s" %s)", p.u8string(), version_check_arguments);
             return exists_and_has_equal_or_greater_version(cmd, expected_version);
         });
 
@@ -63,27 +63,26 @@ namespace vcpkg
     }
 
     static fs::path fetch_dependency(const fs::path& scripts_folder,
-                                     const std::wstring& tool_name,
+                                     const std::string& tool_name,
                                      const fs::path& expected_downloaded_path,
                                      const std::array<int, 3>& version)
     {
-        const std::string tool_name_utf8 = Strings::to_utf8(tool_name);
         const std::string version_as_string = Strings::format("%d.%d.%d", version[0], version[1], version[2]);
         System::println("A suitable version of %s was not found (required v%s). Downloading portable %s v%s...",
-                        tool_name_utf8,
+                        tool_name,
                         version_as_string,
-                        tool_name_utf8,
+                        tool_name,
                         version_as_string);
         const fs::path script = scripts_folder / "fetchDependency.ps1";
         const auto install_cmd =
-            System::create_powershell_script_cmd(script, Strings::wformat(L"-Dependency %s", tool_name));
+            System::create_powershell_script_cmd(script, Strings::format("-Dependency %s", tool_name));
         const System::ExitCodeAndOutput rc = System::cmd_execute_and_capture_output(install_cmd);
         if (rc.exit_code)
         {
             System::println(System::Color::error,
                             "Launching powershell failed or was denied when trying to fetch %s version %s.\n"
                             "(No sufficient installed version was found)",
-                            tool_name_utf8,
+                            tool_name,
                             version_as_string);
             {
                 auto locked_metrics = Metrics::g_metrics.lock();
@@ -107,16 +106,18 @@ namespace vcpkg
     static fs::path get_cmake_path(const fs::path& downloads_folder, const fs::path& scripts_folder)
     {
         static constexpr std::array<int, 3> EXPECTED_VERSION = {3, 9, 3};
-        static const std::wstring VERSION_CHECK_ARGUMENTS = L"--version";
+        static const std::string VERSION_CHECK_ARGUMENTS = "--version";
 
         const fs::path downloaded_copy = downloads_folder / "cmake-3.9.3-win32-x86" / "bin" / "cmake.exe";
-        const std::vector<fs::path> from_path = Files::find_from_PATH(L"cmake");
+        const std::vector<fs::path> from_path = Files::find_from_PATH("cmake");
 
         std::vector<fs::path> candidate_paths;
         candidate_paths.push_back(downloaded_copy);
         candidate_paths.insert(candidate_paths.end(), from_path.cbegin(), from_path.cend());
+#if defined(_WIN32)
         candidate_paths.push_back(System::get_program_files_platform_bitness() / "CMake" / "bin" / "cmake.exe");
         candidate_paths.push_back(System::get_program_files_32_bit() / "CMake" / "bin");
+#endif
 
         const Optional<fs::path> path =
             find_if_has_equal_or_greater_version(candidate_paths, VERSION_CHECK_ARGUMENTS, EXPECTED_VERSION);
@@ -125,43 +126,44 @@ namespace vcpkg
             return *p;
         }
 
-        return fetch_dependency(scripts_folder, L"cmake", downloaded_copy, EXPECTED_VERSION);
+        return fetch_dependency(scripts_folder, "cmake", downloaded_copy, EXPECTED_VERSION);
     }
 
     fs::path get_nuget_path(const fs::path& downloads_folder, const fs::path& scripts_folder)
     {
         static constexpr std::array<int, 3> EXPECTED_VERSION = {4, 3, 0};
-        static const std::wstring VERSION_CHECK_ARGUMENTS = Strings::WEMPTY;
 
         const fs::path downloaded_copy = downloads_folder / "nuget-4.3.0" / "nuget.exe";
-        const std::vector<fs::path> from_path = Files::find_from_PATH(L"nuget");
+        const std::vector<fs::path> from_path = Files::find_from_PATH("nuget");
 
         std::vector<fs::path> candidate_paths;
         candidate_paths.push_back(downloaded_copy);
         candidate_paths.insert(candidate_paths.end(), from_path.cbegin(), from_path.cend());
 
-        auto path = find_if_has_equal_or_greater_version(candidate_paths, VERSION_CHECK_ARGUMENTS, EXPECTED_VERSION);
+        auto path = find_if_has_equal_or_greater_version(candidate_paths, "", EXPECTED_VERSION);
         if (const auto p = path.get())
         {
             return *p;
         }
 
-        return fetch_dependency(scripts_folder, L"nuget", downloaded_copy, EXPECTED_VERSION);
+        return fetch_dependency(scripts_folder, "nuget", downloaded_copy, EXPECTED_VERSION);
     }
 
     fs::path get_git_path(const fs::path& downloads_folder, const fs::path& scripts_folder)
     {
         static constexpr std::array<int, 3> EXPECTED_VERSION = {2, 14, 1};
-        static const std::wstring VERSION_CHECK_ARGUMENTS = L"--version";
+        static const std::string VERSION_CHECK_ARGUMENTS = "--version";
 
         const fs::path downloaded_copy = downloads_folder / "MinGit-2.14.1-32-bit" / "cmd" / "git.exe";
-        const std::vector<fs::path> from_path = Files::find_from_PATH(L"git");
+        const std::vector<fs::path> from_path = Files::find_from_PATH("git");
 
         std::vector<fs::path> candidate_paths;
         candidate_paths.push_back(downloaded_copy);
         candidate_paths.insert(candidate_paths.end(), from_path.cbegin(), from_path.cend());
+#if defined(_WIN32)
         candidate_paths.push_back(System::get_program_files_platform_bitness() / "git" / "cmd" / "git.exe");
         candidate_paths.push_back(System::get_program_files_32_bit() / "git" / "cmd" / "git.exe");
+#endif
 
         const Optional<fs::path> path =
             find_if_has_equal_or_greater_version(candidate_paths, VERSION_CHECK_ARGUMENTS, EXPECTED_VERSION);
@@ -170,13 +172,13 @@ namespace vcpkg
             return *p;
         }
 
-        return fetch_dependency(scripts_folder, L"git", downloaded_copy, EXPECTED_VERSION);
+        return fetch_dependency(scripts_folder, "git", downloaded_copy, EXPECTED_VERSION);
     }
 
     static fs::path get_ifw_installerbase_path(const fs::path& downloads_folder, const fs::path& scripts_folder)
     {
         static constexpr std::array<int, 3> EXPECTED_VERSION = {3, 1, 81};
-        static const std::wstring VERSION_CHECK_ARGUMENTS = L"--framework-version";
+        static const std::string VERSION_CHECK_ARGUMENTS = "--framework-version";
 
         const fs::path downloaded_copy =
             downloads_folder / "QtInstallerFramework-win-x86" / "bin" / "installerbase.exe";
@@ -184,11 +186,11 @@ namespace vcpkg
         std::vector<fs::path> candidate_paths;
         candidate_paths.push_back(downloaded_copy);
         // TODO: Uncomment later
-        // const std::vector<fs::path> from_path = Files::find_from_PATH(L"installerbase");
+        // const std::vector<fs::path> from_path = Files::find_from_PATH("installerbase");
         // candidate_paths.insert(candidate_paths.end(), from_path.cbegin(), from_path.cend());
-        // candidate_paths.push_back(fs::path(System::get_environment_variable(L"HOMEDRIVE").value_or("C:")) / "Qt" /
+        // candidate_paths.push_back(fs::path(System::get_environment_variable("HOMEDRIVE").value_or("C:")) / "Qt" /
         // "Tools" / "QtInstallerFramework" / "3.1" / "bin" / "installerbase.exe");
-        // candidate_paths.push_back(fs::path(System::get_environment_variable(L"HOMEDRIVE").value_or("C:")) / "Qt" /
+        // candidate_paths.push_back(fs::path(System::get_environment_variable("HOMEDRIVE").value_or("C:")) / "Qt" /
         // "QtIFW-3.1.0" / "bin" / "installerbase.exe");
 
         const Optional<fs::path> path =
@@ -198,7 +200,7 @@ namespace vcpkg
             return *p;
         }
 
-        return fetch_dependency(scripts_folder, L"installerbase", downloaded_copy, EXPECTED_VERSION);
+        return fetch_dependency(scripts_folder, "installerbase", downloaded_copy, EXPECTED_VERSION);
     }
 
     Expected<VcpkgPaths> VcpkgPaths::create(const fs::path& vcpkg_root_dir)
@@ -322,7 +324,7 @@ namespace vcpkg
     static std::vector<VisualStudioInstance> get_visual_studio_instances(const VcpkgPaths& paths)
     {
         const fs::path script = paths.scripts / "findVisualStudioInstallationInstances.ps1";
-        const std::wstring cmd = System::create_powershell_script_cmd(script);
+        const std::string cmd = System::create_powershell_script_cmd(script);
         const System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd);
         Checks::check_exit(
             VCPKG_LINE_INFO, ec_data.exit_code == 0, "Could not run script to detect Visual Studio instances");
@@ -370,21 +372,21 @@ namespace vcpkg
                 // Get all supported architectures
                 std::vector<ToolsetArchOption> supported_architectures;
                 if (fs.exists(vcvarsall_dir / "vcvars32.bat"))
-                    supported_architectures.push_back({L"x86", CPU::X86, CPU::X86});
+                    supported_architectures.push_back({"x86", CPU::X86, CPU::X86});
                 if (fs.exists(vcvarsall_dir / "vcvars64.bat"))
-                    supported_architectures.push_back({L"amd64", CPU::X64, CPU::X64});
+                    supported_architectures.push_back({"amd64", CPU::X64, CPU::X64});
                 if (fs.exists(vcvarsall_dir / "vcvarsx86_amd64.bat"))
-                    supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
+                    supported_architectures.push_back({"x86_amd64", CPU::X86, CPU::X64});
                 if (fs.exists(vcvarsall_dir / "vcvarsx86_arm.bat"))
-                    supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
+                    supported_architectures.push_back({"x86_arm", CPU::X86, CPU::ARM});
                 if (fs.exists(vcvarsall_dir / "vcvarsx86_arm64.bat"))
-                    supported_architectures.push_back({L"x86_arm64", CPU::X86, CPU::ARM64});
+                    supported_architectures.push_back({"x86_arm64", CPU::X86, CPU::ARM64});
                 if (fs.exists(vcvarsall_dir / "vcvarsamd64_x86.bat"))
-                    supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
+                    supported_architectures.push_back({"amd64_x86", CPU::X64, CPU::X86});
                 if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm.bat"))
-                    supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
+                    supported_architectures.push_back({"amd64_arm", CPU::X64, CPU::ARM});
                 if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm64.bat"))
-                    supported_architectures.push_back({L"amd64_arm64", CPU::X64, CPU::ARM64});
+                    supported_architectures.push_back({"amd64_arm64", CPU::X64, CPU::ARM64});
 
                 // Locate the "best" MSVC toolchain version
                 const fs::path msvc_path = vc_dir / "Tools" / "MSVC";
@@ -412,7 +414,7 @@ namespace vcpkg
                             found_toolsets.push_back(Toolset{vs_instance.root_path,
                                                              dumpbin_path,
                                                              vcvarsall_bat,
-                                                             {L"-vcvars_ver=14.0"},
+                                                             {"-vcvars_ver=14.0"},
                                                              V_140,
                                                              supported_architectures});
                         }
@@ -437,17 +439,17 @@ namespace vcpkg
                     const fs::path vs2015_bin_dir = vcvarsall_bat.parent_path() / "bin";
                     std::vector<ToolsetArchOption> supported_architectures;
                     if (fs.exists(vs2015_bin_dir / "vcvars32.bat"))
-                        supported_architectures.push_back({L"x86", CPU::X86, CPU::X86});
+                        supported_architectures.push_back({"x86", CPU::X86, CPU::X86});
                     if (fs.exists(vs2015_bin_dir / "amd64\\vcvars64.bat"))
-                        supported_architectures.push_back({L"x64", CPU::X64, CPU::X64});
+                        supported_architectures.push_back({"x64", CPU::X64, CPU::X64});
                     if (fs.exists(vs2015_bin_dir / "x86_amd64\\vcvarsx86_amd64.bat"))
-                        supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
+                        supported_architectures.push_back({"x86_amd64", CPU::X86, CPU::X64});
                     if (fs.exists(vs2015_bin_dir / "x86_arm\\vcvarsx86_arm.bat"))
-                        supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
+                        supported_architectures.push_back({"x86_arm", CPU::X86, CPU::ARM});
                     if (fs.exists(vs2015_bin_dir / "amd64_x86\\vcvarsamd64_x86.bat"))
-                        supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
+                        supported_architectures.push_back({"amd64_x86", CPU::X64, CPU::X86});
                     if (fs.exists(vs2015_bin_dir / "amd64_arm\\vcvarsamd64_arm.bat"))
-                        supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
+                        supported_architectures.push_back({"amd64_arm", CPU::X64, CPU::ARM});
 
                     if (fs.exists(vs2015_dumpbin_exe))
                     {
@@ -489,15 +491,12 @@ namespace vcpkg
 
         if (tsv && vsp)
         {
-            const std::wstring w_toolset_version = Strings::to_utf16(*tsv);
-            const fs::path vs_root_path = *vsp;
-            Util::stable_keep_if(candidates, [&](const Toolset* t) {
-                return w_toolset_version == t->version && vs_root_path == t->visual_studio_root_path;
-            });
+            Util::stable_keep_if(
+                candidates, [&](const Toolset* t) { return *tsv == t->version && *vsp == t->visual_studio_root_path; });
             Checks::check_exit(VCPKG_LINE_INFO,
                                !candidates.empty(),
                                "Could not find Visual Studio instace at %s with %s toolset.",
-                               vs_root_path.generic_string(),
+                               vsp->u8string(),
                                *tsv);
 
             Checks::check_exit(VCPKG_LINE_INFO, candidates.size() == 1);
@@ -506,8 +505,7 @@ namespace vcpkg
 
         if (tsv)
         {
-            const std::wstring w_toolset_version = Strings::to_utf16(*tsv);
-            Util::stable_keep_if(candidates, [&](const Toolset* t) { return w_toolset_version == t->version; });
+            Util::stable_keep_if(candidates, [&](const Toolset* t) { return *tsv == t->version; });
             Checks::check_exit(
                 VCPKG_LINE_INFO, !candidates.empty(), "Could not find Visual Studio instace with %s toolset.", *tsv);
         }