Choose your operating system, then check your processor architecture. Use a GUI client on desktop and mobile; use the standalone core on servers, routers, and command-line systems.
Operating system
Choose an installer that matches your operating system.Processor architecture
Don’t guess between x64 and ARM64 based on the name alone.Configuration source
Install the client and import a subscription as separate steps.Each download button links to a specific file. Choose a maintained client where possible; archived builds are for legacy compatibility and configuration migration only.
These GUI installers are mainly x64. Check Settings → System → About to confirm your device runs 64-bit Windows. On ARM devices, an x64 installer is not a native ARM64 build; whether it runs depends on the system’s app compatibility support.
A good starting point for your first GUI client. After installing, add a subscription or local configuration, then choose a proxy group and routing mode. Starting the app and activating a configuration are separate steps; the tray icon alone doesn’t confirm that routing is active.
A desktop client based on mihomo, suited to users who manage multiple configurations, rules, and routing settings. If you enable TUN or service mode, follow the client’s permission prompts. For system proxy use, you don’t need to turn on every advanced option.
A cross-platform GUI client. Choose the installer for a guided setup, or download the ZIP and manage the extracted app yourself. These are two distribution formats, not two subscription formats; configuration compatibility still depends on the protocols and fields supported by the core.
A good fit if you prefer a standalone desktop interface for managing configurations. When switching clients, first import a known-working configuration and check its proxy groups, rule mode, and listening ports. Migrate overrides afterward; don’t treat the old client’s interface settings as core configuration.
Kept as an archived option for legacy configurations and existing setups; not recommended for new devices. The older core may not support newer protocols and configuration fields. Before migrating, export your local YAML, subscription URL, and custom rules, then import them into a maintained client.
| Item | What to check |
|---|---|
| System and architecture | Most downloads here are x64 installers. Check the selected app’s release notes and installer prompts for minimum system requirements; “64-bit” alone doesn’t tell you whether your Windows version is supported. |
| Installer format | Run the EXE installer and follow the setup wizard. Extract ZIP files fully before launching the app; don’t run it from the archive preview. |
| Routing permissions | System proxy and TUN work differently. Service components and virtual network adapters may require administrator approval. Enable only what your setup needs. |
Check the chip information under Apple menu → About This Mac. Intel and Apple Silicon require different architectures. The downloads below distinguish native ARM64 files from x64 files currently linked in the download list; the entry label doesn’t determine the file’s actual architecture.
Separate macOS downloads are available for each architecture. Choose ARM64 for Apple Silicon or x64 for Intel. Open the disk image and follow the prompts to install the app, then launch the client and import your configuration. The installer does not create a subscription for you.
A good fit for users who need subscription management and desktop rule controls. Both entries in the current download list return the same x64 disk image. Apple Silicon users should confirm the app supports the required translation environment; the download entry does not indicate a native ARM build.
Enjoy a similar workflow across platforms, but configure network permissions and startup items separately on each system. The current macOS download list provides an AMD64 file, which is equivalent to x64. After installation, check that the configuration loads before enabling launch at login.
An archived client retained for users who rely on its menu bar workflow or existing setup. Both entries currently return an x86_64 file. Since development has stopped, compatibility with newer systems and protocols is not guaranteed. For new installations, consider one of the maintained clients above.
| Item | What to check |
|---|---|
| Chip architecture | For Apple Silicon, choose native ARM64 where available; Intel Macs need x64. Some entries currently share an x64 file. Check the app’s actual compatibility requirements. |
| macOS version | Minimum macOS versions vary by client. If you’re using an older release, check the app’s installation prompts; an archived build is not a long-term compatibility solution. |
| Network permissions | System proxy, helper services, and network extensions may each request separate permissions. Approve only the items associated with the client you’re using, and keep any system error messages. |
Most recent phones use ARM64, but a 64-bit processor doesn’t guarantee that Android is running a 64-bit app environment. Check your device information first. If you’re unsure and the client offers a universal build, choose that. Installation and the first VPN connection trigger separate system prompts.
For devices running a 64-bit ARM Android environment. Install the APK using Android’s package installer. On the first connection, approve the VPN request, then check the active configuration in the client. The VPN icon only means a connection is established; it doesn’t guarantee that every proxy in your subscription is working.
A mobile client for managing configurations, suited to users with an existing Clash-format subscription. ARM64 is for 64-bit environments, ARM for older 32-bit environments, and universal builds support multiple architectures. After importing, select a configuration and set up app-specific routing if needed.
A good fit if you want a similar configuration workflow on desktop and mobile. Choose a build that matches your Android app environment. If connections drop when the screen turns off, check battery optimization and background activity settings; there’s no need to change every system setting on first launch.
An Android client with its own configuration format. Don’t assume Clash YAML can be imported as-is. Before using it, check whether your subscription provider supports a format compatible with Surfboard, and verify that its proxy protocols, groups, and rule syntax are supported.
| Item | What to check |
|---|---|
| Architecture and Android version | arm64-v8a is 64-bit ARM; armeabi-v7a is 32-bit ARM. Check the installer and app documentation for the minimum Android version and supported ABIs. |
| Installation permissions | Open the APK from your browser or file manager and allow installation from that source when prompted. For updates, the signing key and existing app must also match. |
| Connections and background activity | Network routing usually uses Android’s VPN interface. Check for conflicts if another VPN app is running; background restrictions can interrupt long-running connections. |
Install Clash Plus from the App Store. Check the store listing for supported iOS versions, devices, and in-app features. After installation, prepare an existing subscription or compatible configuration, then add and enable it in the client.
Open the App Store listing for the app description, device compatibility, and release notes. When you connect for the first time, iOS may ask to add a VPN configuration. Confirm the app name and approve the request, then check the active configuration and proxy rules in the client.
Installing the client does not include a subscription service. When moving a desktop configuration to your phone, check its format, protocols, and mobile support. A matching file extension alone doesn’t guarantee compatibility.
| Item | What to check |
|---|---|
| Supported devices | Check the listing’s Compatibility section for supported device models and minimum iOS version. Don’t try to install files intended for other platforms on iOS. |
| Installation and updates | Install and update the app through the App Store. Refer to the store listing for the app description and feature changes. |
| Configuration and permissions | Prepare a subscription you’re authorized to use, then follow the client’s prompts to add it. VPN authorization and subscription import are separate steps; verify the connection afterward. |
The GUI clients below are for AMD64. Debian- and Ubuntu-based systems generally use DEB packages; Fedora-based systems generally use RPM. Check your distribution and desktop runtime dependencies as well. On headless servers, switch to the core downloads instead; you don’t need to install a desktop environment just to run a proxy.
For desktop users who want GUI subscription management. Choose the package format for your distribution and let the system package manager handle dependencies. Before enabling TUN, check permissions, routing, and DNS settings. Avoid running multiple clients that take over the same network interface.
This section provides a GUI installer for Debian-based systems. If the package manager reports missing dependencies, check the package names and your distribution version before proceeding; don’t force the installation past errors. This AMD64 file won’t run natively on ARM devices.
| Item | What to check |
|---|---|
| Processor architecture | These are x86_64 / AMD64 GUI packages. Run uname -m to check your architecture; aarch64 and armv7l do not match these AMD64 files. |
| Package format | DEB and RPM use different package management systems. Even within the same format, not every package works across all distribution versions; check the installer’s dependency requirements. |
| How it runs | GUI clients require a compatible desktop environment. On command-line-only devices, use the standalone core and manage its configuration directory, service permissions, and startup method yourself. |
The standalone core is for users who manage processes themselves on servers and routers. It parses configurations and handles connections, but doesn’t provide the subscription management interface found in desktop clients. Most desktop and mobile users should choose a GUI client above.
| System | Architecture and use | Download |
|---|---|---|
| Windows | AMD64 · 64-bit x86 hosts | Download AMD64 · ZIP |
| Windows | ARM64 · 64-bit ARM hosts | Download ARM64 · ZIP |
| macOS | AMD64 · Intel | Download Intel · GZ |
| macOS | ARM64 · Apple Silicon | Download Apple Silicon · GZ |
| Linux | AMD64 · Debian package | Download AMD64 · DEB |
| Linux | AMD64 · Standalone executable | Download AMD64 · GZ |
| Linux | ARM64 · 64-bit ARM | Download ARM64 · GZ |
| Linux | ARMv7 · 32-bit ARM | Download ARMv7 · GZ |
| Linux | MIPS · softfloat | Download MIPS softfloat · GZ |
| Item | What to check |
|---|---|
| System compatibility | Architecture is only the first requirement. Older operating systems, specific CPU instruction sets, firmware ABIs, and endianness differences can also prevent a file from running. |
| Files and permissions | Extract the file and launch it using your system’s usual method. On Unix-like systems, check executable permissions and access to the configuration directory. Don’t make the entire configuration directory writable by everyone. |
| Network mode | Standard proxy listeners and TUN have different permission requirements. Before enabling TUN, confirm that your device supports the required interface and check existing routes and DNS services. |
| Service management | For always-on operation, configure the service, log location, and restart policy yourself. Don’t expose an unauthenticated control interface to the public internet. |
See Protocol and core reference for protocol support and legacy configuration compatibility. First verify that the core can parse the configuration, then set up service startup and remote management.
The installer deploys the app; subscriptions and traffic routing still need to be set up in the client.
Prepare a subscription link you’re authorized to use or a local YAML file, then add it from the client’s Subscription, Configuration, or Profile page. Select and activate the imported configuration, then check for parsing errors. A proxy provider file isn’t the same as a complete configuration: a file containing only proxy entries may also need proxy groups, rules, and other top-level settings.
For your first test, run one client at a time. Check the rule mode, selected proxy group, and listening ports before enabling the system proxy. Use TUN only if you need to route apps that don’t follow the system proxy. A working browser connection doesn’t mean terminal apps are using the same proxy settings.
Follow the steps to import a subscription and test your connection →Before updating the app, back up local configuration and custom overrides. Keep remote subscription content separate from settings saved by the client. Remote updates may overwrite files you edit directly; for long-term custom rules, use the client’s supported override or merge options.
When migrating from an older client, don’t copy its entire data directory over the new app. Import your subscription and local YAML first, then confirm that parsing and connections work. Migrate DNS, TUN, scripts, and rules one at a time. Core support varies by field; if an error occurs, save the original message and identify the specific configuration item involved.
Troubleshoot installation, updates, and startup issues →Check your system, architecture, and installer format first; troubleshoot configuration and connectivity afterward.
Desktop and mobile users should start with a GUI client. Clients provide subscription import, profile activation, proxy group selection, and logs. The mihomo core is for server and router users who manage configuration, startup parameters, and services themselves. Downloading the core archive does not install a GUI.
x64 and AMD64 usually refer to the same 64-bit x86 architecture, regardless of processor brand. ARM64 is for 64-bit ARM devices; armeabi-v7a is for older 32-bit ARM Android environments. Universal builds may include multiple architectures and are usually larger. Check your system information first, then compare the button label with the actual filename. On this page, different macOS entries may link to the same x64 file; that does not make it a native ARM build.
The installer contains only the client application. Before use, prepare a subscription link you’re authorized to use or a local configuration file. Import and activate the configuration, then enable the system proxy or TUN if needed. If no configuration is loaded, the application running does not mean it is routing your traffic.
Check the operating system, processor architecture, installer format, and the app’s minimum system requirements. Windows GUI installers here are mainly x64; Linux DEB and RPM packages must match your distribution. If you have an x64 macOS file on Apple Silicon, confirm compatibility with the app’s translation environment. Keep the system error message; disabling all security checks is not a general fix.
Back up your subscription URL, local YAML files, overrides, and custom rules first. Install the new client and import the configuration separately. Archived clients are no longer maintained, so don’t assume they support newer protocols or configuration fields. Confirm that the new client can parse the configuration before enabling traffic routing. Don’t overwrite the entire old configuration directory.
Check your browser’s download history to confirm the download finished and the file extension matches the button label. Delete any incomplete temporary file and try again; if needed, choose another folder and check available disk space. If the download succeeds but installation fails, note your system version, architecture, filename, and error message, then check the help center’s installation and startup troubleshooting guides. Never include subscription credentials in public feedback.