# iloader Tauri Backend Rust Commands: Complete API Reference

> Explore iloader's Tauri backend Rust commands to manage device discovery, IPA sideloading, and Apple developer accounts. Discover 20+ commands for seamless iOS management.

- Repository: [Nicholas Sharp/iloader](https://github.com/nab138/iloader)
- Tags: api-reference
- Published: 2026-09-12

---

**iloader exposes 20+ Rust commands through its Tauri backend, enabling device discovery, IPA sideloading, pairing file management, and Apple developer account operations via the `#[tauri::command]` attribute.**

The `nab138/iloader` repository implements a Rust-based Tauri backend that bridges the React frontend with iOS system APIs. Each public operation available to the UI is defined as an async Rust function decorated with `#[tauri::command]` and registered in the Tauri application state. These commands handle everything from USB device enumeration to secure credential storage in the OS keyring.

## Device Management Commands

Device handling capabilities reside in [`src-tauri/src/device.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/device.rs) and provide the foundation for USB and network device discovery.

### list_devices()

The `list_devices()` function scans for connected iOS devices via USB and network protocols. It returns a list of device information structs that populate the frontend device selector. According to the source code at `src-tauri/src/device.rs#L35-L46`, this command performs no caching and requests fresh data from the underlying iOS communication libraries on every invocation.

### set_selected_device()

When a user selects a device from the UI, `set_selected_device()` updates the global application state with the chosen device reference and its pairing file. Located at `src-tauri/src/device.rs#L23-L34`, this command also cancels any previously running pairing job to prevent state conflicts.

### cancel_pairing()

The `cancel_pairing()` command aborts an ongoing pairing operation using a `CancellationToken`. As implemented in `src-tauri/src/device.rs#L65-L71`, this provides immediate feedback to the UI when users click "Cancel" during the device trust dialog phase.

## Sideloading Operations

Core installation logic lives in [`src-tauri/src/sideload.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/sideload.rs), wrapping the sideloading process in Tauri's operation tracking system for progress reporting.

### sideload_operation()

The `sideload_operation()` command initiates a UI-visible operation that installs an IPA file onto the currently selected device. Found at `src-tauri/src/sideload.rs#L73-L88`, this function accepts the IPA path, application handle, and window reference to stream installation progress back to the frontend.

### install_sidestore_operation()

For initial setup, `install_sidestore_operation()` downloads the SideStore or LiveContainer IPA, installs it to the selected device, and automatically places the required pairing file in the app's container. The implementation at `src-tauri/src/sideload.rs#L90-L118` handles the complete bootstrap flow for new installations, including nightly build selection and LiveContainer mode toggles.

## Pairing File Management

Pairing operations in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs) manage the cryptographic relationship between iloader and iOS devices.

### place_pairing_cmd()

The `place_pairing_cmd()` command transmits a pairing file to a specific bundle identifier on the target device. Defined at `src-tauri/src/pairing.rs#L12-L28`, this enables SideStore or other sideloading tools to receive the necessary pairing credentials without manual user intervention.

### export_pairing_cmd()

To backup pairing files, `export_pairing_cmd()` opens a native file-save dialog and writes the current pairing data to disk. Located at `src-tauri/src/pairing.rs#L31-L38`, this uses Tauri's dialog API to ensure proper sandbox permissions on macOS and Windows.

### RPPairing Cache Management

The backend maintains a cache of RPPairing files to speed up reconnection:

- **`has_stored_rppairing()`**: Checks for cached pairing data at `src-tauri/src/pairing.rs#L26-33` to determine if the UI should skip the initial pairing flow
- **`delete_stored_rppairing()`**: Removes cached data at `src-tauri/src/pairing.rs#L4-5` when users explicitly log out or reset their device connection
- **`installed_pairing_apps()`**: Returns a list of installed apps known to support pairing files at `src-tauri/src/pairing.rs#L44-49`

## Secure Storage Controls

The [`src-tauri/src/secure_storage.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/secure_storage.rs) module provides OS keyring integration with manual override capabilities.

### force_disable_keyring()

The `force_disable_keyring()` command allows users to forcibly disable the OS keyring backend, falling back to encrypted filesystem storage. Implemented at `src-tauri/src/secure_storage.rs#L13-19`, this addresses compatibility issues with certain Linux distributions or enterprise macOS configurations.

### keyring_available()

Before attempting credential storage, the frontend queries `keyring_available()` at `src-tauri/src/secure_storage.rs#L27-31` to determine if the keyring backend is functional and not disabled by user preference.

## Apple Developer Account Commands

Developer session management in [`src-tauri/src/account.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/account.rs) handles authentication, certificate provisioning, and App ID registration.

### Authentication and Session Management

- **`login_new()`** (`src-tauri/src/account.rs#L27-41`): Authenticates with fresh Apple ID credentials, optionally stores them in the keyring, and initializes a `Sideloader` instance for subsequent operations
- **`login_stored()`** (`src-tauri/src/account.rs#L69-77`): Retrieves cached credentials from secure storage and establishes a session without re-prompting the user
- **`delete_account()`** (`src-tauri/src/account.rs#L93-108`): Permanently removes stored credentials from both the keyring and the internal JSON state file
- **`logged_in_as()`** (`src-tauri/src/account.rs#L18-25`): Returns the email address of the currently active Apple account or `None` if no session exists
- **`invalidate_account()`** (`src-tauri/src/account.rs#L27-31`): Clears the in-memory `Sideloader` instance, effectively logging out while preserving stored credentials
- **`reset_anisette_state()`** (`src-tauri/src/account.rs#L33-50`): Deletes cached anisette provisioning data from the keyring to resolve authentication errors

### Certificate and App ID Management

- **`get_certificates()`** (`src-tauri/src/account.rs#L66-74`): Retrieves all development certificates associated with the current team, including expiration dates and serial numbers
- **`revoke_certificate()`** (`src-tauri/src/account.rs#L86-94`): Revokes a specific development certificate by serial number through the Apple Developer Portal API
- **`list_app_ids()`** (`src-tauri/src/account.rs#L98-106`): Fetches the complete list of registered App IDs for the current developer team
- **`delete_app_id()`** (`src-tauri/src/account.rs#L110-118`): Removes a specific App ID identifier from the developer portal

## How to Invoke These Commands from the Frontend

All Rust commands are exposed to the TypeScript frontend via Tauri's `invoke` API. The React/TSX interface calls these functions asynchronously and receives strongly typed responses.

**Listing connected devices:**

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

const devices = await invoke<DeviceInfo[]>('list_devices');

```

**Selecting a device and starting background pairing:**

```typescript
await invoke('set_selected_device', { device: selectedDevice });

```

**Installing SideStore with automatic pairing file placement:**

```typescript
await invoke('install_sidestore_operation', {
  handle: appHandle,
  window,
  device_state,
  sideloader_state,
  nightly: false,
  live_container: false,
});

```

**Authenticating with Apple Developer credentials:**

```typescript
await invoke('login_new', {
  handle: appHandle,
  window,
  sideloader_state,
  email,
  password,
  anisette_server: 'anisette.apple.com',
  save_credentials: true,
});

```

## Summary

- **iloader** exposes its Rust backend through **20+ Tauri commands** defined across five specialized modules
- **Device handling** in [`src-tauri/src/device.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/device.rs) provides `list_devices()`, `set_selected_device()`, and `cancel_pairing()` for USB and network iOS discovery
- **Sideloading operations** in [`src-tauri/src/sideload.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/sideload.rs) handle IPA installation via `sideload_operation()` and SideStore bootstrapping via `install_sidestore_operation()`
- **Pairing file management** in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs) supports placement, export, and caching of RPPairing files with `place_pairing_cmd()` and `export_pairing_cmd()`
- **Secure storage** in [`src-tauri/src/secure_storage.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/secure_storage.rs) offers `force_disable_keyring()` and `keyring_available()` for credential backend management
- **Apple account commands** in [`src-tauri/src/account.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/account.rs) manage developer sessions, certificates, and App IDs through functions like `login_new()`, `get_certificates()`, and `delete_app_id()`

## Frequently Asked Questions

### How does iloader handle device communication from the Rust backend?

iloader utilizes the `#[tauri::command]` macro to expose Rust functions to the JavaScript frontend. Device-specific commands like `list_devices()` and `set_selected_device()` in [`src-tauri/src/device.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/device.rs) wrap low-level iOS communication libraries, providing async interfaces that the React UI can invoke with type-safe parameters and return values.

### Can iloader cache Apple Developer credentials securely?

Yes, according to the source code in [`src-tauri/src/account.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/account.rs) and [`src-tauri/src/secure_storage.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/secure_storage.rs), iloader supports storing Apple ID credentials in the OS-native keyring (Keychain on macOS, Credential Manager on Windows, Secret Service on Linux). The `login_stored()` command retrieves these credentials automatically, while `force_disable_keyring()` provides a fallback to encrypted file storage when keyring access is restricted.

### What is the difference between sideload_operation and install_sidestore_operation?

`sideload_operation()` in `src-tauri/src/sideload.rs#L73-L88` is a generic IPA installer for arbitrary application packages, while `install_sidestore_operation()` at `src-tauri/src/sideload.rs#L90-L118` is a specialized bootstrap command that downloads the SideStore IPA, installs it, and automatically transfers the pairing file required for subsequent wireless sideloading operations.

### How does iloader manage pairing files for SideStore compatibility?

The backend implements specific pairing file commands in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs), including `place_pairing_cmd()` to transmit files to specific app bundles and `export_pairing_cmd()` to save backups locally. The system also maintains an RPPairing cache via `has_stored_rppairing()` and `delete_stored_rppairing()` to optimize reconnection flows without requiring repeated device trust dialogs.