Primary question: Does a Tauri-based GUI with an automated Mihomo core fetch beat the Clash client you already use?
RepoDaily adoption score
RepoDaily rates this as 88/100 (strong) for adoption: evidence, installation path, production risk, differentiation, license clarity, and AI/agent fit are scored from the article sources and adoption notes.
5 source(s) across 3 source category/categories, plus a RepoDaily-specific evidence module when available.
6 workflow step(s), 5 next-action step(s), and 4 command/install signal(s) were detected.
Trending momentum is +195 stars, with maintenance/release/issue signals counted when present.
Risk is marked medium, with 5 security note(s) and 4 explicit skip condition(s).
3 opportunity lens item(s), 4 alternative(s), and 4 type-specific section(s) support differentiation.
License source or license wording is present.
2 AI/agent-related signal(s) were detected in the article text and metadata.
Project overview
Clash Verge Rev is a desktop client for proxy configuration, described by its maintainers as a modern GUI client based on Tauri that runs on Windows, macOS, and Linux. On August 31, 2026 it ranked #17 on GitHub trending with 195 stars in the measurement window. Although GitHub lists TypeScript as the primary language, the project is a deliberate hybrid: package.json declares React 19.2.8, MUI 9, and a set of Tauri 2.x plugins on the JavaScript side, while Cargo.toml defines an eight-member Rust workspace headed by the src-tauri app crate.
The central design decision is the split between GUI and engine. Running `pnpm run prebuild` executes scripts/prebuild.mjs, which downloads the Mihomo core and service binaries; adding `--force` re-downloads and overwrites them. The repository therefore never bundles the proxy engine, and every developer build starts from the same scripted fetch. The Rust side then talks to the core through tauri-plugin-mihomo-api, a dependency pinned directly to the project's own fork branch `refactor-use-reqwest-ipc` instead of a versioned registry release. That single line in package.json is the most important supply-chain fact in the repo.
Feature depth is visible in the workspace crate names: clash-verge-media-unlock, clash-verge-limiter, clash-verge-signal, clash-verge-logging, clash-verge-draft, clash-verge-i18n, and tauri-plugin-clash-verge-sysinfo. On the frontend, profile editing runs inside Monaco with monaco-yaml and meta-json-schema, so subscription YAML gets schema-aware editing inside the app, while js-yaml and serde_yaml_ng handle parsing on the JavaScript and Rust sides respectively.
Governance is stricter than most desktop apps. Version 2.5.3 is declared in package.json under license GPL-3.0-only, matching the full GPLv3 text in the LICENSE file. The release profile is tuned for optimized binaries (codegen-units = 1, thin LTO, opt-level 3), and a workspace-wide clippy configuration denies `panic`, `cognitive_complexity`, `await_holding_lock`, and dozens of other lint categories. Signed commits are required before pull requests can be merged.
Why it is trending now
- 195 stars in the August 31, 2026 window at trending rank #17, showing persistent demand for cross-platform desktop proxy GUIs.
- Both halves of the stack are current: Cargo.toml pins tauri 2.11.5 while the frontend uses React 19.2.8 and @tauri-apps/api 2.11.1.
- Release handling is scripted end to end - package.json lists release-version.mjs, publish-version.mjs, and fix-alpha_version.mjs alongside version 2.5.3.
- Windows-specific ergonomics: dedicated `portable` and `portable-fixed-webview2` scripts target users who need portable builds with a fixed WebView2 runtime.
Problem it solves
- Editing Clash/Mihomo YAML by hand across three operating systems with no schema feedback; the app answers with Monaco plus monaco-yaml and meta-json-schema.
- Keeping GUI and core versions in sync; `pnpm run prebuild --force` turns a core refresh into a one-command step instead of a manual download hunt.
- Windows integration complexity; windows-sys is pulled in with WinSock, Security_Authorization, Threading, JobObjects, and Storage_FileSystem features, and the deelevate crate handles dropping elevated rights after service setup.
- Translation upkeep across many locales; a dedicated clash-verge-i18n crate plus `i18n:check` and `i18n:format` scripts (node scripts/cleanup-unused-i18n.mjs) keep locale keys from drifting.
How it works
- `pnpm run prebuild` runs scripts/prebuild.mjs to fetch the Mihomo core and service binaries; the `--force` flag overwrites existing copies.
- The src-tauri Rust backend manages the core process; reqwest 0.13.4 (configured with rustls, json, cookies, gzip, and form features) and tokio 1.53.1 handle networking and the async runtime.
- The React 19 frontend calls the backend through @tauri-apps/api 2.11.1 and official plugins: dialog, fs, http, shell, clipboard-manager, and updater.
- tauri-plugin-mihomo-api bridges the GUI to Mihomo's control interface; the dependency is pinned to the clash-verge-rev fork branch `refactor-use-reqwest-ipc`.
- Profiles are edited in a Monaco editor with YAML schema support; react-hook-form, swr, and dnd-kit drive the settings interface around it.
- tauri-plugin-updater 2.10.1 together with scripts/updater.mjs handles app update delivery.
Architecture read: one repo, eight crates, two toolchains
The Cargo workspace (resolver 2) contains src-tauri plus crates/clash-verge-draft, crates/clash-verge-media-unlock, crates/clash-verge-logging, crates/clash-verge-signal, crates/tauri-plugin-clash-verge-sysinfo, crates/clash-verge-i18n, and crates/clash-verge-limiter. The crate names map closely to product surface: media unlock detection, traffic limiting, logging, signals, and system information.
The release profile sets panic to unwind, codegen-units to 1, thin LTO, opt-level 3, and keeps debug info (debug = 1, strip = none). A separate fast-release profile inherits from release but drops to opt-level 0, disables LTO, and uses 64 codegen units - that profile is what the `pnpm build:fast` script selects via `tauri build -- --profile fast-release`.
Windows-only dependencies are isolated in Cargo.toml: deelevate 0.2.0 and windows-sys 0.61.2 with features for Win32_Foundation, Networking_WinSock, Security, Security_Authorization, Storage_FileSystem, System_Threading, and System_JobObjects. Other notable backend deps include parking_lot with hardware-lock-elision, flexi_logger, socket2, and compact_str.
Try-it path: from clone to running dev build
- Prerequisites: install Rust and Node.js (the CONTRIBUTING guide links to Tauri's official prerequisites), run `corepack enable`, then `pnpm install`.
- Windows: use the MSVC toolchain via `rustup target add x86_64-pc-windows-msvc` and `rustup set default-host x86_64-pc-windows-msvc`, and install the GNU patch tool.
- Windows ARM additionally requires LLVM including clang, because the `ring` crate depends on clang at build time.
- Ubuntu only: `sudo apt-get install -y libxslt1.1 libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf`.
- `pnpm run prebuild` fetches the Mihomo core and service binaries (`--force` re-downloads), then run `pnpm dev`, `pnpm dev:diff` if an instance is already running, or `pnpm dev:tauri` for Tauri dev mode.
- Build variants: `pnpm build` (standard), `pnpm build:fast` (fast-release profile), `pnpm portable` (Windows portable build), `pnpm clean` to reset.
Command surface: what package.json actually exposes
- Dev entry points: dev, dev:service, dev:sidecar, dev:diff, dev:trace, and dev:tauri (`tauri dev -f tauri-dev` with RUST_BACKTRACE=full).
- Builds: `build` runs tauri build with NODE_OPTIONS max-old-space-size 4096; `build:fast` appends the fast-release profile.
- Quality gates: `lint` runs eslint with --max-warnings=0 against src, `format` uses Biome, `typecheck` runs tsc --noEmit, `test` runs vitest, and `test:dev-control` runs node --test over scripts/dev-control.test.mjs and scripts/service-release.test.mjs.
- Housekeeping: knip checks unused code, while i18n:check, i18n:format, and i18n:types maintain locale keys; Rust side quality is `cargo clippy-all` and `cargo fmt` per CONTRIBUTING.
Maintenance risk: strict by design
The workspace clippy configuration denies panic, unimplemented, cognitive_complexity, future_not_send, await_holding_lock, redundant_clone, correctness as a group, and many more; dbg_macro, expect_used, and todo are warnings. That is a high bar for outside contributors, and it concentrates change review on maintainers who know the lint policy.
Process friction is intentional: CONTRIBUTING requires signed commits, a fork-and-branch pull request model, and both `cargo clippy-all` and `pnpm lint` before committing. Custom release scripts (fix-alpha_version.mjs, release-version.mjs, publish-version.mjs) mean contributors must learn project-specific automation instead of plain tauri CLI commands.
The fork-pinned dependency tauri-plugin-mihomo-api (github:clash-verge-rev/tauri-plugin-mihomo#refactor-use-reqwest-ipc) means core IPC changes land on a branch name, not a tagged version. Anyone building long-term on this client should track that branch's commits.
Who should pay attention?
Good fit if
- Desktop users on Windows, macOS, or Linux who manage Mihomo/Clash subscriptions and want schema-assisted YAML editing inside the client.
- Windows ARM users and contributors - the LLVM/clang requirement for the ring crate is explicitly documented in CONTRIBUTING.
- Windows users who need portable builds; `pnpm portable` and `portable-fixed-webview2` are first-class scripts.
- Developers happy to work across Rust and TypeScript, since `cargo clippy-all` and `pnpm lint` both gate contributions.
Skip for now if
- Mobile-only users; the project targets desktop operating systems exclusively.
- Anyone unwilling to run binaries fetched at build time by scripts/prebuild.mjs without reviewing the download URLs.
- Organizations whose policy bars GPL-3.0-only code when redistribution of modified builds is on the table.
- Environments that require all dependencies to come from versioned registry releases; the core IPC plugin is a fork pinned by branch.
Risks and cautions
A GPL-3.0-only desktop client whose build fetches Mihomo core binaries via script and whose core IPC plugin is pinned to a fork branch rather than a tagged release.
- License is GPL-3.0-only; distributing modified builds triggers copyleft obligations.
- scripts/prebuild.mjs downloads core and service binaries during setup, so restricted networks need the URLs reviewed first.
- tauri-plugin-mihomo-api is referenced by branch name on the project's own fork, not a version number.
- Repository metadata lists no homepage or topics, so all documentation lives inside the repo files themselves.
- The LICENSE file is the complete GNU GPL v3 text and package.json declares GPL-3.0-only; the two agree.
- Backend HTTP uses reqwest configured with rustls (plus json, cookies, gzip, form features) rather than default TLS bindings.
- Workspace lints deny `panic` and `unimplemented` in the Rust backend, reducing abrupt aborts in the proxy control path.
- CONTRIBUTING requires signed commits for merged changes, giving verifiable authorship on the mainline.
- Custom updater scripts (updater.mjs, updater-fixed-webview2.mjs) and portable.mjs deserve a source review before enabling auto-updates in sensitive setups.
Alternatives to compare
| Approach | When to use | Trade-off |
|---|---|---|
Mihomo (Meta core) | You want the proxy engine alone with no GUI - run it as a service and edit YAML by hand. | Free, open source |
v2rayN | You need a Windows-first multi-protocol client that goes beyond Clash-format profiles. | Free, open source |
FlClash | You want a Flutter-based Clash GUI that also covers mobile platforms. | Free, open source |
Clash for Windows | Legacy setups still standardized on it; the project is discontinued, so plan a migration path. | Free (discontinued) |
What this trend reveals
Pin-and-audit the core supply chain
prebuild.mjs fetches Mihomo core and service binaries on every fresh checkout, so the download URLs are the single choke point for supply-chain review. Mirror them internally and diff them on each release.
Read scripts/prebuild.mjs, record every URL it touches, then run `pnpm run prebuild --force` against a mirrored host and compare the fetched binaries.
Ship verified profiles
Monaco, monaco-yaml, and meta-json-schema already give the editor schema-aware YAML validation; the same schema can gate subscription files before they reach end users.
Load a deliberately malformed profile into the built-in editor and check which schema errors surface before the core reloads.
Cover the awkward build targets first
Windows ARM needs LLVM/clang for the ring crate, and Ubuntu needs five apt packages including libwebkit2gtk-4.1-dev and patchelf; CI that covers these targets removes the most common first-build failures for new contributors.
Follow the CONTRIBUTING prerequisites on clean Windows ARM and Ubuntu machines and measure how far a fresh contributor gets before the first successful `pnpm dev:tauri`.
RepoDaily verdict
Clash Verge Rev 2.5.3 is a disciplined GPL-3.0-only desktop proxy GUI: a Tauri 2.11.5 and React 19 split, a scripted Mihomo core pipeline, and workspace-level clippy denies that most desktop projects never adopt. The build-time binary fetch and the fork-pinned IPC plugin are the two concrete facts to weigh before making it your daily client.