Titanium iOS Module Build Fails with Simulator Warnings Despite Physical Device Target

The build failure you’re experiencing occurs because your Titanium iOS module is attempting to build for simulators when you’ve specified device-only dependencies. Even though you’re targeting a physical device, the build process is still referencing simulator slices, which aren’t available in your dependencies. This mismatch causes the build to fail.

Contents

• Understanding the Core Issue
• Do You Need a Physical Device Connected?
• Why Titanium References Simulator Slices
• Solving the Build Failure
• Best Practices for Module Dependencies
• Troubleshooting Checklist

Understanding the Core Issue

When building a Titanium iOS module with external dependencies like .xcframeworks or Swift Packages, the build process must generate slices for both simulators and physical devices. Your error message indicates that:

1. Titanium is detecting multiple build destinations (both simulators and devices)
2. It’s defaulting to a simulator destination first, as shown by the warning: “Using the first of multiple matching destinations”
3. Your dependencies only contain device slices (as noted by “SDK provider notes: no simulator slices provided”)
4. This architecture mismatch causes the build to fail

The key insight is that even when you specify --build-only and intend to target a physical device, Titanium’s build system still evaluates all available destinations, including simulators.

Do You Need a Physical Device Connected?

For a Titanium module build with --build-only flag, you do not need a physical device connected. The --build-only flag specifically tells Titanium to:

• Generate the module package (.zip file)
• Not install it to a device or simulator
• Focus on the compilation and linking process

However, the issue isn’t about device connectivity—it’s about architecture compatibility. Titanium needs to know which architectures to build for, and when dependencies only provide device slices, the build process should default to device-only builds.

Why Titanium References Simulator Slices

Titanium references simulator slices for several reasons:

1. Development Workflow: Titanium’s default build configuration often includes simulators for testing purposes during development.

2. Missing Device-Only Configuration: When no explicit device-only configuration is set, Titanium falls back to evaluating all available build destinations.

3. Dependency Architecture: Your .xcframeworks or packages might be configured in a way that doesn’t properly communicate their device-only nature to the build system.

4. Titanium’s Build System: The Titanium CLI might be defaulting to a “generic” build that checks all available destinations before determining the appropriate architecture.

Here’s what happens when you include dependencies without proper architecture configuration:

Titanium Build Process
                      |
                      v
Determine available destinations
                      |
                      v
[Simulators] [Devices]
      |           |
      v           v
Check dependencies   Check dependencies
for slices          for slices
      |           |
      v           v
Failure (no slices) Success (device slices)

Solving the Build Failure

Solution 1: Explicitly Specify Device-Only Build

Modify your build command to explicitly target a device:

ti build -p ios --build-only --target-device iphone

This tells Titanium to only consider device builds and ignore simulators.

Solution 2: Configure Your Dependencies Properly

For .xcframeworks, ensure they contain the correct architecture slices. If you’re creating your own .xcframework:

# Create device framework
xcodebuild -project YourProject.xcodeproj -scheme YourScheme -configuration Release -sdk iphoneos -arch arm64 -archivePath YourProject.xcarchive archive

# Create simulator framework
xcodebuild -project YourProject.xcodeproj -scheme YourScheme -configuration Release -sdk iphonesimulator -arch x86_64 -archivePath YourProject-sim.xcarchive archive

# Combine into universal xcframework
xcodebuild -create-xcframework -framework YourProject.xcarchive/Products/Library/Frameworks/YourProject.framework -framework YourProject-sim.xcarchive/Products/Library/Frameworks/YourProject.framework -output YourProject.xcframework

Solution 3: Modify Module Configuration

Update your module’s module.xcconfig file to explicitly specify device-only architectures:

// module.xcconfig
ONLY_ACTIVE_ARCH = NO
VALID_ARCHS = arm64 arm64e
ARCHS = arm64 arm64e

Solution 4: Update Build Script in Your Module

In your Titanium module’s build.py file, modify the build script to explicitly set device-only configuration:

def build titaniumSdk):
    import os
    import subprocess
    
    # Get the path to the xcodeproj
    xcodeproj_path = os.path.join(os.getcwd(), "YourModule.xcodeproj")
    
    # Build for device only
    cmd = ["xcodebuild", "-project", xcodeproj_path, "-scheme", "YourModule", "-configuration", "Release", "-sdk", "iphoneos", "archive"]
    
    # Execute the command
    subprocess.call(cmd)

Solution 5: Check and Update Your Package Dependencies

For Swift Package dependencies, ensure they’re properly configured to include device architectures. In Xcode:

1. Select your project in the Project Navigator
2. Go to your target’s “Frameworks, Libraries, and Embedded Content”
3. Verify the package dependencies are set to “Embed & Sign”
4. Check the “Platforms” section to ensure iOS is selected with appropriate architectures

Best Practices for Module Dependencies

1. Universal Frameworks

Always create universal .xcframeworks that include:

• Device slices (arm64, arm64e)
• Simulator slices (x86_64, arm64 for Apple Silicon Macs)

2. Conditional Code

Use conditional compilation to separate simulator and device code:

#if targetEnvironment(simulator)
    // Simulator-specific code
#else
    // Device-specific code
#endif

3. Architecture Validation

Add validation in your module to ensure proper architectures:

import Foundation

public class ArchitectureValidator {
    public static func validate() {
        #if targetEnvironment(simulator)
            print("Running on simulator")
        #else
            print("Running on device")
        #endif
    }
}

4. Proper Dependency Management

Use a dependency management tool like Swift Package Manager or CocoaPods to handle third-party libraries properly.

5. Build Script Best Practices

When creating Titanium modules, always:

1. Explicitly specify architectures
2. Use proper SDK targets
3. Handle both simulator and device configurations
4. Include error handling in build scripts

Troubleshooting Checklist

Before attempting to build your module, verify these items:

• [ ] Your .xcframeworks contain both simulator and device slices
• [ ] Your Swift Packages are properly configured for iOS
• [ ] Your module’s module.xcconfig specifies correct architectures
• [ ] You’re using the latest compatible versions of Titanium SDK and Xcode
• [ ] Your build script explicitly targets device-only builds
• [ ] All dependencies are correctly linked to your module target
• [ ] You’ve tried building with the --target-device iphone flag

Conclusion

The Titanium iOS module build failure with simulator warnings occurs because the build process is attempting to include simulator slices when your dependencies only provide device slices. To resolve this issue:

1. Explicitly specify device-only builds using the --target-device iphone flag
2. Ensure your dependencies include proper architecture slices
3. Configure your module build settings for device-only architectures
4. Consider creating universal frameworks that include both simulator and device slices

By following these steps, you should be able to successfully build your Titanium iOS module with external dependencies, even when targeting physical devices. Remember that proper architecture configuration is essential when working with frameworks and packages in Titanium modules.