Address remaining macOS recipe review comments

* chore: extend prebuilts support for MacOS NE by clang 21+

* chore: trigger prebuilts on workflow file changes

.github/workflows/deploy.yml

@@ -22,6 +22,7 @@ jobs:
             recipes:
               - 'recipes/**'
               - 'conanfile.py'
+              - '.github/workflows/deploy.yml'
 
   Bake-Prebuilts-Linux:
     runs-on: ubuntu-latest
@@ -539,13 +540,17 @@ jobs:
 # ------------------------------------------------------
 
   Bake-Prebuilts-MacOS-NE:
-    runs-on: macos-latest
     needs: Detect-Changes
     if: needs.Detect-Changes.outputs.recipes_changed == 'true'
 
     strategy:
       matrix:
-        xcode-version: [16.2, 16.4]
+        xcode-version: [16.2, 16.4, 26.4]
+        include:
+          - xcode-version: 26.4
+            os: macos-26
+
+    runs-on: ${{ matrix.os || 'macos-latest' }}
 
     steps:
     - uses: actions/checkout@v4

CMakeLists.txt

@@ -4,7 +4,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(PROJECT AmneziaVPN)
-set(AMNEZIAVPN_VERSION 4.8.9.0)
+set(AMNEZIAVPN_VERSION 4.9.0.0)
 
 set(QT_CREATOR_SKIP_PACKAGE_MANAGER_SETUP ON CACHE BOOL "" FORCE)
 set(CMAKE_PROJECT_TOP_LEVEL_INCLUDES

client/CMakeLists.txt

@@ -240,6 +240,10 @@ install(SCRIPT ${QT_DEPLOY_SCRIPT}
 
 if (APPLE AND NOT IOS AND NOT MACOS_NE)
     list(APPEND OVPN_SCRIPTS "${CMAKE_SOURCE_DIR}/deploy/data/macos/update-resolv-conf.sh")
+    set_target_properties(${PROJECT} PROPERTIES
+        XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "NO"
+        XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO"
+    )
 endif()
 if (LINUX AND NOT ANDROID)
     list(APPEND OVPN_SCRIPTS "${CMAKE_SOURCE_DIR}/deploy/data/linux/update-resolv-conf.sh")

client/core/controllers/api/subscriptionController.cpp

@@ -460,6 +460,7 @@ ErrorCode SubscriptionController::updateServiceFromGateway(const QString &server
     
     if (apiV2->nameOverriddenByUser) {
         newApiV2->name = apiV2->name;
+        newApiV2->displayName = apiV2->displayName;
         newApiV2->nameOverriddenByUser = true;
     }
 

client/core/controllers/serversController.cpp

@@ -44,6 +44,7 @@ bool ServersController::renameServer(const QString &serverId, const QString &nam
         auto cfg = m_serversRepository->selfHostedAdminConfig(serverId);
         if (!cfg.has_value()) return false;
         cfg->description = name;
+        cfg->displayName = name;
         m_serversRepository->editServer(serverId, cfg->toJson(), kind);
         return true;
     }
@@ -51,6 +52,7 @@ bool ServersController::renameServer(const QString &serverId, const QString &nam
         auto cfg = m_serversRepository->selfHostedUserConfig(serverId);
         if (!cfg.has_value()) return false;
         cfg->description = name;
+        cfg->displayName = name;
         m_serversRepository->editServer(serverId, cfg->toJson(), kind);
         return true;
     }
@@ -58,6 +60,7 @@ bool ServersController::renameServer(const QString &serverId, const QString &nam
         auto cfg = m_serversRepository->nativeConfig(serverId);
         if (!cfg.has_value()) return false;
         cfg->description = name;
+        cfg->displayName = name;
         m_serversRepository->editServer(serverId, cfg->toJson(), kind);
         return true;
     }
@@ -67,6 +70,7 @@ bool ServersController::renameServer(const QString &serverId, const QString &nam
         auto cfg = m_serversRepository->apiV2Config(serverId);
         if (!cfg.has_value()) return false;
         cfg->name = name;
+        cfg->displayName = name;
         cfg->nameOverriddenByUser = true;
         m_serversRepository->editServer(serverId, cfg->toJson(), kind);
         return true;

client/core/controllers/updateController.cpp

@@ -23,7 +23,7 @@ namespace
 #if defined(Q_OS_WINDOWS)
     const QLatin1String kInstallerRemoteFileNamePattern("AmneziaVPN_%1_windows_x64.exe");
     const QString kInstallerLocalPath = QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/AmneziaVPN_installer.exe";
-#elif defined(Q_OS_MACOS)
+#elif defined(Q_OS_MACOS) && !defined(MACOS_NE)
     const QLatin1String kInstallerRemoteFileNamePattern("AmneziaVPN_%1_macos_x64.pkg");
     const QString kInstallerLocalPath = QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/AmneziaVPN.pkg";
 #elif defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)
@@ -184,7 +184,7 @@ void UpdateController::setupNetworkErrorHandling(QNetworkReply* reply, const QSt
         logger.error() << QString("Network error occurred while fetching %1: %2 %3")
                           .arg(operation, reply->errorString(), QString::number(error));
     });
-    
+
     QObject::connect(reply, &QNetworkReply::sslErrors, [operation](const QList<QSslError> &errors) {
         QStringList errorStrings;
         for (const QSslError &err : errors) {
@@ -196,21 +196,13 @@ void UpdateController::setupNetworkErrorHandling(QNetworkReply* reply, const QSt
 
 void UpdateController::handleNetworkError(QNetworkReply* reply, const QString& operation)
 {
-    if (reply->error() == QNetworkReply::NetworkError::OperationCanceledError
-        || reply->error() == QNetworkReply::NetworkError::TimeoutError) {
-        logger.error() << errorString(ErrorCode::ApiConfigTimeoutError);
-    } else {
-        QString err = reply->errorString();
-        logger.error() << "Network error code:" << QString::number(static_cast<int>(reply->error()));
-        logger.error() << "Error message:" << err;
-        logger.error() << "HTTP status:" << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-        logger.error() << errorString(ErrorCode::ApiConfigDownloadError);
-    }
+    logger.error() << "Network error code:" << QString::number(static_cast<int>(reply->error()));
+    logger.error() << "HTTP status:" << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 }
 
 QString UpdateController::composeDownloadUrl() const
 {
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS) && !defined(MACOS_NE)
     const QString fileName = QString(kInstallerRemoteFileNamePattern).arg(m_version);
     return m_baseUrl + "/" + fileName;
 #else
@@ -220,7 +212,7 @@ QString UpdateController::composeDownloadUrl() const
 
 void UpdateController::runInstaller()
 {
-#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
+#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS) && !defined(MACOS_NE)
     if (m_downloadUrl.isEmpty()) {
         logger.error() << "Download URL is empty";
         return;
@@ -252,7 +244,7 @@ void UpdateController::runInstaller()
 
     #if defined(Q_OS_WINDOWS)
             runWindowsInstaller(kInstallerLocalPath);
-    #elif defined(Q_OS_MACOS)
+    #elif defined(Q_OS_MACOS) && !defined(MACOS_NE)
             runMacInstaller(kInstallerLocalPath);
     #elif defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)
             runLinuxInstaller(kInstallerLocalPath);
@@ -292,7 +284,7 @@ int UpdateController::runWindowsInstaller(const QString &installerPath)
 }
 #endif
 
-#if defined(Q_OS_MACOS)
+#if defined(Q_OS_MACOS) && !defined(MACOS_NE)
 int UpdateController::runMacInstaller(const QString &installerPath)
 {
     // Create temporary directory for extraction

client/main.cpp

@@ -1,13 +1,12 @@
 #include <QDebug>
 #include <QTimer>
+#include <libssh/libssh.h>
 
 #include "amneziaApplication.h"
 #include "core/utils/osSignalHandler.h"
 #include "core/utils/migrations.h"
 #include "version.h"
 
-#include <QTimer>
-
 #ifdef Q_OS_WIN
     #include "Windows.h"
 #endif
@@ -47,6 +46,11 @@ int main(int argc, char *argv[])
     AmneziaApplication app(argc, argv);
     OsSignalHandler::setup();
 
+    ssh_init();
+    QObject::connect(&app, &QCoreApplication::aboutToQuit, []() {
+        ssh_finalize();
+    });
+
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS) && !defined(MACOS_NE)
     if (isAnotherInstanceRunning()) {
         QTimer::singleShot(1000, &app, [&]() { app.quit(); });

cmake/conan_provider.cmake

@@ -84,6 +84,10 @@ function(detect_os os os_api_level os_sdk os_subsystem os_version)
                     set(_os_sdk "watch${apple_platform_suffix}")
                 endif()
             endif()
+            # Macos does not support os.sdk
+            if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+                set(_os_sdk "")
+            endif()
             if(DEFINED os_sdk)
                 message(STATUS "CMake-Conan: cmake_osx_sysroot=${CMAKE_OSX_SYSROOT}")
                 set(${os_sdk} ${_os_sdk} PARENT_SCOPE)

cmake/platform_settings.cmake

@@ -12,7 +12,7 @@ if(APPLE)
         set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64" CACHE STRING "" FORCE)
     else()
         set(CMAKE_OSX_DEPLOYMENT_TARGET "13.0" CACHE STRING "" FORCE)
-        set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "" FORCE)
+        set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64" CACHE STRING "" FORCE)
     endif()
 endif()
 

recipes/amnezia-xray-bindings/conanfile.py

@@ -1,16 +1,27 @@
 from conan import ConanFile
-from conan.tools.files import get, copy, collect_libs, chdir, rename
+from conan.tools.files import get, copy, collect_libs, chdir, rename, mkdir
 from conan.tools.layout import basic_layout
 from conan.errors import ConanInvalidConfiguration
 from conan.tools.gnu import Autotools, AutotoolsToolchain
+from conan.tools.apple import XCRun, is_apple_os
+from conan.tools.apple.apple import _to_apple_arch
 
 import os
+import shlex
+from pathlib import Path
+
 
 class AmneziaXrayBindings(ConanFile):
     name = "amnezia-xray-bindings"
     version = "1.1.0"
     settings = "os", "arch", "compiler"
 
+    _arch_map = {
+        "x86": "386",
+        "x86_64": "amd64",
+        "armv8": "arm64"
+    }
+
     @property
     def _goos(self):
         return {
@@ -19,15 +30,15 @@ class AmneziaXrayBindings(ConanFile):
             "Macos": "darwin",
             "Windows": "windows"
         }.get(str(self.settings.os))
-    
+
     @property
-    def _goarch(self):
-        return {
-            "x86": "386",
-            "x86_64": "amd64",
-            "armv8": "arm64"
-        }.get(str(self.settings.arch))
-    
+    def _archs(self):
+        return str(self.settings.arch).split("|")
+
+    @property
+    def _is_multiarch(self):
+        return len(self._archs) > 1
+
     @property
     def _is_windows(self):
         return str(self.settings.os).startswith("Windows")
@@ -54,34 +65,72 @@ class AmneziaXrayBindings(ConanFile):
             self.tool_requires("mingw-builds/15.1.0")
 
     def validate(self):
-        if not self._goos or not self._goarch:
+        if not self._goos or not all(arch in self._arch_map for arch in self._archs):
             raise ConanInvalidConfiguration(
                 f"{self.name} v{self.version} does not support {self.settings.os} {self.settings.arch}"
             )
 
+        if self._is_multiarch and not is_apple_os(self):
+            raise ConanInvalidConfiguration(
+                f"{self.name} v{self.version} does not support multiarch builds"
+            )
+
     def source(self):
         get(self, "https://github.com/amnezia-vpn/amnezia-xray-bindings/archive/v1.1.0.zip",
             sha256="6ea768ec7002cedd422a39aea17704b888acaf794432aa5937cfc92fb6d80eb5", strip_root=True)
 
     def generate(self):
         tc = AutotoolsToolchain(self)
+        tc.apple_arch_flag = None
         tc.make_args = [
             "LIB_ARC=libamnezia_xray.a"
         ]
         env = tc.environment()
-        env.define("ARCH", self._goarch)
-        env.define("GOARCH", self._goarch)
+        env.define("GOPATH", os.path.join(self.build_folder, "gopath"))
+        env.define("GOMODCACHE", os.path.join(self.build_folder, "gopath", "pkg", "mod"))
+        env.define("GOCACHE", os.path.join(self.build_folder, "gocache"))
         env.define("GOOS", self._goos)
-        env.define("CGO_LDFLAGS", tc.ldflags)
-        env.define("CGO_CFLAGS", tc.cflags)
         if self._is_windows:
             env.define("OS", "windows")
+        self._ldflags = tc.ldflags
+        self._cflags = tc.cflags
         tc.generate(env)
 
     def build(self):
         with chdir(self, self.source_folder):
-            autotools = Autotools(self)
-            autotools.make()
+            for arch in self._archs:
+                cflags = list(self._cflags)
+                ldflags = list(self._ldflags)
+                if is_apple_os(self):
+                    cflags.append(f"-arch {_to_apple_arch(arch)}")
+                    ldflags.append(f"-arch {_to_apple_arch(arch)}")
+
+                autotools = Autotools(self)
+                autotools.make(args=[
+                    f"BUILD_DIR={os.path.join('build', arch)}",
+                    f"ARCH={self._arch_map.get(arch)}",
+                    f"CGO_CFLAGS={shlex.quote(' '.join(cflags))}",
+                    f"CGO_LDFLAGS={shlex.quote(' '.join(ldflags))}"
+                ])
+
+            if is_apple_os(self) and self._is_multiarch:
+                merged_dir = os.path.join(self.source_folder, "merged")
+                archives = sorted(
+                    str(path) for path in Path(self.source_folder).glob("build/*/*.a")
+                )
+                if not archives:
+                    raise ConanInvalidConfiguration(
+                        f"{self.name} v{self.version} did not produce archives for {self.settings.arch}"
+                    )
+                output = os.path.join(merged_dir, Path(archives[0]).name)
+
+                mkdir(self, merged_dir)
+                lipo = XCRun(self).find('lipo')
+                self.run("{} -create -output {} {}".format(
+                    shlex.quote(lipo),
+                    shlex.quote(output),
+                    " ".join(shlex.quote(archive) for archive in archives)
+                ))
 
     def _rename_header(self):
         if not self._is_windows:
@@ -99,10 +148,12 @@ class AmneziaXrayBindings(ConanFile):
                 os.rename(src, dst)
 
     def package(self):
-        copy(self, "*.h", src=self.build_folder, dst=os.path.join(self.package_folder, "include"))
-        copy(self, "*.a", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-        copy(self, "*.lib", src=self.build_folder, dst=os.path.join(self.package_folder, "lib"))
-        copy(self, "*.dll", src=self.build_folder, dst=os.path.join(self.package_folder, "bin"))
+        header_src = os.path.join(self.source_folder, "build", self._archs[0])
+        lib_src = os.path.join(self.source_folder, "merged") if self._is_multiarch else header_src
+        copy(self, "*.h", src=header_src, dst=os.path.join(self.package_folder, "include"), keep_path=False)
+        copy(self, "*.a", src=lib_src, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.lib", src=lib_src, dst=os.path.join(self.package_folder, "lib"), keep_path=False)
+        copy(self, "*.dll", src=lib_src, dst=os.path.join(self.package_folder, "bin"), keep_path=False)
         self._rename_header()
 
     def package_info(self):

recipes/awg-go/conanfile.py

@@ -1,16 +1,20 @@
 from conan import ConanFile
 from conan.errors import ConanInvalidConfiguration
 from conan.tools.layout import basic_layout
-from conan.tools.files import get, copy
+from conan.tools.files import get, copy, chdir
+from conan.tools.apple import XCRun
 from conan.tools.gnu import Autotools, AutotoolsToolchain
 
 import os
+import shlex
+
 
 class AwgGo(ConanFile):
     name = "awg-go"
     version = "0.2.16"
     package_type = "application"
     settings = "os", "arch"
+    _binary_name = "amneziawg-go"
 
     @property
     def _goos(self):
@@ -21,12 +25,29 @@ class AwgGo(ConanFile):
         }.get(str(self.settings.os))
 
     @property
-    def _goarch(self):
+    def _arch_map(self):
         return {
             "x86": "386",
             "x86_64": "amd64",
             "armv8": "arm64"
-        }.get(str(self.settings.arch))
+        }
+
+    @property
+    def _archs(self):
+        return str(self.settings.arch).split("|")
+
+    @property
+    def _goarch(self):
+        goarchs = [self._arch_map.get(arch) for arch in self._archs]
+        return goarchs[0] if len(goarchs) == 1 else None
+
+    @property
+    def _goarchs(self):
+        return [self._arch_map.get(arch) for arch in self._archs]
+
+    @property
+    def _is_universal_macos(self):
+        return str(self.settings.os) == "Macos" and len(self._archs) > 1
 
     def layout(self):
         basic_layout(self, build_folder=".")
@@ -35,7 +56,7 @@ class AwgGo(ConanFile):
         self.tool_requires("go/1.26.0")
 
     def validate(self):
-        if not self._goos or not self._goarch:
+        if not self._goos or not all(self._goarchs) or (len(self._archs) > 1 and not self._is_universal_macos):
             raise ConanInvalidConfiguration(
                 f"{self.name} v{self.version} does not support {self.settings.os} {self.settings.arch}"
             )
@@ -48,20 +69,48 @@ class AwgGo(ConanFile):
     def generate(self):
         tc = AutotoolsToolchain(self)
         env = tc.environment()
+        env.define("GOPATH", os.path.join(self.build_folder, "gopath"))
+        env.define("GOMODCACHE", os.path.join(self.build_folder, "gopath", "pkg", "mod"))
+        env.define("GOCACHE", os.path.join(self.build_folder, "gocache"))
+        env.define("GOTELEMETRY", "off")
         env.define("GOOS", self._goos)
-        env.define("GOARCH", self._goarch)
         env.define("CGO_LDFLAGS", tc.ldflags)
         env.define("CGO_CFLAGS", tc.cflags)
         tc.generate(env)
 
     def build(self):
-        at = Autotools(self)
-        at.make()
+        outputs = []
+        with chdir(self, self.source_folder):
+            for goarch in self._goarchs:
+                arch_destdir = os.path.join(self.build_folder, f"build-{goarch}")
+                at = Autotools(self)
+                at.make("clean")
+                at.make("install", args=[
+                    f"DESTDIR={shlex.quote(arch_destdir)}",
+                    "BINDIR=",
+                    f"GOARCH={goarch}",
+                ])
+                output_path = os.path.join(arch_destdir, self._binary_name)
+                arch_output_path = os.path.join(self.build_folder, f"{self._binary_name}-{goarch}")
+                os.rename(output_path, arch_output_path)
+                outputs.append(arch_output_path)
+
+        output = os.path.join(self.build_folder, self._binary_name)
+        if self._is_universal_macos:
+            lipo = XCRun(self).find("lipo")
+            self.run("{} -create {} -output {}".format(
+                shlex.quote(lipo),
+                " ".join(shlex.quote(output) for output in outputs),
+                shlex.quote(output)
+            ))
+            return
+
+        os.rename(outputs[0], output)
 
     def package(self):
-        copy(self, "amneziawg-go", src=self.build_folder, dst=self.package_folder)
+        copy(self, self._binary_name, src=self.build_folder, dst=self.package_folder)
 
     def package_info(self):
         self.cpp_info.exe = True
-        self.cpp_info.location = os.path.join(self.package_folder, "amneziawg-go")
+        self.cpp_info.location = os.path.join(self.package_folder, self._binary_name)
         self.cpp_info.set_property("cmake_target_name", "amnezia::awg-go")

recipes/openvpn/conandata.yml

@@ -0,0 +1,4 @@
+patches:
+  "2.7.0":
+    - patch_file: "patches/0001-carefully-handle-CMAKE_GENERATOR_PLATFORM.patch"
+    - patch_file: "patches/0002-explicitly-pass-unicode-everywhere.patch"

recipes/openvpn/conanfile.py

@@ -1,5 +1,5 @@
 from conan import ConanFile
-from conan.tools.files import get, copy, replace_in_file
+from conan.tools.files import get, copy, replace_in_file, apply_conandata_patches, export_conandata_patches
 from conan.tools.gnu import Autotools, AutotoolsToolchain, AutotoolsDeps, PkgConfigDeps
 from conan.tools.layout import basic_layout
 from conan.tools.cmake import cmake_layout, CMakeToolchain, CMake, CMakeDeps
@@ -17,6 +17,7 @@ class Openvpn(ConanFile):
         return str(self.settings.os).startswith("Windows")
 
     def export_sources(self):
+        export_conandata_patches(self)
         copy(self, "*applink.c", src=self.recipe_folder, dst=self.export_sources_folder)
 
     def layout(self):
@@ -84,6 +85,7 @@ class Openvpn(ConanFile):
             deps.generate()
 
     def build(self):
+        apply_conandata_patches(self)
         if self._is_windows:
             cmake = CMake(self)
             cmake.configure()

recipes/openvpn/patches/0001-carefully-handle-CMAKE_GENERATOR_PLATFORM.patch

@@ -0,0 +1,25 @@
+From 693bee38daaec5962ea3f0939c71e869f202c08a Mon Sep 17 00:00:00 2001
+From: Yaroslav Gurov <ygurov@proton.me>
+Date: Mon, 18 May 2026 16:58:00 +0200
+Subject: [PATCH] carefully handle CMAKE_GENERATOR_PLATFORM
+
+---
+ CMakeLists.txt | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 198c98ff..7341db70 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -108,7 +108,7 @@ if (MSVC)
+         "$<$<CONFIG:Release>:/OPT:REF>"
+         "$<$<CONFIG:Release>:/OPT:ICF>"
+         )
+-    if (${CMAKE_GENERATOR_PLATFORM} STREQUAL "x64" OR ${CMAKE_GENERATOR_PLATFORM} STREQUAL "x86")
++    if ("${CMAKE_GENERATOR_PLATFORM}" STREQUAL "x64" OR "${CMAKE_GENERATOR_PLATFORM}" STREQUAL "x86")
+         add_link_options("$<$<CONFIG:Release>:/CETCOMPAT>")
+     endif()
+ else ()
+-- 
+2.46.0.windows.1
+

recipes/openvpn/patches/0002-explicitly-pass-unicode-everywhere.patch

@@ -0,0 +1,50 @@
+From 9a42a0350abaa1a329ad56e40b1900ef78183323 Mon Sep 17 00:00:00 2001
+From: Yaroslav Gurov <ygurov@proton.me>
+Date: Mon, 18 May 2026 18:05:09 +0200
+Subject: [PATCH] explicitly pass unicode everywhere
+
+---
+ src/openvpnmsica/CMakeLists.txt | 1 +
+ src/openvpnserv/CMakeLists.txt  | 1 +
+ src/tapctl/CMakeLists.txt       | 1 +
+ 3 files changed, 3 insertions(+)
+
+diff --git a/src/openvpnmsica/CMakeLists.txt b/src/openvpnmsica/CMakeLists.txt
+index 9126b80f..23f979d6 100644
+--- a/src/openvpnmsica/CMakeLists.txt
++++ b/src/openvpnmsica/CMakeLists.txt
+@@ -22,6 +22,7 @@ target_sources(openvpnmsica PRIVATE
+     openvpnmsica_resources.rc
+     )
+ target_compile_options(openvpnmsica PRIVATE
++    -DUNICODE
+     -D_UNICODE
+     -UNTDDI_VERSION
+     -D_WIN32_WINNT=_WIN32_WINNT_VISTA
+diff --git a/src/openvpnserv/CMakeLists.txt b/src/openvpnserv/CMakeLists.txt
+index fc153822..b3a0cff1 100644
+--- a/src/openvpnserv/CMakeLists.txt
++++ b/src/openvpnserv/CMakeLists.txt
+@@ -19,6 +19,7 @@ function(add_common_options target)
+         ${MC_GEN_DIR}
+     )
+     target_compile_options(${target} PRIVATE
++        -DUNICODE
+         -D_UNICODE
+         -UNTDDI_VERSION
+         -D_WIN32_WINNT=_WIN32_WINNT_VISTA
+diff --git a/src/tapctl/CMakeLists.txt b/src/tapctl/CMakeLists.txt
+index 97702c01..81da46b8 100644
+--- a/src/tapctl/CMakeLists.txt
++++ b/src/tapctl/CMakeLists.txt
+@@ -19,6 +19,7 @@ target_sources(tapctl PRIVATE
+     tapctl_resources.rc
+     )
+ target_compile_options(tapctl PRIVATE
++    -DUNICODE
+     -D_UNICODE
+     -UNTDDI_VERSION
+     -D_WIN32_WINNT=_WIN32_WINNT_VISTA
+-- 
+2.46.0.windows.1
+

recipes/tun2socks/conanfile.py

@@ -2,16 +2,24 @@ from conan import ConanFile
 from conan.tools.layout import basic_layout
 from conan.tools.files import get, copy, chdir
 from conan.errors import ConanInvalidConfiguration
+from conan.tools.apple import XCRun
 from conan.tools.gnu import Autotools, AutotoolsToolchain
-from conan.tools.env import Environment
 
 import os
+import shlex
+
 
 class Tun2Socks(ConanFile):
     name = "tun2socks"
     version = "2.6.0"
     package_type = "application"
     settings = "os", "arch"
+    _binary_name = "tun2socks"
+    _arch_map = {
+        "x86": "386",
+        "x86_64": "amd64",
+        "armv8": "arm64"
+    }
 
     @property
     def _goos(self):
@@ -22,17 +30,21 @@ class Tun2Socks(ConanFile):
         }.get(str(self.settings.os))
 
     @property
-    def _goarch(self):
-        return {
-            "x86": "386",
-            "x86_64": "amd64",
-            "armv8": "arm64"
-        }.get(str(self.settings.arch))
-    
+    def _archs(self):
+        return str(self.settings.arch).split("|")
+
+    @property
+    def _goarchs(self):
+        return [self._arch_map.get(arch) for arch in self._archs]
+
+    @property
+    def _is_universal_macos(self):
+        return str(self.settings.os) == "Macos" and len(self._archs) > 1
+
     @property
     def _is_windows(self):
         return str(self.settings.get_safe("os")).startswith("Windows")
-    
+
     @property
     def _ext(self):
         return ".exe" if self._is_windows else ""
@@ -41,7 +53,7 @@ class Tun2Socks(ConanFile):
         basic_layout(self)
 
     def validate(self):
-        if not self._goos or not self._goarch:
+        if not self._goos or not all(self._goarchs) or (len(self._archs) > 1 and not self._is_universal_macos):
             raise ConanInvalidConfiguration(
                 f"{self.name} v{self.version} does not support {self.settings.os} {self.settings.arch}"
             )
@@ -66,23 +78,46 @@ class Tun2Socks(ConanFile):
     def generate(self):
         tc = AutotoolsToolchain(self)
         env = tc.environment()
+        env.define("GOPATH", os.path.join(self.build_folder, "gopath"))
+        env.define("GOMODCACHE", os.path.join(self.build_folder, "gopath", "pkg", "mod"))
+        env.define("GOCACHE", os.path.join(self.build_folder, "gocache"))
+        env.define("GOTELEMETRY", "off")
         env.define("LDFLAGS", "")
         env.define("CGO_LDFLAGS", tc.ldflags)
         env.define("CGO_CFLAGS", tc.cflags)
         env.define("GOOS", self._goos)
-        env.define("GOARCH", self._goarch)
         tc.generate(env)
 
     def build(self):
+        outputs = []
         with chdir(self, self.source_folder):
-            at = Autotools(self)
-            at.make("tun2socks")
+            for goarch in self._goarchs:
+                target = f"{self._goos}-{goarch}"
+                at = Autotools(self)
+                at.make(target)
+                output_ext = ".exe" if self._goos == "windows" else ""
+                output_path = os.path.join(self.source_folder, "build", f"{self._binary_name}-{target}{output_ext}")
+                arch_output_path = os.path.join(self.build_folder, f"{self._binary_name}-{goarch}")
+                os.rename(output_path, arch_output_path)
+                outputs.append(arch_output_path)
+
+        output = os.path.join(self.build_folder, self._binary_name)
+        if self._is_universal_macos:
+            lipo = XCRun(self).find("lipo")
+            self.run("{} -create {} -output {}".format(
+                shlex.quote(lipo),
+                " ".join(shlex.quote(output) for output in outputs),
+                shlex.quote(output)
+            ))
+            return
+
+        os.rename(outputs[0], output)
 
     def package(self):
-        copy(self, "tun2socks", src=self.build_folder, dst=self.package_folder)
+        copy(self, self._binary_name, src=self.build_folder, dst=self.package_folder)
         if self._is_windows:
             with chdir(self, self.package_folder):
-                os.rename(src="tun2socks", dst="tun2socks.exe")
+                os.rename(src=self._binary_name, dst=f"{self._binary_name}.exe")
 
     def package_info(self):
         self.cpp_info.exe = True