Quick Answer: Tauri 2 app development means building a desktop or mobile app with a Rust backend and a web-based interface. Tauri renders your UI in the operating system's own webview instead of bundling a full browser, so the installers are small. The HGhub project, a Tauri 2 interface practice repo, uses React, TypeScript, and Vite on the front end and Rust on the back end, and it shows how the pieces fit together.
Tauri 2 app development looks simple in the framework's getting-started guide and gets interesting the moment you add a second platform, a native capability, or a dependency that changes under you. The repository at AIRzZ90/study-materials-fork is a fork of a project called HGhub, and its README is more useful than most as a case study. It spells out the stack, the setup steps, the filesystem gotchas, and, unusually, what the maintainer will and won't support. Here's what you can learn from it.
One caveat before we start. The repository page opens with a reprint banner, and the fork's name doesn't match the upstream project's README. Check the upstream history before you rely on any code in it. The architecture lessons below don't depend on that.
Why Tauri 2 Instead of Electron?
The most common question about Tauri is whether it's worth choosing over Electron. The short answer: Tauri trades Chromium's consistency for a much smaller footprint. Electron bundles its own Chromium and Node.js runtime with every app, which is why a minimal Electron binary is typically well over 100 MB. Tauri instead asks the operating system for a webview: WebView2 on Windows, WKWebView on macOS and iOS, and WebKitGTK on Linux. The result is a smaller installer and lower idle memory.
The trade-off is rendering consistency. Because each platform ships its own webview, a CSS feature that works in Chrome may behave differently on an older WebKitGTK build. Electron developers rarely have to think about that. Tauri developers have to test on each target platform, and that cost is real.
Tauri 2, which reached stable release in 2024, added first-class iOS and Android targets alongside desktop. That's the reason this project lists mobile configs in src-tauri/tauri*.conf.json. It's also the reason mobile and macOS builds need their own SDKs and toolchains, which the README mentions explicitly.
Setting Up the Toolchain Without Surprises
The README lists the baseline: Node.js 22, pnpm 10, Rust 1.90 or newer, and the platform-specific Tauri prerequisites. Pin these versions. Rust toolchain drift is one of the most common reasons a Tauri build works on one laptop and fails on another.
A typical setup looks like this:
- Install Rust through
rustupand confirm withrustc --version. - Install the platform prerequisites from the Tauri docs (WebView2 on Windows, Xcode command-line tools on macOS, and the GTK and WebKit development packages on Linux).
- Run
pnpm install --frozen-lockfileso the install matches the committed lockfile exactly. - Start the frontend with
pnpm dev, or the desktop shell withpnpm app:dev.
The --frozen-lockfile flag matters more than it looks. Without it, pnpm can silently resolve newer transitive versions, and a bug can show up in CI with no code change to point at.
Here's the part most setup guides skip. If you work on exFAT, or any filesystem that doesn't support symbolic links, pnpm's default linker breaks. This project's answer is node-linker=hoisted in .npmrc. Even with that fix, the README warns that some native build steps can still hit filesystem limits. Don't assume a successful pnpm install means a successful Tauri build.
The Architecture: Where the Rust Ends and the Web Begins
This project splits its code the way most well-organized Tauri apps do. The src/ directory holds the React interface, interaction logic, state management, and components. The src-tauri/ directory holds the native layer in Rust. Tests and local regression pages live in tests/, and build and verification scripts live in scripts/.
The boundary between those two layers is where most Tauri bugs live. The web side calls Rust through Tauri commands, and Rust sends data back through events and return values. Keep the boundary narrow. Every command you expose is an attack surface and a serialization cost, so only expose what the interface actually needs.
The networking stack is a good example. The README lists reqwest with rustls for HTTP. Using rustls instead of the platform's OpenSSL keeps TLS behavior consistent across Windows, macOS, Linux, and mobile. That's a deliberate choice, and a reasonable one for a cross-platform app. The downside is that certificate handling no longer follows the OS trust store unless you configure it, and that can surprise you in corporate networks.
Playback uses hls.js, which handles HTTP Live Streaming in browsers that lack native HLS support. In a Tauri webview, this is a practical decision: WebKitGTK and some Android webviews don't play HLS natively, so a JavaScript player fills the gap. The lesson generalizes. Test your media path on every webview you ship, not just the one on your development machine.
The Counter-Intuitive Lesson: Scope Is a Technical Decision
Most framework guides treat a project as a pile of code. This README treats it as a set of commitments, and that's the most useful part for anyone building a long-lived app.
The maintainer states that they'll actively maintain only UI, interaction details, and user experience. They won't keep up with upstream data fetching, parsing, or playback adaptation, and they make no promise that external interfaces will keep working. The README also says pull requests and issues are welcome but may get low-frequency responses, and that accepting a contribution doesn't mean taking on ongoing maintenance of that area.
Why does this matter to you as a developer? Because the layer you don't control will break first. Any app that depends on a remote API, a scraped page, or a third-party stream has a maintenance cost that grows with time, and it doesn't show up in your commit history. Writing down the boundary, as this README does, tells users and contributors which breakages you'll fix and which they should expect to fix themselves.
Most people assume a permissive-sounding open-source license means the code is free to reuse in any context. It doesn't. This project uses the PolyForm Noncommercial License 1.0.0, which prohibits commercial use, including selling the software, ad monetization, paid unlocks, and use as part of a paid product. The README also notes that earlier versions, v1.0.1 and before, were released under MIT, and that those grants aren't revoked by the relicense. If you're choosing a license for your own Tauri app, read the full text rather than the summary. "Source available" and "open source" mean different things under the Open Source Definition, and PolyForm Noncommercial falls on the source-available side.
A Practical Checklist for Your Own Tauri 2 Project
Before you ship a Tauri 2 app, work through these in order:
- Pin Node, pnpm, and Rust versions in the repo, and commit the lockfile.
- Run a clean build on every target platform, not just your primary one.
- Keep the Rust command surface small and document each command's input and output.
- Decide up front which upstream dependencies you'll actively maintain, and write that down.
- Confirm your license covers the commercial use you intend.
Most people stop here, but the most expensive mistakes come from skipping step 2. A webview difference you find in testing costs an afternoon. Finding it in a user bug report costs weeks.
Frequently Asked Questions
What is Tauri 2 app development?
Tauri 2 app development is building desktop and mobile applications with a Rust core and a web-based interface, using the operating system's native webview for rendering. Tauri 2 targets Windows, macOS, Linux, iOS, and Android. Compared with Electron, the apps are typically much smaller because they don't bundle Chromium.
How do I start a Tauri 2 project with React?
Install Rust, Node.js, and pnpm at the versions the project specifies, then install the platform prerequisites from the Tauri docs. Run pnpm install --frozen-lockfile, then pnpm app:dev to launch the desktop shell. Use --frozen-lockfile so your install matches the committed lockfile exactly.
Why does Tauri use the system webview instead of Chromium?
Tauri uses the system webview to keep app size and memory use low. WebView2 on Windows, WKWebView on Apple platforms, and WebKitGTK on Linux are already installed on the user's machine. The trade-off is that rendering can differ across platforms, so you need to test on each one.
Can I use Tauri 2 apps commercially under a noncommercial license?
Not if the license prohibits commercial use. PolyForm Noncommercial 1.0.0 forbids selling the software, ad monetization, paid unlocks, and use in paid products. Read the full license text and check whether an earlier version under a different license applies to the version you're using.
Why does pnpm fail on exFAT drives?
exFAT doesn't support symbolic links, and pnpm's default linker relies on them. Setting node-linker=hoisted in .npmrc switches to a flat layout that avoids symlinks. Some native build steps may still fail on that filesystem, so for serious Tauri work, build on a filesystem that supports links.
Tauri 2 gives you a fast path to desktop and mobile apps, but the framework is the easy part. The hard parts are keeping the Rust-to-web boundary narrow, testing your webview on every target, and being honest about which dependencies you'll maintain. Try running a clean pnpm install --frozen-lockfile and pnpm build on a second machine this week, and note where the two builds differ. Pass this article to a teammate who's wrestling with a Tauri build that works on one laptop and breaks on another.