Bump version to 2.8.0

Better updating (#236 )
Check hash pattern and launcher signature --- By creating this pull request, I understand that code that is AI generated or otherwise automatically generated may be rejected without further discussion. I declare that I fully understand all code I pushed into this PR, and wrote all this code myself and own the rights to this code.
2026-04-03 14:26:15 +00:00 · 2026-04-01 00:35:14 +02:00 · 2026-04-01 00:05:16 +02:00 · 2026-03-31 23:54:12 +02:00 · 2026-03-31 23:54:09 +02:00 · 2026-03-29 22:55:16 +02:00
23 changed files with 1064 additions and 451 deletions
--- a/.github/workflows/cmake-linux.yml
+++ b/.github/workflows/cmake-linux.yml
@@ -20,7 +20,7 @@ jobs:
        with:
            vcpkgArguments: 'zlib nlohmann-json openssl cpp-httplib[openssl]'
            vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
-            vcpkgGitCommitId: '40616a5e954f7be1077ef37db3fbddbd5dcd1ca6'
+            vcpkgGitCommitId: 'b5d1a94fb7f88fd835e360fd23a45a09ceedbf48'

      - name: Create Build Environment
        run: cmake -E make_directory ${{github.workspace}}/build-linux
--- a/.github/workflows/cmake-windows.yml
+++ b/.github/workflows/cmake-windows.yml
@@ -20,7 +20,7 @@ jobs:
        with:
            vcpkgArguments: 'discord-rpc zlib nlohmann-json openssl cpp-httplib[openssl]'
            vcpkgDirectory: '${{ runner.workspace }}/b/vcpkg'
-            vcpkgGitCommitId: '40616a5e954f7be1077ef37db3fbddbd5dcd1ca6'
+            vcpkgGitCommitId: 'b5d1a94fb7f88fd835e360fd23a45a09ceedbf48'
            vcpkgTriplet: 'x64-windows-static'

      - name: Create Build Environment
--- a/README.md
+++ b/README.md
@@ -2,57 +2,7 @@

 The launcher is the way we communitcate to outside the game, it does a few automated actions such as but not limited to: downloading the mod, launching the game, and create a connection to a server.

-**To clone this repository**: `git clone --recurse-submodules https://github.com/BeamMP/BeamMP-Launcher.git`
-
-## How to build for Windows
-
-Make sure you have the necessary development tools installed:
-
-[vcpkg](https://vcpkg.io/en/)
-
-### Release
-
-In the root directory of the project,
-1. `cmake -DCMAKE_BUILD_TYPE=Release . -B bin -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static`
-2. `cmake --build bin --parallel --config Release`
-
-Remember to change `C:/vcpkg` to wherever you have vcpkg installed.
-
-### Debug
-
-In the root directory of the project,
-1. `cmake . -B bin -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static`
-2. `cmake --build bin --parallel`
-
-Remember to change `C:/vcpkg` to wherever you have vcpkg installed.
-
-## How to build for Linux
-
-Make sure you have `vcpkg` installed, as well as basic development tools, often found in packages, for example:
-
- Debian: `sudo apt install build-essential`
- Fedora: `sudo dnf groupinstall "Development Tools"`
- Arch: `sudo pacman -S base-devel`
- openSUSE: `zypper in -t pattern devel-basis`
-
-### Release
-
-In the root directory of the project,
-1. `cmake -DCMAKE_BUILD_TYPE=Release . -B bin -DCMAKE_TOOLCHAIN_FILE=~/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-linux`
-2. `cmake --build bin --parallel --config Release`
-
-### Debug
-
-In the root directory of the project,
-1. `cmake . -B bin -DCMAKE_TOOLCHAIN_FILE=~/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-linux`
-2. `cmake --build bin --parallel`
-
-## Running out of RAM while building
-
-Should you run out of RAM while building, you can ommit the `--parallel` instruction, it will then use less RAM due to building only on one CPU thread.
-
-You can also specify a number of threads to use, for example `--parallel 4` will use four CPU threads, but due to the small project size, you may be faster just omitting `--parallel` instead of trying to find the highest possible multithread number
-
+## [Getting started](https://docs.beammp.com/game/getting-started/)

 ## License

--- a/include/Http.h
+++ b/include/Http.h
@@ -6,10 +6,12 @@

 #pragma once
 #include "Logger.h"
+#include "Utils.h"
+
 #include <string>
 class HTTP {
 public:
-    static bool Download(const std::string& IP, const std::string& Path);
+    static bool Download(const std::string& IP, const beammp_fs_string& Path, const std::string& Hash);
    static std::string Post(const std::string& IP, const std::string& Fields);
    static std::string Get(const std::string& IP);
    static bool ProgressBar(size_t c, size_t t);
--- a/include/Logger.h
+++ b/include/Logger.h
@@ -14,4 +14,11 @@ void debug(const std::string& toPrint);
 void error(const std::string& toPrint);
 void info(const std::string& toPrint);
 void warn(const std::string& toPrint);
+
+void except(const std::wstring& toPrint);
+void fatal(const std::wstring& toPrint);
+void debug(const std::wstring& toPrint);
+void error(const std::wstring& toPrint);
+void info(const std::wstring& toPrint);
+void warn(const std::wstring& toPrint);
 std::string getDate();
--- a/include/Network/network.hpp
+++ b/include/Network/network.hpp
@@ -6,6 +6,7 @@


 #pragma once
+#include <filesystem>
 #include <string>

 #ifdef __linux__
@@ -29,13 +30,15 @@ extern bool Terminate;
 extern uint64_t UDPSock;
 extern uint64_t TCPSock;
 extern std::string Branch;
-extern std::string CachingDirectory;
+extern std::filesystem::path CachingDirectory;
+extern bool deleteDuplicateMods;
 extern bool TCPTerminate;
 extern std::string LastIP;
 extern std::string MStatus;
 extern std::string UlStatus;
 extern std::string PublicKey;
 extern std::string PrivateKey;
+extern std::string magic;
 int KillSocket(uint64_t Dead);
 void UUl(const std::string& R);
 void UDPSend(std::string Data);
--- a/include/Options.h
+++ b/include/Options.h
@@ -19,6 +19,7 @@ struct Options {
    bool no_download = false;
    bool no_update = false;
    bool no_launch = false;
+    const char* user_path = nullptr;
    const char **game_arguments = nullptr;
    int game_arguments_length = 0;
    const char** argv = nullptr;
--- a/include/Security/Init.h
+++ b/include/Security/Init.h
@@ -6,9 +6,9 @@

 #pragma once
 #include <string>
-void PreGame(const std::string& GamePath);
-std::string CheckVer(const std::string& path);
-void InitGame(const std::string& Dir);
-std::string GetGameDir();
+void PreGame(const beammp_fs_string& GamePath);
+std::string CheckVer(const std::filesystem::path& path);
+void InitGame(const beammp_fs_string& Dir);
+beammp_fs_string GetGameDir();
 void LegitimacyCheck();
 void CheckLocalKey();
--- a/include/Startup.h
+++ b/include/Startup.h
@@ -5,14 +5,17 @@
 */

 #pragma once
+#include "Utils.h"
+
 #include <compare>
 #include <string>
 #include <vector>

 void InitLauncher();
-std::string GetEP(const char* P = nullptr);
-std::string GetGamePath();
+beammp_fs_string GetEP(const beammp_fs_char* P = nullptr);
+std::filesystem::path GetBP(const beammp_fs_char* P = nullptr);
+std::filesystem::path GetGamePath();
 std::string GetVer();
 std::string GetPatch();
-std::string GetEN();
+beammp_fs_string GetEN();
 void ConfigInit();
--- a/include/Utils.h
+++ b/include/Utils.h
@@ -5,8 +5,46 @@
 */

 #pragma once
+#include <cassert>
+#include <filesystem>
+#include <fstream>
+#include <locale>
+#include <map>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <regex>
+#include <cstdint>
+#include <cstring>
 #include <string>
+#include <variant>
 #include <vector>
+#include <array>
+#include <cerrno>
+#include <cstring>
+#include <stdexcept>
+#if defined(__linux__)
+#include <sys/socket.h>
+#include "linuxfixes.h"
+#else
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#endif
+
+#ifdef _WIN32
+#define beammp_fs_string std::wstring
+#define beammp_fs_char wchar_t
+#define beammp_wide(str) L##str
+#define beammp_stdout std::wcout
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+#define beammp_fs_string std::string
+#define beammp_fs_char char
+#define beammp_wide(str) str
+#define beammp_stdout std::cout
+#endif
+
+#include "Logger.h"

 namespace Utils {
    inline std::vector<std::string> Split(const std::string& String, const std::string& delimiter) {
@@ -22,5 +60,280 @@ namespace Utils {
        if (!s.empty())
            Val.push_back(s);
        return Val;
-    };
-};
+    }
+    inline std::string ExpandEnvVars(const std::string& input) {
+        std::string result;
+        std::regex envPattern(R"(%([^%]+)%|\$([A-Za-z_][A-Za-z0-9_]*)|\$\{([^}]+)\})");
+
+        std::sregex_iterator begin(input.begin(), input.end(), envPattern);
+        std::sregex_iterator end;
+
+        size_t lastPos = 0;
+
+        for (auto it = begin; it != end; ++it) {
+            const auto& match = *it;
+
+            result.append(input, lastPos, match.position() - lastPos);
+
+            std::string varName;
+            if (match[1].matched) varName = match[1].str(); // %VAR%
+            else if (match[2].matched) varName = match[2].str(); // $VAR
+            else if (match[3].matched) varName = match[3].str(); // ${VAR}
+
+            if (const char* envValue = std::getenv(varName.c_str())) {
+                result.append(envValue);
+            }
+
+            lastPos = match.position() + match.length();
+        }
+
+        result.append(input, lastPos, input.length() - lastPos);
+
+        return result;
+    }
+#ifdef _WIN32
+    inline std::wstring ExpandEnvVars(const std::wstring& input) {
+        std::wstring result;
+        std::wregex envPattern(LR"(%([^%]+)%|\$([A-Za-z_][A-Za-z0-9_]*)|\$\{([^}]+)\})");
+
+        std::wsregex_iterator begin(input.begin(), input.end(), envPattern);
+        std::wsregex_iterator end;
+
+        size_t lastPos = 0;
+
+        for (auto it = begin; it != end; ++it) {
+            const auto& match = *it;
+
+            result.append(input, lastPos, match.position() - lastPos);
+
+            std::wstring varName;
+            assert(match.size() == 4 && "Input regex has incorrect amount of capturing groups");
+            if (match[1].matched) varName = match[1].str(); // %VAR%
+            else if (match[2].matched) varName = match[2].str(); // $VAR
+            else if (match[3].matched) varName = match[3].str(); // ${VAR}
+
+            if (const wchar_t* envValue = _wgetenv(varName.c_str())) {
+                if (envValue != nullptr) {
+                    result.append(envValue);
+                }
+            }
+
+            lastPos = match.position() + match.length();
+        }
+
+        result.append(input, lastPos, input.length() - lastPos);
+
+        return result;
+    }
+#endif
+    inline std::map<std::string, std::variant<std::map<std::string, std::string>, std::string>> ParseINI(const std::string& contents) {
+        std::map<std::string, std::variant<std::map<std::string, std::string>, std::string>> ini;
+
+        std::string currentSection;
+        auto sections = Split(contents, "\n");
+
+        for (size_t i = 0; i < sections.size(); i++) {
+            std::string line = sections[i];
+            if (line.empty() || line[0] == ';' || line[0] == '#')
+                continue;
+
+            auto invalidLineLog = [&]{
+                debug("Invalid INI line: " + line);
+                debug("Surrounding lines: \n" +
+                    (i > 0 ? sections[i - 1] : "") + "\n" +
+                    (i < sections.size() - 1 ? sections[i + 1] : ""));
+            };
+
+            if (line[0] == '[') {
+                currentSection = line.substr(1, line.find(']') - 1);
+            } else {
+                std::string key, value;
+                size_t pos = line.find('=');
+                if (pos != std::string::npos) {
+                    key = line.substr(0, pos);
+
+                    key = key.substr(0, key.find_last_not_of(" \t") + 1);
+
+                    value = line.substr(pos + 1);
+                    if (currentSection.empty()) {
+                        ini[key] = value;
+                    } else {
+                        std::get<std::map<std::string, std::string>>(ini[currentSection])[key] = value;
+                    }
+                } else {
+                    invalidLineLog();
+                    continue;
+                }
+
+                key.erase(key.find_last_not_of(" \t") + 1);
+                value.erase(0, value.find_first_not_of(" \t"));
+                value.erase(value.find_last_not_of(" \t") + 1);
+
+                std::get<std::map<std::string, std::string>>(ini[currentSection])[key] = value;
+            }
+        }
+
+        return ini;
+    }
+
+#ifdef _WIN32
+    inline std::wstring ToWString(const std::string& s) {
+        if (s.empty()) return std::wstring();
+
+        int size_needed = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), nullptr, 0);
+        if (size_needed <= 0) {
+            return L"";
+        }
+
+        std::wstring result(size_needed, 0);
+
+        MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), &result[0], size_needed);
+
+        return result;
+    }
+#else
+    inline std::string ToWString(const std::string& s) {
+        return s;
+    }
+#endif
+    inline std::string GetSha256HashReallyFastFile(const beammp_fs_string& filename) {
+        try {
+            EVP_MD_CTX* mdctx;
+            const EVP_MD* md;
+            uint8_t sha256_value[EVP_MAX_MD_SIZE];
+            md = EVP_sha256();
+            if (md == nullptr) {
+                throw std::runtime_error("EVP_sha256() failed");
+            }
+
+            mdctx = EVP_MD_CTX_new();
+            if (mdctx == nullptr) {
+                throw std::runtime_error("EVP_MD_CTX_new() failed");
+            }
+            if (!EVP_DigestInit_ex2(mdctx, md, NULL)) {
+                EVP_MD_CTX_free(mdctx);
+                throw std::runtime_error("EVP_DigestInit_ex2() failed");
+            }
+
+            std::ifstream stream(filename, std::ios::binary);
+
+            const size_t FileSize = std::filesystem::file_size(filename);
+            size_t Read = 0;
+            std::vector<char> Data;
+            while (Read < FileSize) {
+                Data.resize(size_t(std::min<size_t>(FileSize - Read, 4096)));
+                size_t RealDataSize = Data.size();
+                stream.read(Data.data(), std::streamsize(Data.size()));
+                if (stream.eof() || stream.fail()) {
+                    RealDataSize = size_t(stream.gcount());
+                }
+                Data.resize(RealDataSize);
+                if (RealDataSize == 0) {
+                    break;
+                }
+                if (RealDataSize > 0 && !EVP_DigestUpdate(mdctx, Data.data(), Data.size())) {
+                    EVP_MD_CTX_free(mdctx);
+                    throw std::runtime_error("EVP_DigestUpdate() failed");
+                }
+                Read += RealDataSize;
+            }
+            unsigned int sha256_len = 0;
+            if (!EVP_DigestFinal_ex(mdctx, sha256_value, &sha256_len)) {
+                EVP_MD_CTX_free(mdctx);
+                throw std::runtime_error("EVP_DigestFinal_ex() failed");
+            }
+            EVP_MD_CTX_free(mdctx);
+
+            std::string result;
+            for (size_t i = 0; i < sha256_len; i++) {
+                char buf[3];
+                sprintf(buf, "%02x", sha256_value[i]);
+                buf[2] = '\0';
+                result += buf;
+            }
+            return result;
+        } catch (const std::exception& e) {
+            error(beammp_wide("Sha256 hashing of '") + filename + beammp_wide("' failed: ") + ToWString(e.what()));
+            return "";
+        }
+    }
+    inline std::string GetSha256HashReallyFast(const std::string& text, const beammp_fs_string& filename) {
+        try {
+            EVP_MD_CTX* mdctx;
+            const EVP_MD* md;
+            uint8_t sha256_value[EVP_MAX_MD_SIZE];
+            md = EVP_sha256();
+            if (md == nullptr) {
+                throw std::runtime_error("EVP_sha256() failed");
+            }
+
+            mdctx = EVP_MD_CTX_new();
+            if (mdctx == nullptr) {
+                throw std::runtime_error("EVP_MD_CTX_new() failed");
+            }
+            if (!EVP_DigestInit_ex2(mdctx, md, NULL)) {
+                EVP_MD_CTX_free(mdctx);
+                throw std::runtime_error("EVP_DigestInit_ex2() failed");
+            }
+
+            if (!EVP_DigestUpdate(mdctx, text.data(), text.size())) {
+                EVP_MD_CTX_free(mdctx);
+                throw std::runtime_error("EVP_DigestUpdate() failed");
+            }
+
+            unsigned int sha256_len = 0;
+            if (!EVP_DigestFinal_ex(mdctx, sha256_value, &sha256_len)) {
+                EVP_MD_CTX_free(mdctx);
+                throw std::runtime_error("EVP_DigestFinal_ex() failed");
+            }
+            EVP_MD_CTX_free(mdctx);
+
+            std::string result;
+            for (size_t i = 0; i < sha256_len; i++) {
+                char buf[3];
+                sprintf(buf, "%02x", sha256_value[i]);
+                buf[2] = '\0';
+                result += buf;
+            }
+            return result;
+        } catch (const std::exception& e) {
+            error(beammp_wide("Sha256 hashing of '") + filename + beammp_wide("' failed: ") + ToWString(e.what()));
+            return "";
+        }
+    }
+
+    template<typename T>
+    inline std::vector<char> PrependHeader(const T& data) {
+        std::vector<char> size_buffer(4);
+        uint32_t len = data.size();
+        std::memcpy(size_buffer.data(), &len, 4);
+        std::vector<char> buffer;
+        buffer.reserve(size_buffer.size() + data.size());
+        buffer.insert(buffer.begin(), size_buffer.begin(), size_buffer.end());
+        buffer.insert(buffer.end(), data.begin(), data.end());
+        return buffer;
+    }
+
+    inline uint32_t RecvHeader(SOCKET socket) {
+        std::array<uint8_t, sizeof(uint32_t)> header_buffer {};
+        auto n = recv(socket, reinterpret_cast<char*>(header_buffer.data()), header_buffer.size(), MSG_WAITALL);
+        if (n < 0) {
+            throw std::runtime_error(std::string("recv() of header failed: ") + std::strerror(errno));
+        } else if (n == 0) {
+            throw std::runtime_error("Game disconnected");
+        }
+        return *reinterpret_cast<uint32_t*>(header_buffer.data());
+    }
+
+    /// Throws!!!
+    inline void ReceiveFromGame(SOCKET socket, std::vector<char>& out_data) {
+        auto header = RecvHeader(socket);
+        out_data.resize(header);
+        auto n = recv(socket, reinterpret_cast<char*>(out_data.data()), out_data.size(), MSG_WAITALL);
+        if (n < 0) {
+            throw std::runtime_error(std::string("recv() of data failed: ") + std::strerror(errno));
+        } else if (n == 0) {
+            throw std::runtime_error("Game disconnected");
+        }
+    }
+};
--- a/src/Config.cpp
+++ b/src/Config.cpp
@@ -6,15 +6,17 @@

 #include "Logger.h"
 #include "Network/network.hpp"
+#include "Options.h"
+#include "Utils.h"
 #include <cstdint>
 #include <filesystem>
 #include <fstream>
 #include <nlohmann/json.hpp>
-#include "Options.h"
 namespace fs = std::filesystem;

 std::string Branch;
-std::string CachingDirectory = "./Resources";
+std::filesystem::path CachingDirectory = std::filesystem::path("./Resources");
+bool deleteDuplicateMods = false;

 void ParseConfig(const nlohmann::json& d) {
    if (d["Port"].is_number()) {
@@ -31,8 +33,8 @@ void ParseConfig(const nlohmann::json& d) {
            c = char(tolower(c));
    }
    if (d.contains("CachingDirectory") && d["CachingDirectory"].is_string()) {
-        CachingDirectory = d["CachingDirectory"].get<std::string>();
-        info("Mod caching directory: " + CachingDirectory);
+        CachingDirectory = std::filesystem::path(d["CachingDirectory"].get<std::string>());
+        info(beammp_wide("Mod caching directory: ") + beammp_fs_string(CachingDirectory.relative_path()));
    }

    if (d.contains("Dev") && d["Dev"].is_boolean()) {
@@ -42,6 +44,11 @@ void ParseConfig(const nlohmann::json& d) {
        options.no_launch = dev;
        options.no_update = dev;
    }
+
+    if (d.contains(("DeleteDuplicateMods")) && d["DeleteDuplicateMods"].is_boolean()) {
+        deleteDuplicateMods = d["DeleteDuplicateMods"].get<bool>();
+    }
+
 }

 void ConfigInit() {
--- a/src/GameStart.cpp
+++ b/src/GameStart.cpp
@@ -4,9 +4,9 @@
 SPDX-License-Identifier: AGPL-3.0-or-later
 */

-
+#include <cstring>
+#include "Utils.h"
 #if defined(_WIN32)
-#include <windows.h>
 #include <shlobj.h>
 #elif defined(__linux__)
 #include "vdf_parser.hpp"
@@ -18,93 +18,162 @@
 #endif

 #include "Logger.h"
+#include "Options.h"
 #include "Startup.h"
 #include <Security/Init.h>
 #include <filesystem>
 #include <thread>
-#include "Options.h"
+
+#include <fstream>

 unsigned long GamePID = 0;
 #if defined(_WIN32)
-std::string QueryKey(HKEY hKey, int ID);
-std::string GetGamePath() {
-    static std::string Path;
+std::wstring QueryKey(HKEY hKey, int ID);
+std::filesystem::path GetGamePath() {
+    static std::filesystem::path Path;
    if (!Path.empty())
-        return Path;
+        return Path.wstring();

-    HKEY hKey;
-    LPCTSTR sk = "Software\\BeamNG\\BeamNG.drive";
-    LONG openRes = RegOpenKeyEx(HKEY_CURRENT_USER, sk, 0, KEY_ALL_ACCESS, &hKey);
-    if (openRes != ERROR_SUCCESS) {
-        fatal("Please launch the game at least once!");
+    if (options.user_path) {
+        if (std::filesystem::exists(options.user_path)) {
+            Path = options.user_path;
+            debug(L"Using custom user folder path: " + Path.wstring());
+        } else
+            warn(L"Invalid or non-existent path (" + Utils::ToWString(options.user_path) + L") specified using --user-path, skipping");
    }
-    Path = QueryKey(hKey, 4);

-    if (Path.empty()) {
-        Path = "";
-        char appDataPath[MAX_PATH];
-        HRESULT result = SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, appDataPath);
-        if (SUCCEEDED(result)) {
-            Path = appDataPath;
+    if (const auto startupIniPath = std::filesystem::path(GetGameDir()) / "startup.ini"; exists(startupIniPath)) {
+
+        if (std::ifstream startupIni(startupIniPath); startupIni.is_open()) {
+            std::string contents((std::istreambuf_iterator(startupIni)), std::istreambuf_iterator<char>());
+            startupIni.close();
+
+            auto ini = Utils::ParseINI(contents);
+            if (ini.empty()) 
+                warn("Failed to parse startup.ini");
+            else
+                debug("Successfully parsed startup.ini");
+
+            std::wstring userPath;
+            if (ini.contains("filesystem") && std::get<std::map<std::string, std::string>>(ini["filesystem"]).contains("UserPath"))
+                userPath = Utils::ToWString(std::get<std::map<std::string, std::string>>(ini["filesystem"])["UserPath"]);
+
+            if (userPath = Utils::ExpandEnvVars(userPath); std::filesystem::exists(userPath)) {
+                Path = userPath;
+                debug(L"Using custom user folder path from startup.ini: " + Path.wstring());
+            } else
+                warn(L"Found custom user folder path (" + userPath + L") in startup.ini but it doesn't exist, skipping");
        }

        if (Path.empty()) {
-            fatal("Cannot get Local Appdata directory");
-        }
+            wchar_t* appDataPath = new wchar_t[MAX_PATH];
+            HRESULT result = SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, appDataPath);

-        Path += "\\BeamNG.drive\\";
+            if (!SUCCEEDED(result)) {
+                fatal("Cannot get Local Appdata directory");
+            }
+
+            auto BeamNGAppdataPath = std::filesystem::path(appDataPath) / "BeamNG";
+
+            if (const auto beamngIniPath = BeamNGAppdataPath / "BeamNG.Drive.ini"; exists(beamngIniPath)) {
+                if (std::ifstream beamngIni(beamngIniPath); beamngIni.is_open()) {
+                    std::string contents((std::istreambuf_iterator(beamngIni)), std::istreambuf_iterator<char>());
+                    beamngIni.close();
+
+                    auto ini = Utils::ParseINI(contents);
+                    if (ini.empty())
+                        warn("Failed to parse BeamNG.Drive.ini");
+                    else
+                        debug("Successfully parsed BeamNG.Drive.ini");
+
+                    std::wstring userPath;
+
+                    if (ini.contains("userFolder")) {
+                        userPath = Utils::ToWString(std::get<std::string>(ini["userFolder"]));
+                        userPath.erase(0, userPath.find_first_not_of(L" \t"));
+
+                    }
+
+                    if (userPath = std::filesystem::path(Utils::ExpandEnvVars(userPath)); std::filesystem::exists(userPath)) {
+                        Path = userPath;
+                        debug(L"Using custom user folder path from BeamNG.Drive.ini: " + Path.wstring());
+                    } else
+                        warn(L"Found custom user folder path (" + userPath + L") in BeamNG.Drive.ini but it doesn't exist, skipping");
+                }
+            }
+
+            if (Path.empty()) {
+                Path = BeamNGAppdataPath / "BeamNG.drive";
+            }
+
+            delete[] appDataPath;
+        }
    }

    std::string Ver = CheckVer(GetGameDir());
    Ver = Ver.substr(0, Ver.find('.', Ver.find('.') + 1));
-    Path += Ver + "\\";
+    Path /= Utils::ToWString("current");
    return Path;
 }
 #elif defined(__linux__)
-std::string GetGamePath() {
+std::filesystem::path GetGamePath() {
    // Right now only steam is supported
    struct passwd* pw = getpwuid(getuid());
    std::string homeDir = pw->pw_dir;

-    std::string Path = homeDir + "/.local/share/BeamNG.drive/";
+    std::string Path = homeDir + "/.local/share/BeamNG/BeamNG.drive/";
    std::string Ver = CheckVer(GetGameDir());
    Ver = Ver.substr(0, Ver.find('.', Ver.find('.') + 1));
-    Path += Ver + "/";
+    Path += "current/";
    return Path;
 }
 #endif

 #if defined(_WIN32)
-void StartGame(std::string Dir) {
+void StartGame(std::wstring Dir) {
    BOOL bSuccess = FALSE;
    PROCESS_INFORMATION pi;
-    STARTUPINFO si = { 0 };
+    STARTUPINFOW si = { 0 };
    si.cb = sizeof(si);
-    std::string BaseDir = Dir; //+"\\Bin64";
+    std::wstring BaseDir = Dir; //+"\\Bin64";
    // Dir += R"(\Bin64\BeamNG.drive.x64.exe)";
-    Dir += "\\BeamNG.drive.exe";
-    std::string gameArgs = "";
+    Dir += L"\\BeamNG.drive.exe";
+    std::wstring gameArgs = L"";

    for (int i = 0; i < options.game_arguments_length; i++) {
-        gameArgs += " ";
-        gameArgs += options.game_arguments[i];
+        gameArgs += L" ";
+        gameArgs += Utils::ToWString(options.game_arguments[i]);
    }

-    bSuccess = CreateProcessA(nullptr, (LPSTR)(Dir + gameArgs).c_str(), nullptr, nullptr, TRUE, 0, nullptr, BaseDir.c_str(), &si, &pi);
+    debug(L"BeamNG executable path: " + Dir);
+
+    bSuccess = CreateProcessW(nullptr, (wchar_t*)(Dir + gameArgs).c_str(), nullptr, nullptr, TRUE, 0, nullptr, BaseDir.c_str(), &si, &pi);
    if (bSuccess) {
        info("Game Launched!");
        GamePID = pi.dwProcessId;
        WaitForSingleObject(pi.hProcess, INFINITE);
        error("Game Closed! launcher closing soon");
    } else {
-        error("Failed to Launch the game! launcher closing soon");
+        std::string err = "";
+
+        DWORD dw = GetLastError();
+        LPVOID lpErrorMsgBuffer;
+
+        if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw,
+                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpErrorMsgBuffer, 0, nullptr)
+            == 0) {
+            err = "Unknown error code: " + std::to_string(dw);
+        } else {
+            err = "Error " + std::to_string(dw) + ": " + (char*)lpErrorMsgBuffer;
+        }
+
+        error("Failed to Launch the game! launcher closing soon. " + err);
    }
    std::this_thread::sleep_for(std::chrono::seconds(5));
    exit(2);
 }
 #elif defined(__linux__)
 void StartGame(std::string Dir) {
-    int status;
    std::string filename = (Dir + "/BinLinux/BeamNG.drive.x64");
    std::vector<const char*> argv;
    argv.push_back(filename.data());
@@ -114,11 +183,24 @@ void StartGame(std::string Dir) {

    argv.push_back(nullptr);
    pid_t pid;
-    posix_spawn_file_actions_t spawn_actions;
-    posix_spawn_file_actions_init(&spawn_actions);
-    posix_spawn_file_actions_addclose(&spawn_actions, STDOUT_FILENO);
-    posix_spawn_file_actions_addclose(&spawn_actions, STDERR_FILENO);
-    int result = posix_spawn(&pid, filename.c_str(), &spawn_actions, nullptr, const_cast<char**>(argv.data()), environ);
+
+    posix_spawn_file_actions_t file_actions;
+    auto status = posix_spawn_file_actions_init(&file_actions);
+    // disable stdout
+    if (status != 0) {
+        error(std::string("posix_spawn_file_actions_init failed: ") + std::strerror(errno));
+    }
+    status = posix_spawn_file_actions_addclose(&file_actions, STDOUT_FILENO);
+    if (status != 0) {
+        error(std::string("posix_spawn_file_actions_addclose for STDOUT failed: ") + std::strerror(errno));
+    }
+    status = posix_spawn_file_actions_addclose(&file_actions, STDERR_FILENO);
+    if (status != 0) {
+        error(std::string("posix_spawn_file_actions_addclose for STDERR failed: ") + std::strerror(errno));
+    }
+
+    // launch the game
+    int result = posix_spawn(&pid, filename.c_str(), &file_actions, NULL, const_cast<char**>(argv.data()), environ);

    if (result != 0) {
        error("Failed to Launch the game! launcher closing soon");
@@ -133,7 +215,7 @@ void StartGame(std::string Dir) {
 }
 #endif

-void InitGame(const std::string& Dir) {
+void InitGame(const beammp_fs_string& Dir) {
    if (!options.no_launch) {
        std::thread Game(StartGame, Dir);
        Game.detach();
--- a/src/Logger.cpp
+++ b/src/Logger.cpp
@@ -7,6 +7,7 @@

 #include "Logger.h"
 #include "Startup.h"
+#include "Utils.h"
 #include <chrono>
 #include <fstream>
 #include <sstream>
@@ -36,7 +37,7 @@ std::string getDate() {
 }
 void InitLog() {
    std::ofstream LFS;
-    LFS.open(GetEP() + "Launcher.log");
+    LFS.open(GetEP() + beammp_wide("Launcher.log"));
    if (!LFS.is_open()) {
        error("logger file init failed!");
    } else
@@ -44,41 +45,85 @@ void InitLog() {
 }
 void addToLog(const std::string& Line) {
    std::ofstream LFS;
-    LFS.open(GetEP() + "Launcher.log", std::ios_base::app);
+    LFS.open(GetEP() + beammp_wide("Launcher.log"), std::ios_base::app);
+    LFS << Line.c_str();
+    LFS.close();
+}
+void addToLog(const std::wstring& Line) {
+    std::wofstream LFS;
+    LFS.open(GetEP() + beammp_wide("Launcher.log"), std::ios_base::app);
    LFS << Line.c_str();
    LFS.close();
 }
 void info(const std::string& toPrint) {
    std::string Print = getDate() + "[INFO] " + toPrint + "\n";
-    std::cout << Print;
+    beammp_stdout << Utils::ToWString(Print);
    addToLog(Print);
 }
 void debug(const std::string& toPrint) {
    std::string Print = getDate() + "[DEBUG] " + toPrint + "\n";
    if (options.verbose) {
-        std::cout << Print;
+        beammp_stdout << Utils::ToWString(Print);
    }
    addToLog(Print);
 }
 void warn(const std::string& toPrint) {
    std::string Print = getDate() + "[WARN] " + toPrint + "\n";
-    std::cout << Print;
+    beammp_stdout << Utils::ToWString(Print);
    addToLog(Print);
 }
 void error(const std::string& toPrint) {
    std::string Print = getDate() + "[ERROR] " + toPrint + "\n";
-    std::cout << Print;
+    beammp_stdout << Utils::ToWString(Print);
    addToLog(Print);
 }
 void fatal(const std::string& toPrint) {
    std::string Print = getDate() + "[FATAL] " + toPrint + "\n";
-    std::cout << Print;
+    beammp_stdout << Utils::ToWString(Print);
    addToLog(Print);
    std::this_thread::sleep_for(std::chrono::seconds(5));
    std::exit(1);
 }
 void except(const std::string& toPrint) {
    std::string Print = getDate() + "[EXCEP] " + toPrint + "\n";
-    std::cout << Print;
+    beammp_stdout << Utils::ToWString(Print);
    addToLog(Print);
 }
+
+
+#ifdef _WIN32
+void info(const std::wstring& toPrint) {
+    std::wstring Print = Utils::ToWString(getDate()) + L"[INFO] " + toPrint + L"\n";
+    std::wcout << Print;
+    addToLog(Print);
+}
+void debug(const std::wstring& toPrint) {
+    std::wstring Print = Utils::ToWString(getDate()) + L"[DEBUG] " + toPrint + L"\n";
+    if (options.verbose) {
+        std::wcout << Print;
+    }
+    addToLog(Print);
+}
+void warn(const std::wstring& toPrint) {
+    std::wstring Print = Utils::ToWString(getDate()) + L"[WARN] " + toPrint + L"\n";
+    std::wcout << Print;
+    addToLog(Print);
+}
+void error(const std::wstring& toPrint) {
+    std::wstring Print = Utils::ToWString(getDate()) + L"[ERROR] " + toPrint + L"\n";
+    std::wcout << Print;
+    addToLog(Print);
+}
+void fatal(const std::wstring& toPrint) {
+    std::wstring Print = Utils::ToWString(getDate()) + L"[FATAL] " + toPrint + L"\n";
+    std::wcout << Print;
+    addToLog(Print);
+    std::this_thread::sleep_for(std::chrono::seconds(5));
+    std::exit(1);
+}
+void except(const std::wstring& toPrint) {
+    std::wstring Print = Utils::ToWString(getDate()) + L"[EXCEP] " + toPrint + L"\n";
+    std::wcout << Print;
+    addToLog(Print);
+}
+#endif
--- a/src/Network/Core.cpp
+++ b/src/Network/Core.cpp
@@ -7,11 +7,13 @@
 #include "Http.h"
 #include "Network/network.hpp"
 #include "Security/Init.h"
+#include "Utils.h"
 #include <cstdlib>
 #include <regex>
 #if defined(_WIN32)
 #include <winsock2.h>
 #include <ws2tcpip.h>
+#include <shellapi.h>
 #elif defined(__linux__)
 #include <cstring>
 #include <errno.h>
@@ -141,7 +143,7 @@ void GetServerInfo(std::string Data) {
    const std::string buffer = ([&]() -> std::string {
        int32_t Header;
        std::vector<char> data(sizeof(Header));
-        int32_t Temp = recv(ISock, data.data(), sizeof(Header), MSG_WAITALL);
+        int Temp = recv(ISock, data.data(), sizeof(Header), MSG_WAITALL);

        auto checkBytes = ([&](const int32_t bytes) -> bool {
            if (bytes == 0) {
@@ -187,7 +189,8 @@ void CoreSend(std::string data) {
    std::lock_guard lock(sendMutex);
    
    if (CoreSocket != -1) {
-        int res = send(CoreSocket, (data + "\n").c_str(), int(data.size()) + 1, 0);
+        auto ToSend = Utils::PrependHeader(data);
+        int res = send(CoreSocket, ToSend.data(), ToSend.size(), 0);
        if (res < 0) {
            debug("(Core) send failed with error: " + std::to_string(WSAGetLastError()));
        }
@@ -200,7 +203,17 @@ bool IsAllowedLink(const std::string& Link) {
    return std::regex_search(Link, link_match, link_pattern) && link_match.position() == 0;
 }

+std::vector<std::future<void>> futures;
+
 void Parse(std::string Data, SOCKET CSocket) {
+    std::erase_if(futures, [](const std::future<void>& f) {
+        if (f.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
+            return true;
+        }
+        return false;
+    });
+
+
    char Code = Data.at(0), SubCode = 0;
    if (Data.length() > 1)
        SubCode = Data.at(1);
@@ -213,9 +226,9 @@ void Parse(std::string Data, SOCKET CSocket) {
            Terminate = true;
            TCPTerminate = true;
            Data.clear();
-            auto future = std::async(std::launch::async, []() {
+            futures.push_back(std::async(std::launch::async, []() {
                CoreSend("B" + HTTP::Get("https://backend.beammp.com/servers-info"));
-            });
+            }));
        }
        break;
    case 'C':
@@ -267,7 +280,7 @@ void Parse(std::string Data, SOCKET CSocket) {
                Ping = "-2";
            else
                Ping = std::to_string(ping);
-            Data = std::string(UlStatus) + "\n" + "Up" + Ping;
+            Data = "Up" + Ping;
        }
        break;
    case 'M':
@@ -312,9 +325,9 @@ void Parse(std::string Data, SOCKET CSocket) {
            }
            Data = "N" + Auth.dump();
        } else {
-            auto future = std::async(std::launch::async, [data = std::move(Data)]() {
+            futures.push_back(std::async(std::launch::async, [data = std::move(Data)]() {
                CoreSend("N" + Login(data.substr(data.find(':') + 1)));
-            });
+            }));
            Data.clear();
        }
        break;
@@ -337,50 +350,29 @@ void Parse(std::string Data, SOCKET CSocket) {
        Data.clear();
        break;
    }
-    if (!Data.empty())
-        CoreSend(Data);
+    if (!Data.empty() && CSocket != -1) {
+        auto ToSend = Utils::PrependHeader(Data);
+        int res = send(CSocket, ToSend.data(), ToSend.size(), 0);
+        if (res < 0) {
+            debug("(Core) send failed with error: " + std::to_string(WSAGetLastError()));
+        }
+    }
 }
 void GameHandler(SOCKET Client) {
    CoreSocket = Client;
-    int32_t Size, Temp, Rcv;
+    std::vector<char> data{};
+    int Temp;
    char Header[10] = { 0 };
    do {
-        Rcv = 0;
-        do {
-            Temp = recv(Client, &Header[Rcv], 1, 0);
-            if (Temp < 1)
-                break;
-            if (!isdigit(Header[Rcv]) && Header[Rcv] != '>') {
-                error("(Core) Invalid lua communication");
-                KillSocket(Client);
-                return;
-            }
-        } while (Header[Rcv++] != '>');
-        if (Temp < 1)
-            break;
-        if (std::from_chars(Header, &Header[Rcv], Size).ptr[0] != '>') {
-            debug("(Core) Invalid lua Header -> " + std::string(Header, Rcv));
+        try {
+            Utils::ReceiveFromGame(Client, data);
+            Parse(std::string(data.data(), data.size()), Client);
+        } catch (const std::exception& e) {
+            error(std::string("Error while receiving from game on core: ") + e.what());
            break;
        }
-        std::string Ret(Size, 0);
-        Rcv = 0;
-
-        do {
-            Temp = recv(Client, &Ret[Rcv], Size - Rcv, 0);
-            if (Temp < 1)
-                break;
-            Rcv += Temp;
-        } while (Rcv < Size);
-        if (Temp < 1)
-            break;
-
-        Parse(Ret, Client);
-    } while (Temp > 0);
-    if (Temp == 0) {
-        debug("(Core) Connection closing");
-    } else {
-        debug("(Core) recv failed with error: " + std::to_string(WSAGetLastError()));
-    }
+    } while (true);
+    debug("(Core) Connection closing");
    NetReset();
    KillSocket(Client);
 }
--- a/src/Network/GlobalHandler.cpp
+++ b/src/Network/GlobalHandler.cpp
@@ -5,6 +5,7 @@
 */

 #include "Network/network.hpp"
+#include "Utils.h"
 #include <memory>
 #include <zlib.h>
 #if defined(_WIN32)
@@ -21,17 +22,20 @@
 #endif

 #include "Logger.h"
+#include "Options.h"
 #include <charconv>
 #include <mutex>
 #include <string>
 #include <thread>
 #include "Options.h"
+#include <chrono>

 std::chrono::time_point<std::chrono::high_resolution_clock> PingStart, PingEnd;
 bool GConnected = false;
 bool CServer = true;
 SOCKET CSocket = -1;
 SOCKET GSocket = -1;
+std::string magic;

 int KillSocket(uint64_t Dead) {
    if (Dead == (SOCKET)-1) {
@@ -60,30 +64,13 @@ bool CheckBytes(uint32_t Bytes) {
 void GameSend(std::string_view Data) {
    static std::mutex Lock;
    std::scoped_lock Guard(Lock);
-    if (TCPTerminate || !GConnected || CSocket == -1)
-        return;
-    int32_t Size, Temp, Sent;
-    Size = int32_t(Data.size());
-    Sent = 0;
-#ifdef DEBUG
-    if (Size > 1000) {
-        debug("Launcher -> game (" + std::to_string(Size) + ")");
-    }
-#endif
-    do {
-        if (Sent > -1) {
-            Temp = send(CSocket, &Data[Sent], Size - Sent, 0);
-        }
-        if (!CheckBytes(Temp))
-            return;
-        Sent += Temp;
-    } while (Sent < Size);
-    // send separately to avoid an allocation for += "\n"
-    Temp = send(CSocket, "\n", 1, 0);
-    if (!CheckBytes(Temp)) {
-        return;
+    auto ToSend = Utils::PrependHeader<std::string_view>(Data);
+    auto Result = send(CSocket, ToSend.data(), ToSend.size(), 0);
+    if (Result < 0) {
+        error("(Game) send failed with error: " + std::to_string(WSAGetLastError()));
    }
 }
+
 void ServerSend(std::string Data, bool Rel) {
    if (Terminate || Data.empty())
        return;
@@ -217,6 +204,8 @@ void ParserAsync(std::string_view Data) {
        MStatus = Data;
        UlStatus = "Uldone";
        return;
+    case 'U':
+        magic = Data.substr(1);
    default:
        break;
    }
@@ -261,42 +250,22 @@ void TCPGameServer(const std::string& IP, int Port) {
            NetMainThread = std::make_unique<std::thread>(NetMain, IP, Port);
            CServer = false;
        }
-        int32_t Size, Temp, Rcv;
+        int32_t Size, Rcv;
+        int Temp;
        char Header[10] = { 0 };
+        std::vector<char> data {};

        // Read byte by byte until '>' is rcved then get the size and read based on it
        do {
-            Rcv = 0;
-
-            do {
-                Temp = recv(CSocket, &Header[Rcv], 1, 0);
-                if (Temp < 1 || TCPTerminate)
-                    break;
-            } while (Header[Rcv++] != '>');
-            if (Temp < 1 || TCPTerminate)
-                break;
-            if (std::from_chars(Header, &Header[Rcv], Size).ptr[0] != '>') {
-                debug("(Game) Invalid lua Header -> " + std::string(Header, Rcv));
+            try {
+                Utils::ReceiveFromGame(CSocket, data);
+                ServerSend(std::string(data.data(), data.size()), false);
+            } catch (const std::exception& e) {
+                error(std::string("Error while receiving from game on proxy: ") + e.what());
                break;
            }
-            std::string Ret(Size, 0);
-            Rcv = 0;
-            do {
-                Temp = recv(CSocket, &Ret[Rcv], Size - Rcv, 0);
-                if (Temp < 1)
-                    break;
-                Rcv += Temp;
-            } while (Rcv < Size && !TCPTerminate);
-            if (Temp < 1 || TCPTerminate)
-                break;
-
-            ServerSend(Ret, false);
-
-        } while (Temp > 0 && !TCPTerminate);
-        if (Temp == 0)
-            debug("(Proxy) Connection closing");
-        else
-            debug("(Proxy) recv failed error : " + std::to_string(WSAGetLastError()));
+        } while (!TCPTerminate);
+        debug("(Proxy) Connection closing");
    }
    TCPTerminate = true;
    GConnected = false;
--- a/src/Network/Http.cpp
+++ b/src/Network/Http.cpp
@@ -20,45 +20,6 @@
 #include <mutex>
 #include <nlohmann/json.hpp>

-void WriteHttpDebug(const httplib::Client& client, const std::string& method, const std::string& target, const httplib::Result& result) try {
-    const std::filesystem::path folder = ".https_debug";
-    std::filesystem::create_directories(folder);
-    if (!std::filesystem::exists(folder / "WHAT IS THIS FOLDER.txt")) {
-        std::ofstream ignore { folder / "WHAT IS THIS FOLDER.txt" };
-        ignore << "This folder exists to help debug current issues with the backend. Do not share this folder with anyone but BeamMP staff. It contains detailed logs of any failed http requests." << std::endl;
-    }
-    const auto file = folder / (method + ".json");
-    // 1 MB limit
-    if (std::filesystem::exists(file) && std::filesystem::file_size(file) > 1'000'000) {
-        std::filesystem::rename(file, file.generic_string() + ".bak");
-    }
-
-    std::ofstream of { file, std::ios::app };
-    nlohmann::json js {
-        { "utc", std::chrono::system_clock::now().time_since_epoch().count() },
-        { "target", target },
-        { "client_info", {
-                             { "openssl_verify_result", client.get_openssl_verify_result() },
-                             { "host", client.host() },
-                             { "port", client.port() },
-                             { "socket_open", client.is_socket_open() },
-                             { "valid", client.is_valid() },
-                         } },
-    };
-    if (result) {
-        auto value = result.value();
-        js["result"] = {};
-        js["result"]["body"] = value.body;
-        js["result"]["status"] = value.status;
-        js["result"]["headers"] = value.headers;
-        js["result"]["version"] = value.version;
-        js["result"]["location"] = value.location;
-        js["result"]["reason"] = value.reason;
-    }
-    of << js.dump();
-} catch (const std::exception& e) {
-    error(e.what());
-}

 static size_t CurlWriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    std::string* Result = reinterpret_cast<std::string*>(userp);
@@ -127,7 +88,7 @@ std::string HTTP::Post(const std::string& IP, const std::string& Fields) {
    return Ret;
 }

-bool HTTP::Download(const std::string& IP, const std::string& Path) {
+bool HTTP::Download(const std::string& IP, const beammp_fs_string& Path, const std::string& Hash) {
    static std::mutex Lock;
    std::scoped_lock Guard(Lock);

@@ -139,13 +100,23 @@ bool HTTP::Download(const std::string& IP, const std::string& Path) {
        return false;
    }

+    std::string RetHash = Utils::GetSha256HashReallyFast(Ret, Path);
+
+    debug("Return hash: " + RetHash);
+    debug("Expected hash: " + Hash);
+
+    if (RetHash != Hash) {
+        error("Downloaded file hash does not match expected hash");
+        return false;
+    }
+
    std::ofstream File(Path, std::ios::binary);
    if (File.is_open()) {
        File << Ret;
        File.close();
        info("Download Complete!");
    } else {
-        error("Failed to open file directory: " + Path);
+        error(beammp_wide("Failed to open file directory: ") + Path);
        return false;
    }

--- a/src/Network/Resources.cpp
+++ b/src/Network/Resources.cpp
@@ -164,9 +164,12 @@ std::vector<char> TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {
    do {
        // receive at most some MB at a time
        int Len = std::min(int(Size - Rcv), 1 * 1024 * 1024);
-        int32_t Temp = recv(Sock, &File[Rcv], Len, MSG_WAITALL);
-        if (Temp < 1) {
-            info(std::to_string(Temp));
+        int Temp = recv(Sock, &File[Rcv], Len, MSG_WAITALL);
+        if (Temp == -1 || Temp == 0) {
+            debug("Recv returned: " + std::to_string(Temp));
+            if (Temp == -1) {
+                error("Socket error during download: " + std::to_string(WSAGetLastError()));
+            }
            UUl("Socket Closed Code 1");
            KillSocket(Sock);
            Terminate = true;
@@ -177,8 +180,8 @@ std::vector<char> TCPRcvRaw(SOCKET Sock, uint64_t& GRcv, uint64_t Size) {

        auto end = std::chrono::high_resolution_clock::now();
        auto difference = end - start;
-        float bits_per_s = float(Rcv * 8) / float(std::chrono::duration_cast<std::chrono::milliseconds>(difference).count());
-        float megabits_per_s = bits_per_s / 1000;
+        double bits_per_s = double(Rcv * 8) / double(std::chrono::duration_cast<std::chrono::milliseconds>(difference).count());
+        double megabits_per_s = bits_per_s / 1000;
        DownloadSpeed = megabits_per_s;
        // every 8th iteration print the speed
        if (i % 8 == 0) {
@@ -298,68 +301,6 @@ void InvalidResource(const std::string& File) {
    Terminate = true;
 }

-std::string GetSha256HashReallyFast(const std::string& filename) {
-    try {
-        EVP_MD_CTX* mdctx;
-        const EVP_MD* md;
-        uint8_t sha256_value[EVP_MAX_MD_SIZE];
-        md = EVP_sha256();
-        if (md == nullptr) {
-            throw std::runtime_error("EVP_sha256() failed");
-        }
-
-        mdctx = EVP_MD_CTX_new();
-        if (mdctx == nullptr) {
-            throw std::runtime_error("EVP_MD_CTX_new() failed");
-        }
-        if (!EVP_DigestInit_ex2(mdctx, md, NULL)) {
-            EVP_MD_CTX_free(mdctx);
-            throw std::runtime_error("EVP_DigestInit_ex2() failed");
-        }
-
-        std::ifstream stream(filename, std::ios::binary);
-
-        const size_t FileSize = std::filesystem::file_size(filename);
-        size_t Read = 0;
-        std::vector<char> Data;
-        while (Read < FileSize) {
-            Data.resize(size_t(std::min<size_t>(FileSize - Read, 4096)));
-            size_t RealDataSize = Data.size();
-            stream.read(Data.data(), std::streamsize(Data.size()));
-            if (stream.eof() || stream.fail()) {
-                RealDataSize = size_t(stream.gcount());
-            }
-            Data.resize(RealDataSize);
-            if (RealDataSize == 0) {
-                break;
-            }
-            if (RealDataSize > 0 && !EVP_DigestUpdate(mdctx, Data.data(), Data.size())) {
-                EVP_MD_CTX_free(mdctx);
-                throw std::runtime_error("EVP_DigestUpdate() failed");
-            }
-            Read += RealDataSize;
-        }
-        unsigned int sha256_len = 0;
-        if (!EVP_DigestFinal_ex(mdctx, sha256_value, &sha256_len)) {
-            EVP_MD_CTX_free(mdctx);
-            throw std::runtime_error("EVP_DigestFinal_ex() failed");
-        }
-        EVP_MD_CTX_free(mdctx);
-
-        std::string result;
-        for (size_t i = 0; i < sha256_len; i++) {
-            char buf[3];
-            sprintf(buf, "%02x", sha256_value[i]);
-            buf[2] = 0;
-            result += buf;
-        }
-        return result;
-    } catch (const std::exception& e) {
-        error("Sha256 hashing of '" + filename + "' failed: " + e.what());
-        return "";
-    }
-}
-
 struct ModInfo {
    static std::pair<bool, std::vector<ModInfo>> ParseModInfosFromPacket(const std::string& packet) {
        bool success = false;
@@ -377,6 +318,11 @@ struct ModInfo {
                    .Hash = entry["hash"],
                    .HashAlgorithm = entry["hash_algorithm"],
                };
+
+                if (entry.contains("protected")) {
+                    modInfo.Protected = entry["protected"];
+                }
+
                modInfos.push_back(modInfo);
                success = true;
            }
@@ -390,13 +336,14 @@ struct ModInfo {
    size_t FileSize;
    std::string Hash;
    std::string HashAlgorithm;
+    bool Protected = false;
 };

 nlohmann::json modUsage = {};

 void UpdateModUsage(const std::string& fileName) {
    try {
-        fs::path usageFile = fs::path(CachingDirectory) / "mods.json";
+        fs::path usageFile = CachingDirectory / "mods.json";

        if (!fs::exists(usageFile)) {
            if (std::ofstream file(usageFile); !file.is_open()) {
@@ -414,7 +361,7 @@ void UpdateModUsage(const std::string& fileName) {
        }

        if (modUsage.empty()) {
-            auto Size = fs::file_size(fs::path(CachingDirectory) / "mods.json");
+            auto Size = fs::file_size(CachingDirectory / "mods.json");
            std::string modsJson(Size, 0);
            file.read(&modsJson[0], Size);

@@ -466,22 +413,45 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo

    info("Syncing...");

-    int ModNo = 1;
+    std::vector<std::pair<std::string, std::filesystem::path>> CachedMods = {};
+    if (deleteDuplicateMods) {
+        for (const auto& entry : fs::directory_iterator(CachingDirectory)) {
+            const std::string filename = entry.path().filename().string();
+            if (entry.is_regular_file() && entry.path().extension() == ".zip" && filename.length() > 10) {
+                CachedMods.push_back(std::make_pair(filename.substr(0, filename.length() - 13) + ".zip", entry.path()));
+            }
+        }
+    }
+
+    int ModNo = 0;
    int TotalMods = ModInfos.size();
    for (auto ModInfoIter = ModInfos.begin(), AlsoModInfoIter = ModInfos.begin(); ModInfoIter != ModInfos.end() && !Terminate; ++ModInfoIter, ++AlsoModInfoIter) {
+        ++ModNo;
+        if (deleteDuplicateMods) {
+            for (auto& CachedMod : CachedMods) {
+                const bool cachedModExists = CachedMod.first == ModInfoIter->FileName;
+                const bool cachedModIsNotNewestVersion = CachedMod.second.stem().string() + ".zip" != std::filesystem::path(ModInfoIter->FileName).stem().string() + "-" + ModInfoIter->Hash.substr(0, 8) + ".zip";
+                if (cachedModExists && cachedModIsNotNewestVersion) {
+                    debug("Found duplicate mod '" + CachedMod.second.stem().string() + ".zip" + "' in cache, removing it");
+                    std::filesystem::remove(CachedMod.second);
+                    break;
+                }
+            }
+        }
        if (ModInfoIter->Hash.length() < 8 || ModInfoIter->HashAlgorithm != "sha256") {
            error("Unsupported hash algorithm or invalid hash for '" + ModInfoIter->FileName + "'");
            Terminate = true;
            return;
        }
        auto FileName = std::filesystem::path(ModInfoIter->FileName).stem().string() + "-" + ModInfoIter->Hash.substr(0, 8) + std::filesystem::path(ModInfoIter->FileName).extension().string();
-        auto PathToSaveTo = (fs::path(CachingDirectory) / FileName).string();
-        if (fs::exists(PathToSaveTo) && GetSha256HashReallyFast(PathToSaveTo) == ModInfoIter->Hash) {
+        auto PathToSaveTo = (CachingDirectory / FileName);
+        if (fs::exists(PathToSaveTo) && Utils::GetSha256HashReallyFastFile(PathToSaveTo) == ModInfoIter->Hash) {
            debug("Mod '" + FileName + "' found in cache");
+            UpdateUl(false, std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + ModInfoIter->FileName);
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            try {
-                if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                    fs::create_directories(GetGamePath() + "mods/multiplayer");
+                if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
+                    fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
                }
                auto modname = ModInfoIter->FileName;
 #if defined(__linux__)
@@ -505,15 +475,16 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
            }
            WaitForConfirm();
            continue;
-        } else if (auto OldCachedPath = fs::path(CachingDirectory) / std::filesystem::path(ModInfoIter->FileName).filename();
-                   fs::exists(OldCachedPath) && GetSha256HashReallyFast(OldCachedPath.string()) == ModInfoIter->Hash) {
+        } else if (auto OldCachedPath = CachingDirectory / std::filesystem::path(ModInfoIter->FileName).filename();
+                   fs::exists(OldCachedPath) && Utils::GetSha256HashReallyFastFile(OldCachedPath) == ModInfoIter->Hash) {
            debug("Mod '" + FileName + "' found in old cache, copying it to the new cache");
+            UpdateUl(false, std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + ModInfoIter->FileName);
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            try {
                fs::copy_file(OldCachedPath, PathToSaveTo, fs::copy_options::overwrite_existing);

-                if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                    fs::create_directories(GetGamePath() + "mods/multiplayer");
+                if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
+                    fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
                }

                auto modname = ModInfoIter->FileName;
@@ -541,10 +512,20 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
            WaitForConfirm();
            continue;
        }
+
+        if (ModInfoIter->Protected) {
+            std::string message = "Mod '" + ModInfoIter->FileName + "' is protected and therefore must be placed in the Resources/Caching folder manually here: " + absolute(CachingDirectory).string();
+
+            error(message);
+            UUl(message);
+            Terminate = true;
+            return;
+        }
+
        CheckForDir();
        std::string FName = ModInfoIter->FileName;
        do {
-            debug("Loading file '" + FName + "' to '" + PathToSaveTo + "'");
+            debug(beammp_wide("Loading file '") + Utils::ToWString(FName) + beammp_wide("' to '") + beammp_fs_string(PathToSaveTo) + beammp_wide("'"));
            TCPSend("f" + ModInfoIter->FileName, Sock);

            std::string Data = TCPRcv(Sock);
@@ -554,6 +535,13 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
                break;
            }

+            if (Data != "AG") {
+                UUl("Received corrupted download confirmation, aborting download.");
+                debug("Corrupted download confirmation: " + Data);
+                Terminate = true;
+                break;
+            }
+
            std::string Name = std::to_string(ModNo) + "/" + std::to_string(TotalMods) + ": " + FName;

            std::vector<char> DownloadedFile = SingleNormalDownload(Sock, ModInfoIter->FileSize, Name);
@@ -568,15 +556,20 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
                OutFile.write(DownloadedFile.data(), DownloadedFile.size());
                OutFile.flush();
            }
-            // 2. verify size
+            // 2. verify size and hash
            if (std::filesystem::file_size(PathToSaveTo) != DownloadedFile.size()) {
-                error("Failed to write the entire file '" + PathToSaveTo + "' correctly (file size mismatch)");
+                error(beammp_wide("Failed to write the entire file '") + beammp_fs_string(PathToSaveTo) + beammp_wide("' correctly (file size mismatch)"));
+                Terminate = true;
+            }
+
+            if (Utils::GetSha256HashReallyFastFile(PathToSaveTo) != ModInfoIter->Hash) {
+                error(beammp_wide("Failed to write or download the entire file '") + beammp_fs_string(PathToSaveTo) + beammp_wide("' correctly (hash mismatch)"));
                Terminate = true;
            }
        } while (fs::file_size(PathToSaveTo) != ModInfoIter->FileSize && !Terminate);
        if (!Terminate) {
-            if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                fs::create_directories(GetGamePath() + "mods/multiplayer");
+            if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
+                fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
            }

 // Linux version of the game doesnt support uppercase letters in mod names
@@ -590,7 +583,6 @@ void NewSyncResources(SOCKET Sock, const std::string& Mods, const std::vector<Mo
            UpdateModUsage(FName);
        }
        WaitForConfirm();
-        ++ModNo;
    }

    if (!Terminate) {
@@ -634,7 +626,8 @@ void SyncResources(SOCKET Sock) {
    Ret.clear();

    int Amount = 0, Pos = 0;
-    std::string PathToSaveTo, t;
+    std::filesystem::path PathToSaveTo;
+    std::string t;
    for (const std::string& name : FNames) {
        if (!name.empty()) {
            t += name.substr(name.find_last_of('/') + 1) + ";";
@@ -662,7 +655,7 @@ void SyncResources(SOCKET Sock) {
    for (auto FN = FNames.begin(), FS = FSizes.begin(); FN != FNames.end() && !Terminate; ++FN, ++FS) {
        auto pos = FN->find_last_of('/');
        if (pos != std::string::npos) {
-            PathToSaveTo = CachingDirectory + FN->substr(pos);
+            PathToSaveTo = CachingDirectory / std::filesystem::path(*FN).filename();
        } else {
            continue;
        }
@@ -672,21 +665,22 @@ void SyncResources(SOCKET Sock) {
            if (FS->find_first_not_of("0123456789") != std::string::npos)
                continue;
            if (fs::file_size(PathToSaveTo) == FileSize) {
-                UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + PathToSaveTo.substr(PathToSaveTo.find_last_of('/')));
+                UpdateUl(false, std::to_string(Pos) + "/" + std::to_string(Amount) + ": " + PathToSaveTo.filename().string());
                std::this_thread::sleep_for(std::chrono::milliseconds(50));
                try {
-                    if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                        fs::create_directories(GetGamePath() + "mods/multiplayer");
+                    if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
+                        fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
                    }
-                    auto modname = PathToSaveTo.substr(PathToSaveTo.find_last_of('/'));
+                    auto modname = PathToSaveTo.filename().string();
 #if defined(__linux__)
                    // Linux version of the game doesnt support uppercase letters in mod names
                    for (char& c : modname) {
                        c = ::tolower(c);
                    }
 #endif
-                    auto name = GetGamePath() + "mods/multiplayer" + modname;
-                    auto tmp_name = name + ".tmp";
+                    auto name = GetGamePath() / beammp_wide("mods/multiplayer") / Utils::ToWString(modname);
+                    auto tmp_name = name;
+                    tmp_name += L".tmp";
                    fs::copy_file(PathToSaveTo, tmp_name, fs::copy_options::overwrite_existing);
                    fs::rename(tmp_name, name);
                    UpdateModUsage(modname);
@@ -698,12 +692,12 @@ void SyncResources(SOCKET Sock) {
                WaitForConfirm();
                continue;
            } else
-                remove(PathToSaveTo.c_str());
+                fs::remove(PathToSaveTo.wstring());
        }
        CheckForDir();
-        std::string FName = PathToSaveTo.substr(PathToSaveTo.find_last_of('/'));
+        std::string FName = PathToSaveTo.filename().string();
        do {
-            debug("Loading file '" + FName + "' to '" + PathToSaveTo + "'");
+            debug("Loading file '" + FName + "' to '" + PathToSaveTo.string() + "'");
            TCPSend("f" + *FN, Sock);

            std::string Data = TCPRcv(Sock);
@@ -728,13 +722,13 @@ void SyncResources(SOCKET Sock) {
            }
            // 2. verify size
            if (std::filesystem::file_size(PathToSaveTo) != DownloadedFile.size()) {
-                error("Failed to write the entire file '" + PathToSaveTo + "' correctly (file size mismatch)");
+                error(beammp_wide("Failed to write the entire file '") + beammp_fs_string(PathToSaveTo) + beammp_wide("' correctly (file size mismatch)"));
                Terminate = true;
            }
        } while (fs::file_size(PathToSaveTo) != std::stoull(*FS) && !Terminate);
        if (!Terminate) {
-            if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                fs::create_directories(GetGamePath() + "mods/multiplayer");
+            if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
+                fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
            }

 // Linux version of the game doesnt support uppercase letters in mod names
@@ -744,7 +738,7 @@ void SyncResources(SOCKET Sock) {
            }
 #endif

-            fs::copy_file(PathToSaveTo, GetGamePath() + "mods/multiplayer" + FName, fs::copy_options::overwrite_existing);
+            fs::copy_file(PathToSaveTo, GetGamePath() / beammp_wide("mods/multiplayer") / Utils::ToWString(FName), fs::copy_options::overwrite_existing);
            UpdateModUsage(FN->substr(pos));
        }
        WaitForConfirm();
--- a/src/Network/VehicleData.cpp
+++ b/src/Network/VehicleData.cpp
@@ -93,6 +93,9 @@ void UDPClientMain(const std::string& IP, int Port) {
    ToServer->sin_port = htons(Port);
    inet_pton(AF_INET, IP.c_str(), &ToServer->sin_addr);
    UDPSock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (!magic.empty())
+        for (int i = 0; i < 10; i++)
+            UDPSend(magic);
    GameSend("P" + std::to_string(ClientID));
    TCPSend("H", TCPSock);
    UDPSend("p");
--- a/src/Network/VehicleEvent.cpp
+++ b/src/Network/VehicleEvent.cpp
@@ -81,7 +81,8 @@ std::string TCPRcv(SOCKET Sock) {
        UUl("Invalid Socket");
        return "";
    }
-    int32_t Header, Temp;
+    int32_t Header;
+    int Temp;
    std::vector<char> Data(sizeof(Header));
    Temp = recv(Sock, Data.data(), sizeof(Header), MSG_WAITALL);
    if (!CheckBytes(Temp)) {
--- a/src/Options.cpp
+++ b/src/Options.cpp
@@ -86,6 +86,12 @@ void InitOptions(int argc, const char *argv[], Options &options) {
            options.no_download = true;
            options.no_launch = true;
            options.no_update = true;
+        } else if (argument == "--user-path") {
+            if (i + 1 >= argc) {
+                error("You must specify a path after the `--user-path` argument");
+            }
+            options.user_path = argv[i + 1];
+            i++;
        } else if (argument == "--" || argument == "--game") {
            options.game_arguments = &argv[i + 1];
            options.game_arguments_length = argc - i - 1;
@@ -101,6 +107,7 @@ void InitOptions(int argc, const char *argv[], Options &options) {
                "\t--no-update          Skip applying launcher updates (you must update manually)\n"
                "\t--no-launch          Skip launching the game (you must launch the game manually)\n"
                "\t--dev                Developer mode, same as --verbose --no-download --no-launch --no-update\n"
+                "\t--user-path <path>   Path to BeamNG's User Path\n"
                "\t--game <args...>     Passes ALL following arguments to the game, see also `--`\n"
                << std::flush;
            exit(0);
--- a/src/Security/BeamNG.cpp
+++ b/src/Security/BeamNG.cpp
@@ -6,8 +6,9 @@


 #include <filesystem>
+#include "Utils.h"
 #if defined(_WIN32)
-#include <windows.h>
+#include <shlobj_core.h>
 #elif defined(__linux__)
 #include "vdf_parser.hpp"
 #include <pwd.h>
@@ -23,7 +24,7 @@
 #define MAX_VALUE_NAME 16383

 int TraceBack = 0;
-std::string GameDir;
+beammp_fs_string GameDir;

 void lowExit(int code) {
    TraceBack = 0;
@@ -33,7 +34,7 @@ void lowExit(int code) {
    exit(2);
 }

-std::string GetGameDir() {
+beammp_fs_string GetGameDir() {
 #if defined(_WIN32)
    return GameDir.substr(0, GameDir.find_last_of('\\'));
 #elif defined(__linux__)
@@ -44,8 +45,8 @@ std::string GetGameDir() {
 LONG OpenKey(HKEY root, const char* path, PHKEY hKey) {
    return RegOpenKeyEx(root, reinterpret_cast<LPCSTR>(path), 0, KEY_READ, hKey);
 }
-std::string QueryKey(HKEY hKey, int ID) {
-    TCHAR achKey[MAX_KEY_LENGTH]; // buffer for subkey name
+std::wstring QueryKey(HKEY hKey, int ID) {
+    wchar_t* achKey; // buffer for subkey name
    DWORD cbName; // size of name string
    TCHAR achClass[MAX_PATH] = TEXT(""); // buffer for class name
    DWORD cchClassName = MAX_PATH; // size of class string
@@ -60,7 +61,7 @@ std::string QueryKey(HKEY hKey, int ID) {

    DWORD i, retCode;

-    TCHAR achValue[MAX_VALUE_NAME];
+    wchar_t* achValue = new wchar_t[MAX_VALUE_NAME];
    DWORD cchValue = MAX_VALUE_NAME;

    retCode = RegQueryInfoKey(
@@ -82,9 +83,9 @@ std::string QueryKey(HKEY hKey, int ID) {
    if (cSubKeys) {
        for (i = 0; i < cSubKeys; i++) {
            cbName = MAX_KEY_LENGTH;
-            retCode = RegEnumKeyEx(hKey, i, achKey, &cbName, nullptr, nullptr, nullptr, &ftLastWriteTime);
+            retCode = RegEnumKeyExW(hKey, i, achKey, &cbName, nullptr, nullptr, nullptr, &ftLastWriteTime);
            if (retCode == ERROR_SUCCESS) {
-                if (strcmp(achKey, "Steam App 284160") == 0) {
+                if (wcscmp(achKey, L"Steam App 284160") == 0) {
                    return achKey;
                }
            }
@@ -94,36 +95,37 @@ std::string QueryKey(HKEY hKey, int ID) {
        for (i = 0, retCode = ERROR_SUCCESS; i < cValues; i++) {
            cchValue = MAX_VALUE_NAME;
            achValue[0] = '\0';
-            retCode = RegEnumValue(hKey, i, achValue, &cchValue, nullptr, nullptr, nullptr, nullptr);
+            retCode = RegEnumValueW(hKey, i, achValue, &cchValue, nullptr, nullptr, nullptr, nullptr);
            if (retCode == ERROR_SUCCESS) {
                DWORD lpData = cbMaxValueData;
                buffer[0] = '\0';
-                LONG dwRes = RegQueryValueEx(hKey, achValue, nullptr, nullptr, buffer, &lpData);
-                std::string data = (char*)(buffer);
-                std::string key = achValue;
+                LONG dwRes = RegQueryValueExW(hKey, achValue, nullptr, nullptr, buffer, &lpData);
+                std::wstring data = (wchar_t*)(buffer);
+                std::wstring key = achValue;
+

                switch (ID) {
                case 1:
-                    if (key == "SteamExe") {
-                        auto p = data.find_last_of("/\\");
+                    if (key == L"SteamExe") {
+                        auto p = data.find_last_of(L"/\\");
                        if (p != std::string::npos) {
                            return data.substr(0, p);
                        }
                    }
                    break;
                case 2:
-                    if (key == "Name" && data == "BeamNG.drive")
+                    if (key == L"Name" && data == L"BeamNG.drive")
                        return data;
                    break;
                case 3:
-                    if (key == "rootpath")
+                    if (key == L"rootpath")
                        return data;
                    break;
                case 4:
-                    if (key == "userpath_override")
+                    if (key == L"userpath_override")
                        return data;
                case 5:
-                    if (key == "Local AppData")
+                    if (key == L"Local AppData")
                        return data;
                default:
                    break;
@@ -131,8 +133,9 @@ std::string QueryKey(HKEY hKey, int ID) {
            }
        }
    }
+    delete[] achValue;
    delete[] buffer;
-    return "";
+    return L"";
 }
 #endif

@@ -159,24 +162,70 @@ void FileList(std::vector<std::string>& a, const std::string& Path) {
 }
 void LegitimacyCheck() {
 #if defined(_WIN32)
-    std::string Result;
-    std::string K3 = R"(Software\BeamNG\BeamNG.drive)";
-    HKEY hKey;
-    LONG dwRegOPenKey = OpenKey(HKEY_CURRENT_USER, K3.c_str(), &hKey);
-    if (dwRegOPenKey == ERROR_SUCCESS) {
-        Result = QueryKey(hKey, 3);
-        if (Result.empty()) {
-            debug("Failed to QUERY key HKEY_CURRENT_USER\\Software\\BeamNG\\BeamNG.drive");
-            lowExit(3);
-        }
-        GameDir = Result;
-    } else {
-        debug("Failed to OPEN key HKEY_CURRENT_USER\\Software\\BeamNG\\BeamNG.drive");
-        lowExit(4);
+    wchar_t* appDataPath = new wchar_t[MAX_PATH];
+    HRESULT result = SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, appDataPath);
+
+    if (!SUCCEEDED(result)) {
+        fatal("Cannot get Local Appdata directory");
    }
-    K3.clear();
-    Result.clear();
-    RegCloseKey(hKey);
+
+    auto BeamNGAppdataPath = std::filesystem::path(appDataPath) / "BeamNG";
+
+    if (const auto beamngIniPath = BeamNGAppdataPath / "BeamNG.Drive.ini"; exists(beamngIniPath)) {
+        if (std::ifstream beamngIni(beamngIniPath); beamngIni.is_open()) {
+            std::string contents((std::istreambuf_iterator(beamngIni)), std::istreambuf_iterator<char>());
+            beamngIni.close();
+
+            if (contents.size() >= 3 && (unsigned char)contents[0] == 0xEF && (unsigned char)contents[1] == 0xBB && (unsigned char)contents[2] == 0xBF) {
+                contents = contents.substr(3);
+            }
+
+            auto ini = Utils::ParseINI(contents);
+            if (ini.empty())
+                lowExit(3);
+            else
+                debug("Successfully parsed BeamNG.Drive.ini");
+
+            if (ini.contains("installPath")) {
+                std::wstring installPath = Utils::ToWString(std::get<std::string>(ini["installPath"]));
+                installPath.erase(0, installPath.find_first_not_of(L" \t"));
+
+                if (installPath = std::filesystem::path(Utils::ExpandEnvVars(installPath)); std::filesystem::exists(installPath)) {
+                    GameDir = installPath;
+                    debug(L"GameDir from BeamNG.Drive.ini: " + installPath);
+                } else {
+                    lowExit(4);
+                }
+            } else {
+                lowExit(5);
+            }
+        }
+    } else {
+        std::wstring Result;
+
+        std::string K3 = R"(Software\BeamNG\BeamNG.drive)";
+
+        HKEY hKey;
+
+        LONG dwRegOPenKey = OpenKey(HKEY_CURRENT_USER, K3.c_str(), &hKey);
+        if (dwRegOPenKey == ERROR_SUCCESS) {
+            Result = QueryKey(hKey, 3);
+            if (Result.empty()) {
+                debug("Failed to QUERY key HKEY_CURRENT_USER\\Software\\BeamNG\\BeamNG.drive");
+                lowExit(6);
+            }
+            GameDir = Result;
+            debug(L"GameDir from registry: " + Result);
+        } else {
+            debug("Failed to OPEN key HKEY_CURRENT_USER\\Software\\BeamNG\\BeamNG.drive");
+            lowExit(7);
+        }
+        K3.clear();
+        Result.clear();
+        RegCloseKey(hKey);
+    }
+
+    delete[] appDataPath;
 #elif defined(__linux__)
    struct passwd* pw = getpwuid(getuid());
    std::filesystem::path homeDir = pw->pw_dir;
@@ -184,6 +233,7 @@ void LegitimacyCheck() {
    // Right now only steam is supported
    std::vector<std::filesystem::path> steamappsCommonPaths = {
        ".steam/root/steamapps", // default
+        ".steam/steam/steamapps", // Legacy Steam installations
        ".var/app/com.valvesoftware.Steam/.steam/root/steamapps", // flatpak
        "snap/steam/common/.local/share/Steam/steamapps" // snap
    };
@@ -218,7 +268,7 @@ void LegitimacyCheck() {
    std::ifstream libraryFolders(libraryFoldersPath);
    auto root = tyti::vdf::read(libraryFolders);
    for (auto folderInfo : root.childs) {
-        if (std::filesystem::exists(folderInfo.second->attribs["path"] + "/steamapps/common/BeamNG.drive/integrity.json")){
+        if ((folderInfo.second->childs["apps"]->attribs).contains("284160") && std::filesystem::exists(folderInfo.second->attribs["path"] + "/steamapps/common/BeamNG.drive/integrity.json")){
            GameDir = folderInfo.second->attribs["path"] + "/steamapps/common/BeamNG.drive/";
            break;
        }
@@ -229,12 +279,9 @@ void LegitimacyCheck() {
    }
 #endif
 }
-std::string CheckVer(const std::string& dir) {
-#if defined(_WIN32)
-    std::string temp, Path = dir + "\\integrity.json";
-#elif defined(__linux__)
-    std::string temp, Path = dir + "/integrity.json";
-#endif
+std::string CheckVer(const std::filesystem::path& dir) {
+    std::string temp;
+    std::filesystem::path Path = dir / beammp_wide("integrity.json");
    std::ifstream f(Path.c_str(), std::ios::binary);
    int Size = int(std::filesystem::file_size(Path));
    std::string vec(Size, 0);
--- a/src/Startup.cpp
+++ b/src/Startup.cpp
@@ -4,7 +4,6 @@
 SPDX-License-Identifier: AGPL-3.0-or-later
 */

-
 #include "zip_file.h"
 #include <charconv>
 #include <cstring>
@@ -12,20 +11,23 @@
 #include <nlohmann/json.hpp>
 #include <string>
 #if defined(_WIN32)
-#include <windows.h>
 #elif defined(__linux__)
 #include <unistd.h>
-#endif
+#elif defined(__APPLE__)
+#include <libproc.h>
+#include <unistd.h>
+#endif // __APPLE__
 #include "Http.h"
 #include "Logger.h"
 #include "Network/network.hpp"
+#include "Options.h"
 #include "Security/Init.h"
 #include "Startup.h"
+#include "Utils.h"
 #include "hashpp.h"
 #include <filesystem>
 #include <fstream>
 #include <thread>
-#include "Options.h"

 extern int TraceBack;
 int ProxyPort = 0;
@@ -72,49 +74,77 @@ Version::Version(const std::array<uint8_t, 3>& v)
    : Version(v[0], v[1], v[2]) {
 }

-std::string GetEN() {
+beammp_fs_string GetEN() {
 #if defined(_WIN32)
-    return "BeamMP-Launcher.exe";
+    return L"BeamMP-Launcher.exe";
 #elif defined(__linux__)
    return "BeamMP-Launcher";
 #endif
 }

 std::string GetVer() {
-    return "2.4";
+    return "2.8";
 }
 std::string GetPatch() {
    return ".0";
 }

-std::string GetEP(const char* P) {
-    static std::string Ret = [&]() {
-        std::string path(P);
-        return path.substr(0, path.find_last_of("\\/") + 1);
+beammp_fs_string GetEP(const beammp_fs_char* P) {
+    static beammp_fs_string Ret = [&]() {
+        beammp_fs_string path(P);
+        return path.substr(0, path.find_last_of(beammp_wide("\\/")) + 1);
    }();
    return Ret;
 }
+
+fs::path GetBP(const beammp_fs_char* P) {
+    fs::path fspath = {};
+#if defined(_WIN32)
+    beammp_fs_char path[256];
+    GetModuleFileNameW(nullptr, path, sizeof(path));
+    fspath = path;
+#elif defined(__linux__)
+    fspath = fs::canonical("/proc/self/exe");
+#elif defined(__APPLE__)
+    pid_t pid = getpid();
+    char path[PROC_PIDPATHINFO_MAXSIZE];
+    // While this is fine for a raw executable,
+    // an application bundle is read-only and these files
+    // should instead be placed in Application Support.
+    proc_pidpath(pid, path, sizeof(path));
+    fspath = std::string(path);
+#else
+    fspath = beammp_fs_string(P);
+#endif
+    fspath = fs::weakly_canonical(fspath.string() + "/..");
+#if defined(_WIN32)
+    return fspath.wstring();
+#else
+    return fspath.string();
+#endif
+}
+
 #if defined(_WIN32)
 void ReLaunch() {
-    std::string Arg;
+    std::wstring Arg;
    for (int c = 2; c <= options.argc; c++) {
-        Arg += options.argv[c - 1];
-        Arg += " ";
+        Arg += Utils::ToWString(options.argv[c - 1]);
+        Arg += L" ";
    }
    info("Relaunch!");
    system("cls");
-    ShellExecute(nullptr, "runas", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
+    ShellExecuteW(nullptr, L"runas", (GetBP() / GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
    ShowWindow(GetConsoleWindow(), 0);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    exit(1);
 }
 void URelaunch() {
-    std::string Arg;
+    std::wstring Arg;
    for (int c = 2; c <= options.argc; c++) {
-        Arg += options.argv[c - 1];
-        Arg += " ";
+        Arg += Utils::ToWString(options.argv[c - 1]);
+        Arg += L" ";
    }
-    ShellExecute(nullptr, "open", (GetEP() + GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
+    ShellExecuteW(nullptr, L"open", (GetBP() / GetEN()).c_str(), Arg.c_str(), nullptr, SW_SHOWNORMAL);
    ShowWindow(GetConsoleWindow(), 0);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    exit(1);
@@ -128,7 +158,7 @@ void ReLaunch() {
    }
    info("Relaunch!");
    system("clear");
-    int ret = execv(options.executable_name.c_str(), const_cast<char**>(options.argv));
+    int ret = execv((GetBP() / GetEN()).c_str(), const_cast<char**>(options.argv));
    if (ret < 0) {
        error(std::string("execv() failed with: ") + strerror(errno) + ". Failed to relaunch");
        exit(1);
@@ -137,7 +167,7 @@ void ReLaunch() {
    exit(1);
 }
 void URelaunch() {
-    int ret = execv(options.executable_name.c_str(), const_cast<char**>(options.argv));
+    int ret = execv((GetBP() / GetEN()).c_str(), const_cast<char**>(options.argv));
    if (ret < 0) {
        error(std::string("execv() failed with: ") + strerror(errno) + ". Failed to relaunch");
        exit(1);
@@ -149,29 +179,175 @@ void URelaunch() {

 void CheckName() {
 #if defined(_WIN32)
-    std::string DN = GetEN(), CDir = options.executable_name, FN = CDir.substr(CDir.find_last_of('\\') + 1);
+    std::wstring DN = GetEN(), CDir = Utils::ToWString(options.executable_name), FN = CDir.substr(CDir.find_last_of('\\') + 1);
 #elif defined(__linux__)
    std::string DN = GetEN(), CDir = options.executable_name, FN = CDir.substr(CDir.find_last_of('/') + 1);
 #endif
    if (FN != DN) {
        if (fs::exists(DN))
-            remove(DN.c_str());
+            fs::remove(DN.c_str());
        if (fs::exists(DN))
            ReLaunch();
-        std::rename(FN.c_str(), DN.c_str());
+        fs::rename(FN.c_str(), DN.c_str());
        URelaunch();
    }
 }

+#if defined(_WIN32)
+#include <wincrypt.h>
+#include <wintrust.h>
+#include <softpub.h>
+#include <iostream>
+
+#pragma comment(lib, "wintrust.lib")
+#pragma comment(lib, "crypt32.lib")
+
+bool CheckThumbprint(std::filesystem::path filepath)
+{
+    HCERTSTORE hStore = NULL;
+    HCRYPTMSG hMsg = NULL;
+
+    if (!CryptQueryObject(
+        CERT_QUERY_OBJECT_FILE,
+        filepath.wstring().c_str(),
+        CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED,
+        CERT_QUERY_FORMAT_FLAG_BINARY,
+        0,
+        NULL, NULL, NULL,
+        &hStore,
+        &hMsg,
+        NULL))
+    {
+        return false;
+    }
+
+    DWORD dwSignerInfo = 0;
+    if (!CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &dwSignerInfo) || dwSignerInfo == 0)
+        return false;
+
+    PCMSG_SIGNER_INFO pSignerInfo = (PCMSG_SIGNER_INFO)LocalAlloc(LPTR, dwSignerInfo);
+    if (!CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM, 0, pSignerInfo, &dwSignerInfo))
+    {
+        LocalFree(pSignerInfo);
+        return false;
+    }
+
+    CERT_INFO certInfo = {};
+    certInfo.Issuer = pSignerInfo->Issuer;
+    certInfo.SerialNumber = pSignerInfo->SerialNumber;
+
+    PCCERT_CONTEXT pCertContext = CertFindCertificateInStore(
+        hStore,
+        X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
+        0,
+        CERT_FIND_SUBJECT_CERT,
+        &certInfo,
+        NULL);
+
+    if (!pCertContext)
+    {
+        LocalFree(pSignerInfo);
+        return false;
+    }
+
+    BYTE hash[64];
+    DWORD hashSize = sizeof(hash);
+
+    bool match = false;
+    if (CertGetCertificateContextProperty(pCertContext, CERT_SHA256_HASH_PROP_ID, hash, &hashSize))
+    {
+        std::string pubKeyData(
+            reinterpret_cast<const char*>(pCertContext->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData),
+            pCertContext->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData
+        );
+
+        std::string pubKeyHash = Utils::GetSha256HashReallyFast(pubKeyData, L"PubKey");
+        debug("pub key hash: " + pubKeyHash);
+
+        std::string fileThumbprint;
+        for (DWORD i = 0; i < hashSize; i++)
+        {
+            char buf[3];
+            sprintf_s(buf, "%02x", hash[i]);
+            fileThumbprint += buf;
+        }
+
+        debug("File thumbprint: " +fileThumbprint);
+        debug(filepath);
+
+        if (fileThumbprint == "937f055b713de69416926ed4651d65219a0a0e77d7a78c1932c007e14326da33" && pubKeyHash == "2afad4a5773b0ac449f48350ce0d09c372be0d5bcbaa6d01332ce000baffde99"){
+            match = true;
+        }
+    }
+
+    CertFreeCertificateContext(pCertContext);
+    CertCloseStore(hStore, 0);
+    LocalFree(pSignerInfo);
+
+    return match;
+}
+#include <windows.h>
+#include <wintrust.h>
+#include <Softpub.h>
+#include <filesystem>
+#include <string>
+
+#pragma comment(lib, "wintrust")
+
+bool VerifySignature(const std::filesystem::path& filePath)
+{
+    std::wstring path = filePath.wstring();
+
+    WINTRUST_FILE_INFO fileInfo = {};
+    fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);
+    fileInfo.pcwszFilePath = path.c_str();
+    fileInfo.hFile = NULL;
+    fileInfo.pgKnownSubject = NULL;
+
+    WINTRUST_DATA winTrustData = {};
+    winTrustData.cbStruct = sizeof(WINTRUST_DATA);
+    winTrustData.dwUIChoice = WTD_UI_NONE;
+    winTrustData.dwUnionChoice = WTD_CHOICE_FILE;
+    winTrustData.pFile = &fileInfo;
+
+    winTrustData.dwStateAction = WTD_STATEACTION_VERIFY;
+
+    GUID policyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
+
+    LONG status = WinVerifyTrust(
+        NULL,
+        &policyGUID,
+        &winTrustData
+    );
+
+    debug(filePath);
+    debug("Signature check code: " + std::to_string(status));
+
+    winTrustData.dwStateAction = WTD_STATEACTION_CLOSE;
+    WinVerifyTrust(NULL, &policyGUID, &winTrustData);
+
+    return (status == CERT_E_UNTRUSTEDROOT);
+}
+#endif
+
 void CheckForUpdates(const std::string& CV) {
    std::string LatestHash = HTTP::Get("https://backend.beammp.com/sha/launcher?branch=" + Branch + "&pk=" + PublicKey);
    std::string LatestVersion = HTTP::Get(
        "https://backend.beammp.com/version/launcher?branch=" + Branch + "&pk=" + PublicKey);

-    transform(LatestHash.begin(), LatestHash.end(), LatestHash.begin(), ::tolower);
-    std::string EP(GetEP() + GetEN()), Back(GetEP() + "BeamMP-Launcher.back");
+    std::regex sha256_pattern(R"(^[a-fA-F0-9]{64}$)");
+    std::smatch match;

-    std::string FileHash = hashpp::get::getFileHash(hashpp::ALGORITHMS::SHA2_256, EP);
+    if (LatestHash.length() != 64 || !std::regex_match(LatestHash, match, sha256_pattern)) {
+        error("Invalid hash from backend, skipping update check.");
+        debug("Launcher hash in question: " + LatestHash);
+        return;
+    }
+
+    transform(LatestHash.begin(), LatestHash.end(), LatestHash.begin(), ::tolower);
+    beammp_fs_string BP(GetBP() / GetEN()), Back(GetBP() / beammp_wide("BeamMP-Launcher.back"));
+
+    std::string FileHash = Utils::GetSha256HashReallyFastFile(BP);

    if (FileHash != LatestHash && IsOutdated(Version(VersionStrToInts(GetVer() + GetPatch())), Version(VersionStrToInts(LatestVersion)))) {
        if (!options.no_update) {
@@ -179,15 +355,44 @@ void CheckForUpdates(const std::string& CV) {
 #if defined(__linux__)
            error("Auto update is NOT implemented for the Linux version. Please update manually ASAP as updates contain security patches.");
 #else
-            fs::remove(Back);
-            fs::rename(EP, Back);
            info("Downloading Launcher update " + LatestHash);
-            HTTP::Download(
-                "https://backend.beammp.com/builds/launcher?download=true"
-                "&pk="
-                    + PublicKey + "&branch=" + Branch,
-                EP);
-            URelaunch();
+            std::wstring DownloadLocation = GetBP() / (beammp_wide("new_") + GetEN());
+            if (HTTP::Download(
+                    "https://backend.beammp.com/builds/launcher?download=true"
+                    "&pk="
+                        + PublicKey + "&branch=" + Branch,
+                    DownloadLocation, LatestHash)) {
+                if (!VerifySignature(DownloadLocation) || !CheckThumbprint(DownloadLocation)) {
+                    std::error_code ec;
+                    fs::remove(DownloadLocation, ec);
+                    if (ec) {
+                        error("Failed to remove broken launcher update");
+                    }
+                    throw std::runtime_error("The authenticity of the updated launcher could not be verified, it was corrupted or tampered with.");
+                }
+
+                info("Update signature is valid");
+
+                std::error_code ec;
+                fs::remove(Back, ec);
+                if (ec == std::errc::permission_denied) {
+                    error("Failed to remove old backup file: " + ec.message() + ". Using alternative name.");
+                    fs::rename(BP, Back + beammp_wide(".") + Utils::ToWString(FileHash.substr(0, 8)));
+                } else {
+                    fs::rename(BP, Back);
+                }
+                fs::rename(GetBP() / (beammp_wide("new_") + GetEN()), BP);
+                URelaunch();
+            } else {
+                if (fs::exists(DownloadLocation)) {
+                    std::error_code error_code;
+                    fs::remove(DownloadLocation, error_code);
+                    if (error_code) {
+                        error("Failed to remove broken launcher update");
+                    }
+                }
+                throw std::runtime_error("Failed to download the launcher update! Please try manually updating it, https://docs.beammp.com/FAQ/Update-launcher/");
+            }
 #endif
        } else {
            warn("Launcher update was found, but not updating because --no-update or --dev was specified.");
@@ -197,7 +402,6 @@ void CheckForUpdates(const std::string& CV) {
    TraceBack++;
 }

-
 #ifdef _WIN32
 void LinuxPatch() {
    HKEY hKey = nullptr;
@@ -231,6 +435,8 @@ void LinuxPatch() {

 void InitLauncher() {
    SetConsoleTitleA(("BeamMP Launcher v" + std::string(GetVer()) + GetPatch()).c_str());
+    SetConsoleOutputCP(CP_UTF8);
+    _setmode(_fileno(stdout), _O_U8TEXT);
    debug("Launcher Version : " + GetVer() + GetPatch());
    CheckName();
    LinuxPatch();
@@ -247,11 +453,11 @@ void InitLauncher() {
 }
 #endif

-size_t DirCount(const std::filesystem::path& path) {
-    return (size_t)std::distance(std::filesystem::directory_iterator { path }, std::filesystem::directory_iterator {});
+size_t DirCount(const fs::path& path) {
+    return (size_t)std::distance(fs::directory_iterator { path }, fs::directory_iterator {});
 }

-void CheckMP(const std::string& Path) {
+void CheckMP(const beammp_fs_string& Path) {
    if (!fs::exists(Path))
        return;
    size_t c = DirCount(fs::path(Path));
@@ -271,7 +477,7 @@ void CheckMP(const std::string& Path) {
 }

 void EnableMP() {
-    std::string File(GetGamePath() + "mods/db.json");
+    beammp_fs_string File(GetGamePath() / beammp_wide("mods/db.json"));
    if (!fs::exists(File))
        return;
    auto Size = fs::file_size(File);
@@ -294,18 +500,18 @@ void EnableMP() {
                ofs << d.dump();
                ofs.close();
            } else {
-                error("Failed to write " + File);
+                error(beammp_wide("Failed to write ") + File);
            }
        }
    }
 }

-void PreGame(const std::string& GamePath) {
+void PreGame(const beammp_fs_string& GamePath) {
    std::string GameVer = CheckVer(GamePath);
    info("Game Version : " + GameVer);

-    CheckMP(GetGamePath() + "mods/multiplayer");
-    info("Game user path: " + GetGamePath());
+    CheckMP(GetGamePath() / beammp_wide("mods/multiplayer"));
+    info(beammp_wide("Game user path: ") + beammp_fs_string(GetGamePath()));

    if (!options.no_download) {
        std::string LatestHash = HTTP::Get("https://backend.beammp.com/sha/mod?branch=" + Branch + "&pk=" + PublicKey);
@@ -314,34 +520,43 @@ void PreGame(const std::string& GamePath) {
                             [](auto const& c) -> bool { return !std::isalnum(c); }),
            LatestHash.end());

+        std::regex sha256_pattern(R"(^[a-fA-F0-9]{64}$)");
+        std::smatch match;
+
+        if (LatestHash.length() != 64 || !std::regex_match(LatestHash, match, sha256_pattern)) {
+            error("Invalid hash from backend, skipping mod update check.");
+            debug("Mod hash in question: " + LatestHash);
+            return;
+        }
+
        try {
-            if (!fs::exists(GetGamePath() + "mods/multiplayer")) {
-                fs::create_directories(GetGamePath() + "mods/multiplayer");
+            if (!fs::exists(GetGamePath() / beammp_wide("mods/multiplayer"))) {
+                fs::create_directories(GetGamePath() / beammp_wide("mods/multiplayer"));
            }
            EnableMP();
        } catch (std::exception& e) {
            fatal(e.what());
        }
 #if defined(_WIN32)
-        std::string ZipPath(GetGamePath() + R"(mods\multiplayer\BeamMP.zip)");
+        std::wstring ZipPath(GetGamePath() / LR"(mods\multiplayer\BeamMP.zip)");
 #elif defined(__linux__)
        // Linux version of the game cant handle mods with uppercase names
-        std::string ZipPath(GetGamePath() + R"(mods/multiplayer/beammp.zip)");
+        std::string ZipPath(GetGamePath() / R"(mods/multiplayer/beammp.zip)");
 #endif

-        std::string FileHash = hashpp::get::getFileHash(hashpp::ALGORITHMS::SHA2_256, ZipPath);
+        std::string FileHash = fs::exists(ZipPath) ? Utils::GetSha256HashReallyFastFile(ZipPath) : "";

        if (FileHash != LatestHash) {
            info("Downloading BeamMP Update " + LatestHash);
            HTTP::Download("https://backend.beammp.com/builds/client?download=true"
                           "&pk="
                    + PublicKey + "&branch=" + Branch,
-                ZipPath);
+                ZipPath, LatestHash);
        }

-        std::string Target(GetGamePath() + "mods/unpacked/beammp");
+        beammp_fs_string Target(GetGamePath() / beammp_wide("mods/unpacked/beammp"));

-        if (fs::is_directory(Target)) {
+        if (fs::is_directory(Target) && !fs::is_directory(Target + beammp_wide("/.git"))) {
            fs::remove_all(Target);
        }
    }
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -9,6 +9,7 @@
 #include "Network/network.hpp"
 #include "Security/Init.h"
 #include "Startup.h"
+#include "Utils.h"
 #include <curl/curl.h>
 #include <iostream>
 #include <thread>
@@ -37,7 +38,7 @@ int main(int argc, const char** argv) try {

    curl_global_init(CURL_GLOBAL_ALL);

-    GetEP(argv[0]);
+    GetEP(Utils::ToWString(std::string(argv[0])).c_str());

    InitLog();
    ConfigInit();