Bini.js
GitHubnpm

iOS

Build native iOS mobile applications with Bini.js.

iOS Overview

Bini.js allows you to build native iOS mobile applications using Tauri. Your React app runs inside a WKWebView with full access to native iOS APIs and features.

Native iOS App

Real native iOS app, not a WebView wrapper

Code Signing

Xcode-managed automatic signing

Auto Plugin Wiring

bini-native detects web APIs and wires iOS permissions automatically

Full Configuration

Splash screen, status bar, and more configurable

iOS apps are built using Tauri's iOS backend. Your app runs in a native WKWebView with full system access.

Requirements

⚠️ iOS development requires macOS with Xcode for local development

Before building iOS apps, make sure you have the following installed:

  • macOS 11 (Big Sur) or higher (for local development)
  • Node.js 20.19.0 or higher
  • Xcode (Mac App Store) — Download
  • Xcode Command Line Tools — xcode-select --install
  • CocoaPods — sudo gem install cocoapods
  • Rust targets:
    • rustup target add aarch64-apple-ios
    • rustup target add x86_64-apple-ios
    • rustup target add aarch64-apple-ios-sim
iOS development is only supported on macOS for local development. Windows and Linux users can use GitHub Actions.

macOS

Build iOS apps natively on macOS using Xcode and the CLI.

Setup on macOS

  • Install Xcode from the Mac App Store
  • Install Xcode Command Line Tools with xcode-select --install
  • Install CocoaPods with sudo gem install cocoapods
  • Install Node.js from nodejs.org
  • Install Rust targets with rustup
# Create a new iOS project
npx create-bini-app@latest my-app --platform ios

# Navigate to project
cd my-app

# Install dependencies
npm install
pod install --project-directory=src-tauri/gen/ios

# Run on simulator or device
npm run ios

# Build for distribution
npm run ios:build
iOS development requires macOS with Xcode. All iOS development commands work on macOS.

Windows

Build iOS apps from Windows using GitHub Actions. This is the recommended approach for cross-platform builds.

GitHubGitHub Actions Workflow
.github/workflows/build-ios.yml
# .github/workflows/build-ios.yml
name: Build iOS App

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-ios:
    runs-on: macos-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
          
      - name: Install dependencies
        run: npm install
        
      - name: Install CocoaPods
        run: sudo gem install cocoapods
        
      - name: Install Rust targets
        run: |
          rustup target add aarch64-apple-ios
          rustup target add x86_64-apple-ios
          rustup target add aarch64-apple-ios-sim
          
      - name: Build iOS app
        run: npm run ios:build
        
      - name: Upload artifacts
        uses: actions/upload-artifact@v3
        with:
          name: ios-build
          path: src-tauri/gen/ios/target/universal-apple-ios/release/*.app

Why GitHub Actions? Tauri recommends GitHub Actions for cross-platform builds because:

  • No local Xcode setup required
  • Consistent build environment
  • Automatic artifact generation
  • Works from Windows and Linux
GitHub Actions runs on macOS runners to build native iOS applications. This works from Windows.

Linux

Build iOS apps from Linux using GitHub Actions. This is the recommended approach for cross-platform builds.

GitHubGitHub Actions Workflow
.github/workflows/build-ios.yml
# .github/workflows/build-ios.yml
name: Build iOS App

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-ios:
    runs-on: macos-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
          
      - name: Install dependencies
        run: npm install
        
      - name: Install CocoaPods
        run: sudo gem install cocoapods
        
      - name: Install Rust targets
        run: |
          rustup target add aarch64-apple-ios
          rustup target add x86_64-apple-ios
          rustup target add aarch64-apple-ios-sim
          
      - name: Build iOS app
        run: npm run ios:build
        
      - name: Upload artifacts
        uses: actions/upload-artifact@v3
        with:
          name: ios-build
          path: src-tauri/gen/ios/target/universal-apple-ios/release/*.app

Why GitHub Actions? Tauri recommends GitHub Actions for cross-platform builds because:

  • No local Xcode setup required
  • Consistent build environment
  • Automatic artifact generation
  • Works from Windows and Linux
GitHub Actions with macos-latest runners is the official Tauri-recommended approach for building iOS apps from Linux.

Creating an iOS App

Create a new Bini.js project targeting iOS:

npx create-bini-app@latest my-app --platform ios

Or use the interactive prompt and select ios:

Prompt: Which platform would you like to target?

web / windows / macos / linux / android / ios

Select ios and press Enter

npx create-bini-app@latest

After installation, navigate to your project and install dependencies:

cd my-app
npm install
pod install --project-directory=src-tauri/gen/ios

Development

Run your iOS app on the simulator or a connected device:

npm run ios

This launches your app with:

  • Hot reload for frontend changes
  • Native iOS integration
  • Auto-wired native APIs (bini-native)
  • Safari Web Inspector for debugging

Setting up a Simulator

  1. Open Xcode
  2. Go to Preferences → Components
  3. Download a simulator for your target iOS version
  4. Run npm run ios

Building

Build your iOS app for distribution:

npm run ios:build

This creates a signed iOS app in the src-tauri/gen/ios/target/universal-apple-ios/release/ directory.

Output Files

  • my-app.app — iOS app bundle
  • my-app.ipa — iOS App Store package (if configured)
The build output is a native iOS app that runs on iOS 13.0 and above.

Code Signing

iOS code signing is managed by Xcode. Configure signing in src-tauri/gen/ios/:

# For development
# Xcode handles automatic signing with your Apple ID

# For distribution
# Configure signing in Xcode project:
# src-tauri/gen/ios/MyApp.xcodeproj

For GitHub Actions, you can use secrets for secure certificate storage:

# In GitHub Actions workflow
- name: Build iOS app
  env:
    APPLE_ID: ${{ secrets.APPLE_ID }}
    APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
    TEAM_ID: ${{ secrets.TEAM_ID }}
  run: npm run ios:build
For App Store distribution, you need an Apple Developer account and provisioning profiles. Development builds use Xcode's automatic signing.

Deployment

Deploy your iOS project by pushing to GitHub:

npm run deploy

deploy does not build, sign, or submit to the App Store — it pushes the project source to GitHub.

Deployment Flow

  1. Build your app with npm run ios:build
  2. Run npm run deploy to push source to GitHub
  3. Upload the app to App Store Connect manually
Store submission is manual. After building your app, upload it to App Store Connect for TestFlight or App Store distribution.
Previous
Android
Next
Deployment