Tauri mobile (Android + iOS): roadmap

Tauri mobile: state of the art of Android and iOS support

Tauri has historically been a framework for multi-platform desktop apps built in Rust and JavaScript/TypeScript. With version 2, the team expanded the horizons by including mobile support for Android and iOS in the official roadmap. This article explores the current state, planned milestones, and implications for developers who want to adopt Tauri for mobile-first applications.

Why Tauri for mobile?

The value proposition of Tauri mobile lies in code reuse between desktop and mobile. If your project already exists as a Tauri desktop app, porting it to Android/iOS means reusing the Rust logic of the core and adapting mainly the UI based on the mobile paradigm (navigation, screen size, touch).

Tauri mobile architecture

Unlike Cordova (wrapper around native WebView), Tauri mobile employs the same hybrid approach as desktop: the core business logic lives in Rust compiled natively; the UI is a WebView (WKWebView on iOS, WebView on Android) that communicates via IPC bridge. This allows:

• Isolation between logic (Rust) and presentation (web standards)
• Hot-reload of the UI without recompiling the native core
• Direct access to native Android/iOS APIs via Rust FFI (Foreign Function Interface)

// src-tauri/src/lib.rs (core Rust)
#[tauri::command]
pub async fn capture_camera(width: u32, height: u32) -> Result<Vec<u8>, String> {
  // Calls native Android/iOS permissions
  #[cfg(target_os = "android")]
  return android_camera::capture(width, height).await;

  #[cfg(target_os = "ios")]
  return ios_camera::capture(width, height).await;

  #[cfg(not(any(target_os = "android", target_os = "ios")))]
  Err("Camera not supported on this OS".to_string())
}

// Frontend TypeScript remains identical desktop/mobile
#[tauri::command]
pub async fn get_device_info() -> Result<DeviceInfo, String> {
  Ok(DeviceInfo {
    os: std::env::consts::OS.to_string(),
    device_model: get_device_model(), // Platform-specific
  })
}

Tauri mobile roadmap: phases and timeline

The official roadmap is dynamic and subject to revision based on community feedback. The following phases represent the stated vision as of Q3 2026:

Phase 1: Experimental (Q2–Q3 2026)

• Goal: Proof-of-concept Rust compilation on Android/iOS toolchain.
• Deliverable: Tauri project template that compiles on both platforms.
• Constraints: Basic WebView, no abstract mobile API, manual platform-specific code.
• Output: Feedback collected from community alpha testers.

Phase 2: Beta Stabilization (Q4 2026 – Q1 2027)

• Focus: Plugin ecosystem for common features (camera, geolocation, push notifications, storage, vibration).
• Deliverable: Set of official plugins curated by Tauri core team.
• Testing: Continuous integration across multi-device (emulators + device farm).
• Breaking changes: API changes still likely based on beta feedback.

Phase 3: General Availability (Q2 2027+)

• Milestone: Stable Semver, long-term support, defined deprecation policy.
• Plugin maturity: Third-party plugin ecosystem well-catalogued and maintained.
• Performance benchmarks: Bundle size, boot time, memory footprint published and documented.
• Adoption: Significant production apps operational.

Setting up development environment

Prerequisites for building Tauri mobile apps locally:

# macOS + Xcode (for iOS)
xcode-select --install
sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer

# Android SDK + NDK (Linux/Windows/macOS)
# Install Android Studio, then:
export ANDROID_HOME=$HOME/Library/Android/sdk
export PATH=$PATH:$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/latest/bin

# Rust targets for mobile
rustup target add aarch64-linux-android     # Android 64-bit
rustup target add armv7-linux-androideabi   # Android 32-bit
rustup target add aarch64-apple-ios         # iOS ARM64
rustup target add x86_64-apple-ios          # iOS Simulator

# Verify toolchain installed
rustc --print sysroot
cargo --version

# Official template (when available)
npm create tauri-app -- --template vue --mobile
# or (currently)
cargo create-tauri-app --template vue
cd app

# Build for Android (debug)
cd src-tauri
cargo build --target aarch64-linux-android

# Build for iOS (debug)
cargo build --target aarch64-apple-ios

# Run Android emulator
cargo tauri android run

# Run iOS simulator
cargo tauri ios run

Plugin integration and native APIs

The communication between TypeScript frontend and Rust backend on mobile follows the same IPC bridge model as desktop. Tauri plugins provide abstractions for native features:

import { invoke } from '@tauri-apps/api/tauri';

// Access camera (official mobile plugin)
async function takePicture() {
  try {
    const photoPath = await invoke('plugin:camera|capture', {
      width: 1080,
      height: 1440,
      quality: 0.85,
    });
    console.log('Photo saved:', photoPath);
  } catch (err) {
    console.error('Camera error:', err);
  }
}

// Geolocation
async function getCurrentLocation() {
  const location = await invoke('plugin:geolocation|get_location', {
    timeout: 10000, // ms
  });
  return location; // { lat, lon, accuracy }
}

// Persistent storage (mobile-safe)
async function saveUserPrefs(prefs: Record<string, unknown>) {
  await invoke('plugin:storage|set', {
    key: 'user_prefs',
    value: JSON.stringify(prefs),
  });
}

Performance considerations on mobile

Mobile apps face greater constraints on memory, battery, and CPU compared to desktop. Tauri mobile inherits Rust efficiency, but requires performance-conscious optimization:

// src-tauri/src/lib.rs
use std::sync::Arc;
use tokio::sync::Mutex;

// Pool of reusable connections (not created per command)
lazy_static::lazy_static! {
  static ref DB_POOL: Arc<Mutex<DatabasePool>> = Arc::new(
    Mutex::new(DatabasePool::new(4))
  );
}

#[tauri::command]
pub async fn query_database(sql: String) -> Result<Vec<Row>, String> {
  let pool = DB_POOL.lock().await;
  pool.execute(&sql)
    .await
    .map_err(|e| format!("DB error: {}", e))
}

// Graceful cleanup on app exit
#[tauri::command]
pub async fn cleanup() -> Result<(), String> {
  let pool = DB_POOL.lock().await;
  pool.close().await;
  Ok(())
}

Testing on real devices vs emulator

App quality depends on testing on real devices. Emulators (Android Studio, Xcode) are useful for prototyping, but reveal fewer issues than physical devices (performance, thermal behavior, touch latency).

Recommended testing strategies:

• Rust unit tests: `cargo test` for core logic, independent of platform.
• Integration testing: TestFlight (iOS) + Google Play Beta (Android) for controlled beta distribution.
• Device farm (CI/CD): BrowserStack, AWS Device Farm, or similar for automated multi-device testing.
• Manual QA: Touch responsiveness, screen orientation, interruptions (calls, notifications) on physical devices.

Adoption scenario: when to use Tauri mobile

Examples of multi-target architecture

[package]
name = "my-tauri-app"
version = "0.1.0"
edition = "2021"

[dependencies]
tauri = { version = "2.0", features = ["macos-private-api", "mobile"] }
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.40", features = ["full"] }
sqlx = { version = "0.8", features = ["sqlite", "runtime-tokio"] }

[target.'cfg(target_os = "android")'.dependencies]
android_logger = "0.14"
jni = "0.21"

[target.'cfg(target_os = "ios")'.dependencies]
objc = "0.2"

[features]
default = []
android = []
ios = []
desktop = []

Conclusion and future predictions

Tauri mobile represents a natural evolution of the framework, addressing developers who want a lightweight, performance-oriented solution with maximum code reuse across platforms. As of Q3 2026, the status is still experimental-to-beta, but the trajectory is clear: stability by Q2 2027.

Tauri mobile's competitive advantage is the Rust core + WebView UI synergy, which reduces bundle size and runtime overhead compared to interpreted runtimes. For teams with Rust expertise and performance constraints, it's an attractive stack. For rapid prototyping without Rust, Flutter/React Native remain more mature.

The practical recommendation: experiment with Tauri mobile today on non-critical projects (side project, proof-of-concept), gain experience with mobile debugging and the build cycle, and plan migration to v2 GA when API stability is officially guaranteed.