Ultralytics YOLO27: Join the waitlist.
Get Started

Ultralytics Integrations#

This page lists the tools and platforms that Ultralytics integrates with to support your machine learning workflows, from dataset management and model training to experiment tracking and deployment.

Ultralytics YOLO ecosystem and integrations


Watch: Ultralytics YOLO Deployment and Integrations

Training Integrations#

  • Agent Skills: Teach AI coding agents like Claude Code, Codex, Cursor, and Gemini CLI the complete Ultralytics YOLO workflow with official skills covering datasets, training, inference, and export.

  • Albumentations: Apply additional image augmentations during Ultralytics training to improve model robustness and generalization.

  • Amazon SageMaker: Use Amazon SageMaker to build, train, and deploy Ultralytics models on one platform for the ML lifecycle.

  • ClearML: Automate your Ultralytics ML workflows, track experiments, and collaborate as a team.

  • Comet ML: Enhance your model development with Ultralytics by tracking, comparing, and optimizing your machine learning experiments.

  • DVC: Implement version control for your Ultralytics machine learning projects, synchronizing data, code, and models effectively.

  • Google Colab: Use Google Colab to train and evaluate Ultralytics models in a cloud-based environment that supports collaboration and sharing.

  • IBM Watsonx: Train and evaluate Ultralytics models in IBM watsonx.ai notebooks, alongside IBM tools for data management and model governance.

  • JupyterLab: Use JupyterLab's interactive, customizable environment to train and evaluate Ultralytics models.

  • Kaggle: Explore how you can use Kaggle to train and evaluate Ultralytics models in a cloud-based environment with pre-installed libraries, GPU support, and an active community for collaboration and sharing.

  • MLflow: Streamline the entire ML lifecycle of Ultralytics models, from experimentation and reproducibility to deployment.

  • Modal: Run Ultralytics models on Modal's serverless cloud platform with automatic GPU provisioning, pay-per-second pricing, and automatic scaling for inference and training workloads.

  • Paperspace Gradient: Use Paperspace Gradient cloud GPUs and notebooks to train, test, and deploy YOLO26 models.

  • Ray Tune: Run hyperparameter tuning for your Ultralytics models at any scale.

  • TensorBoard: Visualize your Ultralytics training runs and monitor model metrics.

  • Ultralytics Platform: Train, manage, and deploy Ultralytics models in the browser, and download official pretrained models and datasets.

  • VS Code: An extension for VS Code that provides code snippets to accelerate Ultralytics development workflows and offers examples to help anyone learn or get started.

  • Weights & Biases (W&B): Monitor experiments, visualize metrics, and foster reproducibility and collaboration on Ultralytics projects.

  • YAML2ModelGraph: Generate publication-ready SVG architecture diagrams directly from Ultralytics YOLO YAML configuration files.

Deployment Integrations#

  • Ambarella: Train, compress, and export Ultralytics YOLO models for Ambarella CVflow® SoCs such as the CV72 with Ambarella's Ultralytics fork, using SpongeTorch compression-aware training and the offline CVflow toolchain.

  • AMD: Export Ultralytics YOLO to ONNX and run GPU-accelerated inference on AMD Instinct and Radeon GPUs through the ONNX Runtime MIGraphX execution provider on ROCm, with native PyTorch ROCm training also supported.

  • AMD Xilinx: Export Ultralytics YOLO with format="xilinx" for AMD Versal AI Edge Series Gen 2 NPUs using AMD Quark and Vitis AI, with a guide to Zynq, Kria and Versal devices, DPU vs NPU accelerators and YOLO operator support.

  • Axelera: Explore Metis accelerators and the Voyager SDK for running Ultralytics models with efficient edge inference.

  • Core AI: Learn about Apple's new .aimodel format, how Core AI compares with Core ML, its current limitations, and how to export YOLO26 models with format="coreai" for the iOS 27 and macOS 27 generation.

  • CoreML: CoreML, developed by Apple, is a framework designed for efficiently integrating machine learning models into applications across iOS, macOS, watchOS, and tvOS, using Apple's hardware for effective and secure model deployment.

  • DEEPX: Export Ultralytics YOLO models to the DEEPX .dxnn format for power-efficient INT8 inference on DEEPX NPU hardware, targeting embedded and edge AI applications.

  • ExecuTorch: Developed by Meta, ExecuTorch is PyTorch's unified solution for deploying Ultralytics YOLO models on edge devices.

  • Gradio: Deploy Ultralytics models with Gradio for real-time, interactive object detection demos.

  • Hailo: Export Ultralytics YOLO detection, segmentation, semantic segmentation, depth estimation, classification, pose, and OBB models directly to Hailo HEF; see the integration guide for validated models and targets.

  • Huawei Ascend: Compile Ultralytics YOLO models to the Huawei Ascend .om offline format with the CANN ATC compiler for FP16 inference on Atlas and OrangePi AIPro devices.

  • LiteRT: Developed by Google, LiteRT (formerly TensorFlow Lite) is the on-device runtime for the .tflite format, deploying a single model across mobile, embedded, edge, and the browser (via LiteRT.js).

  • Luxonis OAK: Convert Ultralytics YOLO models with Luxonis Hub or local Luxonis tooling and run them on-device on Luxonis OAK RVC2 and RVC4 cameras.

  • MNN: Developed by Alibaba, MNN is a lightweight deep learning framework for on-device inference and training on mobile and embedded hardware.

  • NCNN: Developed by Tencent, NCNN is a neural network inference framework optimized for mobile devices. It runs AI models directly inside apps across various mobile platforms.

  • Neural Magic: Historical guide to sparse CPU inference with the DeepSparse engine, whose community libraries are deprecated.

  • ONNX: An open-source format originally developed by Microsoft and Facebook for transferring AI models between frameworks, making Ultralytics models portable across runtimes and hardware.

  • OpenVINO: Intel's toolkit for optimizing and deploying computer vision models on Intel CPUs, GPUs, and NPUs.

  • PaddlePaddle: An open-source deep learning platform by Baidu, PaddlePaddle supports AI model deployment with a focus on scalable industrial applications.

  • Qualcomm QNN: Compile Ultralytics YOLO models locally into the QNN (AI Engine Direct) context-binary format with the ONNX Runtime QNN Execution Provider for accelerated inference on Snapdragon CPU, Adreno GPU, and Hexagon NPU hardware in mobile and edge devices.

  • Rockchip RKNN: Developed by Rockchip, RKNN is a neural network inference framework optimized for Rockchip's hardware platforms, particularly their NPUs, for real-time AI inference on edge devices.

  • Seeed Studio reCamera: Developed by Seeed Studio, the reCamera is an edge AI device for real-time computer vision applications. Powered by the RISC-V-based SG200X processor, it runs energy-efficient AI inference, and its modular design and video processing capabilities suit use cases such as safety monitoring, environmental applications, and manufacturing.

  • SONY IMX500: Optimize and deploy Ultralytics YOLOv8n and YOLO11n models on Raspberry Pi AI Cameras with the IMX500 sensor for fast, low-power performance.

  • TensorRT: Developed by NVIDIA, this high-performance deep learning inference framework and model format optimizes AI models for speed and efficiency on NVIDIA GPUs.

  • TF GraphDef: Developed by Google, GraphDef is TensorFlow's format for representing computation graphs, enabling optimized execution of machine learning models across diverse hardware.

  • TF SavedModel: Developed by Google, TF SavedModel is a serialization format for TensorFlow models, enabling sharing and deployment across a wide range of platforms, from servers to edge devices.

  • TFLite Edge TPU: Developed by Google for optimizing TensorFlow Lite models on Edge TPUs, this model format enables fast, efficient edge computing.

  • TorchScript: Developed as part of the PyTorch framework, TorchScript enables efficient execution and deployment of machine learning models in various production environments without the need for Python dependencies.

Datasets Integrations#

  • Roboflow: Facilitate dataset labeling and management for Ultralytics models, offering annotation tools to label images.

Export Formats#

We also support a variety of model export formats for deployment in different environments. Here are the available formats:

Formatformat ArgumentModelMetadataArguments
PyTorch-yolo26n.pt✅-
TorchScripttorchscriptyolo26n.torchscript✅imgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n.onnx✅imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n_openvino_model/✅imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n.engine✅imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n.mlpackage✅imgsz, dynamic, quantize, nms, batch, device
Apple Core AIcoreaiyolo26n.aimodel✅imgsz, batch, quantize
TF SavedModelsaved_modelyolo26n_saved_model/✅imgsz, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n.pb❌imgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n_edgetpu.tflite✅imgsz, quantize, opset, data, fraction, device
LiteRTlitertyolo26n.tflite✅imgsz, quantize, batch, data, fraction, device
PaddlePaddlepaddleyolo26n_paddle_model/✅imgsz, batch, device
MNNmnnyolo26n.mnn✅imgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n_ncnn_model/✅imgsz, quantize, batch, device
IMX500imxyolo11n_imx_model/✅imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n_rknn_model/✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n_executorch_model/✅imgsz, batch, device
Axeleraaxelerayolo26n_axelera_model/✅imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n_deepx_model/✅imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n_qnn.onnx✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
Hailohailoyolo26n_hailo_model/✅imgsz, name, quantize, data, fraction, simplify, conf, iou, device
Huawei Ascendascendyolo26n_ascend_model/✅imgsz, batch, name, quantize, opset, simplify, nms, device
AMD Xilinxxilinxyolo26n_xilinx_model/✅imgsz, name, quantize, data, fraction, opset, simplify, device

nms=None defaults to raw outputs for external NMS (YOLO26 keeps its NMS-free head on Axelera). Set nms=False to select an available NMS-free head; unsupported formats fall back to their native output path. The nms entries above identify formats that can embed NMS with nms=True.

Explore the links to learn more about each integration and how to get the most out of them with Ultralytics. See full export details in the Export page.

Contribute to Our Integrations#

We welcome community guides on integrating Ultralytics YOLO with other technologies, tools, and platforms. If you have successfully integrated YOLO with a new system or have valuable insights to share, consider contributing to our Integrations Docs.

By writing a guide or tutorial, you can help expand our documentation and provide real-world examples that benefit the community.

To contribute, follow the instructions in our contributing guide on how to submit a Pull Request (PR).

FAQ#

  • Ultralytics Platform is a cloud-based platform for end-to-end machine learning workflows with Ultralytics models. You can upload and annotate datasets, train models on cloud GPUs, track experiments, and deploy YOLO models without extensive coding. The platform serves as a centralized workspace for your entire ML pipeline, from data preparation to deployment.

  • Yes, you can. Integrating MLflow with Ultralytics models allows you to track experiments, improve reproducibility, and streamline the entire ML lifecycle. Detailed instructions for setting up this integration can be found on the MLflow integration page. This integration is particularly useful for monitoring model metrics, comparing different training runs, and managing the ML workflow efficiently. MLflow provides a centralized platform to log parameters, metrics, and artifacts, making it easier to understand model behavior and make data-driven improvements.

  • To deploy Ultralytics YOLO models with Gradio for interactive object detection demos, you can follow the steps outlined on the Gradio integration page. Gradio creates web interfaces for real-time model inference, which makes it useful for showcasing your YOLO model to both developers and end users. With a few lines of code, you can build interactive applications that demonstrate your model's performance on custom inputs.

Comments