# How iLoader Handles Pairing Generation Based on iOS Version: Legacy vs. Modern Code Paths

> Discover how iLoader's Rust code paths handle pairing generation for iOS 15 and older versus iOS 16 and newer, ensuring device compatibility with distinct manifest creation.

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

---

**iLoader selects between two distinct Rust code paths in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs)—`generate_pairing_new` for iOS 16+ and `generate_pairing_legacy` for iOS 15 and earlier—to produce device-compatible pairing manifests.**

The nab138/iloader repository implements **pairing generation based on iOS version** through conditional logic in its Rust backend. Located in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs), this system dynamically selects between modern and legacy cryptographic approaches to establish device trust. Understanding these distinct code paths helps developers debug compatibility issues across different iOS releases.

## iOS Version Detection and Branching Logic

Before generating pairing files, the application retrieves the target iOS version through the device module. In [`src-tauri/src/device.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/device.rs), the system obtains an `IosVersion` enum that determines which pairing strategy executes at runtime. The core branching logic resides in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs), where the code compares the detected version against `IosVersion::V16` to determine the appropriate generation method.

```rust
// Conceptual representation based on src-tauri/src/pairing.rs
if ios_version >= IosVersion::V16 {
    generate_pairing_new(device_info, output_path)?;
} else {
    generate_pairing_legacy(device_info, output_path)?;
}

```

## Modern Pairing Generation for iOS 16+

When the detected version satisfies `ios_version >= IosVersion::V16`, the backend executes `generate_pairing_new` (approximately lines 120–170 in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs)). This function implements the modern Apple Device Management API introduced with iOS 16.

**Key implementation details:**
- Constructs a JSON-structured profile within a `pairing_profiles` directory
- Generates a `profile.mobileconfig` manifest file
- Cryptographically signs the output using the stored private key
- Adheres to the enhanced security specifications required by iOS 16 and later

## Legacy Pairing Generation for iOS 15 and Earlier

For devices running iOS 15 or older, the application falls back to `generate_pairing_legacy` (approximately lines 180–240 in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs)). This path maintains backward compatibility with older device management protocols.

**Key implementation details:**
- Produces a simple XML-based `.mobileconfig` file
- Embeds the device's UUID and a static certificate bundle
- Omits the nested `pairing_profiles` directory structure required by newer iOS versions
- Matches the format expected by pre-iOS 16 device management systems

## Frontend Integration and Tauri Commands

The React frontend in [`src/pages/Pairing.tsx`](https://github.com/nab138/iloader/blob/main/src/pages/Pairing.tsx) initiates the process by invoking the Tauri command `place_pairing_cmd`. This command registers in [`src-tauri/src/operation.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/operation.rs) alongside `export_pairing_cmd`, bridging the TypeScript UI layer with the Rust backend. When executed, the backend performs the version detection described above and dispatches to the appropriate generation function, ensuring the target device receives a compatible pairing file format.

## Summary

- **iLoader** dynamically selects pairing generation methods based on iOS version detected at runtime via `device::IosVersion`.
- **iOS 16+** devices receive modern JSON-structured profiles through `generate_pairing_new` in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs) (lines ~120–170).
- **iOS 15 and earlier** use XML-based legacy configurations through `generate_pairing_legacy` in the same file (lines ~180–240).
- The **Tauri command layer** in [`src-tauri/src/operation.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/operation.rs) exposes `place_pairing_cmd` and `export_pairing_cmd` to the frontend.
- The React frontend in [`src/pages/Pairing.tsx`](https://github.com/nab138/iloader/blob/main/src/pages/Pairing.tsx) triggers the Rust backend logic responsible for format selection.

## Frequently Asked Questions

### What determines which pairing generation path iLoader uses?

The iOS version obtained from `device::IosVersion` in [`src-tauri/src/device.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/device.rs) determines the execution path. If the version satisfies `>= IosVersion::V16`, the system executes `generate_pairing_new`; otherwise, it falls back to `generate_pairing_legacy`.

### Where are the pairing generation functions defined?

Both functions reside in [`src-tauri/src/pairing.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/pairing.rs). The modern implementation for iOS 16+ occupies approximately lines 120–170, while the legacy version for iOS 15 and earlier spans approximately lines 180–240.

### How does the frontend trigger the pairing generation process?

The React component in [`src/pages/Pairing.tsx`](https://github.com/nab138/iloader/blob/main/src/pages/Pairing.tsx) invokes the Tauri command `place_pairing_cmd`, which is registered in [`src-tauri/src/operation.rs`](https://github.com/nab138/iloader/blob/main/src-tauri/src/operation.rs). This command routes to the Rust backend, which then selects and executes the appropriate generation function based on the detected iOS version.

### Why does iOS 16 require a different pairing file format?

iOS 16 introduced enhanced Apple Device Management APIs that expect cryptographically signed JSON manifests within a `pairing_profiles` directory structure, replacing the simpler XML `.mobileconfig` files used by earlier iOS versions to enforce stricter security requirements.