English | 简体中文

Welcome to the Ultralytics YOLO iOS App GitHub repository! 📖 This project transforms your iOS device into a powerful real-time inference tool for object detection, instance segmentation, semantic segmentation, classification, pose estimation, and oriented bounding box detection. The SDK supports both legacy YOLO11 (with Core ML NMS) and state-of-the-art YOLO26 models (NMS-free, with Swift-side postprocessing). Download the app directly from the App Store or explore our guide to integrate YOLO capabilities into your own Swift applications.

• Native iOS Performance — Maximum speed with Swift & Core ML
• Optimized for Apple Silicon — Leverages the Neural Engine & GPU
• Real-time Inference — 60+ FPS on recent iPhones
• Low Latency — Direct hardware access without framework overhead
• iOS-First Design — Native UI/UX following Apple guidelines
• Core ML Integration — Apple's optimized ML framework
• YOLO26 (NMS-free) and YOLO11 models both supported
• Zero Dependencies — Pure Swift on Apple's first-party frameworks only; no third-party packages

This repository provides a comprehensive solution for running YOLO models on Apple platforms, enabling powerful Edge AI capabilities:

The primary iOS application allows easy real-time YOLO inference using your device's camera or image library. The shipped app bundles all six official nano Core ML models, larger variants download on demand, and you can also test your custom Core ML models by adding them to the app project.

A lightweight Swift package designed for iOS and iPadOS. It simplifies the integration and usage of YOLO-based models like YOLO26 within your own applications. Integrate YOLO models effortlessly with minimal code using SwiftUI:

// Perform inference on a UIImage
let result = model(uiImage)

// Use the built-in camera view for real-time inference
var body: some View {
    YOLOCamera(
        url: URL(string: "https://github.com/ultralytics/yolo-ios-app/releases/download/v8.3.0/yolo26n-seg.mlpackage.zip")!,
        task: .segment,
        cameraPosition: .back
    )
    .ignoresSafeArea()
}

Official models are GitHub release assets, not large files committed to the repositories. The main iOS app downloads the six nano Core ML assets at build time and bundles them into the app; larger app models, Swift package examples, and Flutter package assets download official models on first use and cache them locally.

The main YOLOiOSApp bundles all six nano models (one per task: detect, segment, semantic, classify, pose, OBB) into the shipped app, including App Store/archive builds. They are downloaded at build time from the GitHub release assets by a Download YOLO Models Xcode build phase that runs scripts/download-models.sh — the .mlpackage files are never committed to the repo (*.mlpackage is gitignored). The step is idempotent and is skipped on GitHub Actions CI, which runs the same script in its own step.

URL patterns:

• Core ML: https://github.com/ultralytics/yolo-ios-app/releases/download/v8.3.0/<model>.mlpackage.zip
• TFLite: https://github.com/ultralytics/yolo-flutter-app/releases/download/v0.3.5/<model>.tflite

The iOS app registry is RemoteModels.swift. It enumerates YOLO26 n/s/m/l/x assets for detect, segment, semantic, classify, pose, and OBB and points each model ID at the v8.3.0 Core ML release. The Core ML column below is owned by this repo; the TFLite column summarizes the Flutter repo's Android export script and release assets.

Core ML assets use nms=False and end2end=True: nms=False suppresses the Core ML NMS pipeline, and end2end=True supplies the YOLO26 decoded output contract consumed by the Swift decoders. The TFLite export script passes both nms=False and end2end=False; end2end=False disables the YOLO26 end-to-end head for the Android LiteRT conversion path.

The authoritative export script is scripts/export-models.py. It defines the task/size matrix, export image sizes, int8 Core ML settings, .mlpackage.zip packaging, optional local app-copy step, and optional GitHub release upload.

uv venv --python 3.13 .venv
uv pip install -e "../ultralytics[export]"
uv run python scripts/export-models.py

Useful variants:

# Export only nano task models for local validation and copy them into YOLOiOSApp/Models/.
uv run python scripts/export-models.py --sizes n --copy-to-app

# Export all official Core ML assets and upload them to the canonical release.
uv run python scripts/export-models.py --upload --repo ultralytics/yolo-ios-app --tag v8.3.0

The script exports from checkpoints named yolo26<size><suffix>.pt, for example yolo26n.pt, yolo26s-seg.pt, yolo26m-sem.pt, yolo26l-pose.pt, and yolo26x-obb.pt. YOLO26 is NMS-free in this SDK, so official Core ML assets are exported with nms=False and end2end=True; Swift-side postprocessing handles detect, segment, pose, and OBB outputs.

The Android assets used by the Flutter package are maintained in the Flutter repo, not this iOS repo. Their canonical export script is scripts/export-tflite-models.py in ultralytics/yolo-flutter-app; it exports the matching YOLO26 task/size matrix as int8 .tflite assets calibrated with data=coco128.yaml and uploads them to yolo-flutter-app v0.3.5.

New to YOLO on mobile or want to quickly test your custom model? Start with the main YOLOiOSApp. The six nano task models are bundled at build time, so the app can run offline after installation; larger model sizes download on demand.

• Ultralytics YOLO iOS App (Main App): The easiest way to experience YOLO inference on iOS.

Ready to integrate YOLO into your own project? Explore the Swift Package and example applications.

• Swift Package (YOLO Library): Integrate YOLO capabilities into your Swift app.
• Example Apps: See practical implementations using the YOLO Swift Package.

Add the UltralyticsYOLO package to your app with Swift Package Manager:

.package(url: "https://github.com/ultralytics/yolo-ios-app.git", from: "8.9.0")

Or with CocoaPods:

pod 'UltralyticsYOLO', '~> 8.9'

Then import UltralyticsYOLO and use the YOLO class — see the Swift Package README for full usage. The same UltralyticsYOLO package powers both this native iOS app and the Ultralytics YOLO Flutter plugin, keeping one source of truth across platforms.

• Real-Time Inference: Achieve high-speed, high-accuracy object detection on iPhones and iPads using optimized Core ML models, potentially enhanced through techniques like model quantization. See docs/performance.md for on-device profiling and the camera/Core ML configuration rationale.
• Apple Mobile Support: The Swift Package targets iOS and iPadOS with native Core ML integration.
• Flexible Tasks: Supports object detection, instance segmentation, semantic segmentation, classification, pose estimation, and oriented bounding box (OBB) detection.

This repository includes comprehensive unit tests for both the YOLO Swift Package and the example applications, ensuring code reliability and stability.

Tests require Core ML model files (.mlpackage), which are not committed to the repository due to their size. To run the package tests with model validation, first run the same downloader used by CI and the app build phase:

bash scripts/download-models.sh

This downloads the six nano Core ML packages into Tests/YOLOTests/Resources/ and copies them into YOLOiOSApp/Models/<Task>/ for the main app bundle. You can also export or replace these packages with custom Core ML models using the Ultralytics Python library's export function. If a specific test target supports SKIP_MODEL_TESTS, keeping it set to true skips tests that require loading and running a model.

• YOLO Swift Package: Includes tests for core functionalities like model loading, preprocessing, inference, and postprocessing across different tasks.
• Example Apps: Contains tests verifying UI components, model integration, and real-time inference performance within the sample applications.

Each test directory (e.g., Tests/YOLOTests) may include a README.md with specific instructions for testing that component, covering:

• Required model files and where to obtain them.
• Steps for model conversion and setup.
• Overview of the testing strategy.
• Explanation of key test cases.

We warmly welcome contributions to our open-source projects! Your support helps us push the boundaries of Artificial Intelligence (AI). Get involved by reviewing our Contributing Guide and sharing your feedback through our Survey. Thank you 🙏 to all our contributors!

Ultralytics provides two licensing options to accommodate diverse use cases:

• AGPL-3.0 License: An OSI-approved open-source license ideal for academic research, personal projects, and experimentation. It promotes open collaboration and knowledge sharing. See the LICENSE file and the full AGPL-3.0 license text for details.
• Enterprise License: Tailored for commercial applications, this license allows the integration of Ultralytics software and AI models into commercial products and services without the open-source requirements of AGPL-3.0. If your scenario involves commercial use, please contact us via Ultralytics Licensing.

• For bug reports and feature requests related to this iOS project, please use GitHub Issues.
• For questions, discussions, and support regarding Ultralytics technologies, join our active Discord community!