Setting Up Tauri Projects

What is Tauri?

Tauri is a framework for building tiny, fast binaries for all major desktop and mobile platforms. It combines any frontend that compiles to HTML/JS/CSS with Rust for the backend.

Key characteristics:

• Minimal apps can be under 600KB (uses system webview, not bundled browser)

• Built on Rust for memory, thread, and type safety

• Supports virtually any frontend framework

• Cross-platform: Windows, macOS, Linux, iOS, Android

System Prerequisites

macOS

For desktop + iOS development

Install Xcode from Mac App Store

For desktop-only development (lighter option)

xcode-select --install

Windows

• Microsoft C++ Build Tools: Download from Visual Studio, select "Desktop development with C++"

• WebView2: Pre-installed on Windows 10 v1803+ (install manually if needed)

• Rust toolchain:

winget install Rustlang.Rustup rustup default stable-msvc

Linux

Debian/Ubuntu:

sudo apt update sudo apt install libwebkit2gtk-4.1-dev build-essential curl wget file
libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev

Arch Linux:

sudo pacman -S webkit2gtk-4.1 base-devel curl wget file openssl
appmenu-gtk-module libappindicator-gtk3 librsvg xdotool

Fedora:

sudo dnf install webkit2gtk4.1-devel openssl-devel curl wget file
libappindicator-gtk3-devel librsvg2-devel libxdo-devel
@development-tools

Rust (All Platforms)

macOS/Linux

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Windows (PowerShell)

winget install Rustlang.Rustup

Node.js

Required only for JavaScript/TypeScript frontends. Install LTS version from nodejs.org.

Mobile Development (Optional)

Android (all platforms):

Install Android Studio, then add Rust targets

rustup target add aarch64-linux-android armv7-linux-androideabi
i686-linux-android x86_64-linux-android

Set environment variables: JAVA_HOME , ANDROID_HOME , NDK_HOME

iOS (macOS only):

Requires full Xcode (not just Command Line Tools)

rustup target add aarch64-apple-ios x86_64-apple-ios aarch64-apple-ios-sim

Install Cocoapods

brew install cocoapods

Creating a Project

Method 1: create-tauri-app (Recommended)

Interactive scaffolding with framework templates.

npm

npm create tauri-app@latest

pnpm

pnpm create tauri-app

yarn

yarn create tauri-app

bun

bun create tauri-app

cargo (no Node.js required)

cargo install create-tauri-app --locked cargo create-tauri-app

Shell scripts

sh <(curl https://create.tauri.app/sh) # Bash irm https://create.tauri.app/ps | iex # PowerShell

Prompts you'll see:

• Project name

• Bundle identifier (e.g., com.example.app )

• Frontend language: TypeScript/JavaScript, Rust, or .NET

• Package manager

• UI template: vanilla, Vue, Svelte, React, SolidJS, Angular, Preact, Yew, Leptos, Sycamore

After scaffolding:

cd your-project npm install npm run tauri dev

Method 2: Manual Setup (Existing Projects)

Add Tauri to an existing frontend project.

1. In your existing project, install Tauri CLI

npm install -D @tauri-apps/cli@latest

2. Initialize Tauri (creates src-tauri directory)

npx tauri init

tauri init prompts:

• App name

• Window title

• Frontend dev server URL (e.g., http://localhost:5173 )

• Frontend build output directory (e.g., dist )

• Frontend dev command (e.g., npm run dev )

• Frontend build command (e.g., npm run build )

3. Start development

npx tauri dev

Project Structure

my-tauri-app/ ├── package.json # Frontend dependencies ├── index.html # Frontend entry point ├── src/ # Frontend source code │ └── main.js └── src-tauri/ # Rust backend ├── Cargo.toml # Rust dependencies ├── Cargo.lock ├── build.rs # Tauri build script ├── tauri.conf.json # Main Tauri configuration ├── capabilities/ # Permission/capability definitions ├── icons/ # App icons (all formats) └── src/ ├── lib.rs # Main Rust code + mobile entry point └── main.rs # Desktop entry point

Key Files

tauri.conf.json - Primary configuration:

{ "productName": "my-app", "version": "0.1.0", "identifier": "com.example.my-app", "build": { "devUrl": "http://localhost:5173", "frontendDist": "../dist" }, "app": { "windows": [{ "title": "My App", "width": 800, "height": 600 }] } }

src/lib.rs - Rust application code:

#[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { tauri::Builder::default() .run(tauri::generate_context!()) .expect("error while running tauri application"); }

src/main.rs - Desktop entry point:

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

fn main() { app_lib::run(); }

capabilities/ - Define what commands JavaScript can invoke:

{ "identifier": "main-capability", "windows": ["main"], "permissions": ["core:default"] }

Common Commands

Development with hot reload

npm run tauri dev

Build production binary

npm run tauri build

Generate app icons from source image

npm run tauri icon path/to/icon.png

Add Android target

npm run tauri android init

Add iOS target

npm run tauri ios init

Run on Android

npm run tauri android dev

Run on iOS simulator

npm run tauri ios dev

Quick Reference: Supported Frontend Templates

Template Languages Notes

vanilla JS, TS No framework

react JS, TS Vite-based

vue JS, TS Vite-based

svelte JS, TS Vite-based

solid JS, TS Vite-based

angular TS Angular CLI

preact JS, TS Vite-based

yew Rust Rust WASM frontend

leptos Rust Rust WASM frontend

sycamore Rust Rust WASM frontend