# Where Are Tauri Commands Defined in iloader? A Complete Guide to the Rust Backend

> Discover where Tauri commands are defined in iloader's Rust backend. Explore the sideload pairing device and account modules for a complete guide to the codebase.

- Repository: [Nicholas Sharp/iloader](https://github.com/nab138/iloader)
- Tags: deep-dive
- Published: 2026-09-13

---

**Tauri commands in iloader are defined in the `src-tauri/src` directory across five specialized modules—[`sideload.rs`](https://github.com/nab138/iloader/blob/main/sideload.rs), [`secure_storage.rs`](https://github.com/nab138/iloader/blob/main/secure_storage.rs), [`pairing.rs`](https://github.com/nab138/iloader/blob/main/pairing.rs), [`device.rs`](https://github.com/nab138/iloader/blob/main/device.rs), and [`account.rs`](https://github.com/nab138/iloader/blob/main/account.rs)—using the `#[tauri::command]` attribute to expose Rust functions to the JavaScript frontend.**

The iloader repository by nab138 is a Tauri-based iOS sideloading application that bridges Rust backend functionality with a web-based frontend. Understanding exactly where Tauri commands are defined in iloader's Rust code is critical for developers extending the application or debugging device communication issues. All command handlers follow a consistent architectural pattern: public async functions (or standard functions) annotated with the `#[tauri::command]` macro, which the Tauri runtime automatically registers as invokable from the frontend.

## Command Architecture and File Organization

In iloader, the Tauri command layer is organized under the `src-tauri/src` path. The Tauri runtime scans the compiled binary for functions marked with the `#[tauri::command]` attribute and exposes them to the frontend using the exact Rust function names as command strings.

### The #[tauri::command] Pattern

Every command function in iloader follows this signature pattern:

```rust
#[tauri::command]
pub async fn command_name(arg: Type) -> Result<ReturnType, Error> {
    // Implementation
}

```

The `pub` visibility modifier and the procedural macro attribute are required for Tauri to register the function. Commands can be either `async` or synchronous `fn`, depending on whether they perform I/O operations or device communication that requires non-blocking execution.

## Module Breakdown: Command Locations by Function

The commands are distributed across five domain-specific modules, each handling a distinct aspect of iOS sideloading and device management.

### sideload.rs: App Installation Commands

Located at [`src-tauri/src/sideload.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/sideload.rs) (lines 73-90), this module handles the core sideloading functionality:

- **`sideload`** – Initiates the application installation process on a connected iOS device
- **`install_sidestore_operation`** – Handles specific SideStore installation workflows

These commands manage the actual transfer and installation of IPA files to devices.

### secure_storage.rs: Keyring Management Commands

Found in [`src-tauri/src/secure_storage.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/secure_storage.rs) (lines 13-27), this module provides secure credential storage:

- **`force_disable_keyring`** – Disables platform-specific keyring integration
- **`create_sideloading_storage`** – Initializes secure storage containers for sensitive sideloading data

These functions abstract platform keychain access for storing certificates and authentication tokens securely.

### pairing.rs: iOS Pairing File Commands

The [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs) module (lines 212-442) contains the most extensive command set for managing device pairing files:

- **`place_pairing_cmd`** – Stores pairing records on the filesystem
- **`export_pairing_cmd`** – Generates and exports pairing files for device communication
- **`delete_stored_rppairing`** – Removes stored pairing records
- **`has_stored_rppairing`** – Checks for existing pairing file availability
- **`installed_pairing_apps`** – Lists applications currently using pairing profiles

These commands enable the frontend to manage the cryptographic pairing relationship between the host computer and iOS devices.

### device.rs: Device Enumeration Commands

Located in [`src-tauri/src/device.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/device.rs) (lines 35-165), this module handles USB/Network device discovery and selection:

- **`list_devices`** – Enumerates all connected iOS devices via USB or WiFi
- **`set_selected_device`** – Sets the active device target for subsequent operations
- **`cancel_pairing`** – Aborts ongoing device pairing attempts

These functions provide the device selection interface required before any sideloading operation can commence.

### account.rs: Apple ID and Certificate Commands

The [`src-tauri/src/account.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/account.rs) module (lines 27-320) manages Apple ID authentication and developer certificate operations:

- **`login_new`** – Authenticates new Apple ID credentials
- **`login_stored`** – Re-authenticates using cached credentials
- **`delete_account`** – Removes stored account information
- **`logged_in_as`** – Retrieves currently authenticated account details
- **`invalidate_account`** – Forces credential invalidation
- **`reset_anisette_state`** – Resets Anisette data (Apple's authentication checkpoint)
- **`get_certificates`** – Retrieves developer signing certificates
- **`revoke_certificate`** – Revokes existing developer certificates
- **`list_app_ids`**, **`delete_app_id`** – Manages application identifiers

This module forms the authentication layer required for free developer account sideloading.

## Invoking Commands from the Frontend

Frontend code invokes these Rust commands using Tauri's `invoke` function from `@tauri-apps/api/tauri`. The command string must match the Rust function name exactly.

### TypeScript Invocation Examples

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

// List connected devices
async function getDevices() {
  const devices = await invoke<Array<any>>('list_devices');
  console.log('Connected devices:', devices);
}

// Authenticate with Apple ID
async function authenticate(email: string, password: string) {
  const result = await invoke('login_new', { email, password });
  return result;
}

// Export pairing file for a specific app
async function generatePairingFile(appId: string) {
  const plistPath = await invoke('export_pairing_cmd', { appId });
  console.log('Pairing file saved to:', plistPath);
}

// Check for stored pairing records
async function checkPairingStatus() {
  const hasPairing = await invoke<boolean>('has_stored_rppairing');
  return hasPairing;
}

```

Arguments are passed as a plain JavaScript object and deserialized into Rust function parameters. Return values are automatically serialized from Rust types to JavaScript values.

## Summary

- **Tauri commands in iloader are located in `src-tauri/src`** across five domain-specific modules that handle sideloading, secure storage, device pairing, device enumeration, and account management.
- **Commands use the `#[tauri::command]` attribute** on public async functions to register with the Tauri runtime automatically.
- **Key files include**: [`sideload.rs`](https://github.com/nab138/iloader/blob/main/sideload.rs) (installation), [`secure_storage.rs`](https://github.com/nab138/iloader/blob/main/secure_storage.rs) (credentials), [`pairing.rs`](https://github.com/nab138/iloader/blob/main/pairing.rs) (device pairing), [`device.rs`](https://github.com/nab138/iloader/blob/main/device.rs) (USB/WiFi devices), and [`account.rs`](https://github.com/nab138/iloader/blob/main/account.rs) (Apple ID auth).
- **Frontend invocation uses the exact Rust function name** as the command string in `invoke()` calls, with arguments passed as plain objects.

## Frequently Asked Questions

### What naming convention does iloader use for Tauri commands?

iloader uses the exact snake_case Rust function names as the command strings available to the frontend. For example, the Rust function `export_pairing_cmd` is invoked from TypeScript using `invoke('export_pairing_cmd', ...)`.

### How does iloader handle asynchronous operations in Tauri commands?

Most I/O-heavy commands in iloader, such as `sideload` and `login_new`, are defined as `pub async fn` to prevent blocking the main thread during device communication or network requests. The Tauri runtime automatically handles the async/await bridge between JavaScript promises and Rust futures.

### Where are the pairing file generation commands implemented?

The pairing file commands are implemented in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs) (lines 212-442), specifically the `export_pairing_cmd` function for generating files and `has_stored_rppairing` for checking existing records.

### Can I add custom Tauri commands to iloader's backend?

Yes, you can add custom commands by creating a new public function with the `#[tauri::command]` attribute in any file under `src-tauri/src`, then registering it in the Tauri builder within [`main.rs`](https://github.com/nab138/iloader/blob/main/main.rs). The function will automatically become available to the frontend using its Rust name.