Ultralytics YOLO26

Overview

Ultralytics YOLO26 is the latest evolution in the YOLO series of real-time object detectors, engineered from the ground up for edge and low-power devices. It introduces a streamlined design that removes unnecessary complexity while integrating targeted innovations to deliver faster, lighter, and more accessible deployment.

The architecture of YOLO26 is guided by three core principles:

• Simplicity: YOLO26 is a native end-to-end model, producing predictions directly without the need for non-maximum suppression (NMS). By eliminating this post-processing step, inference becomes faster, lighter, and easier to deploy in real-world systems. This breakthrough approach was first pioneered in YOLOv10 by Ao Wang at Tsinghua University and has been further advanced in YOLO26.
• Deployment Efficiency: The end-to-end design cuts out an entire stage of the pipeline, dramatically simplifying integration, reducing latency, and making deployment more robust across diverse environments.
• Training Innovation: YOLO26 introduces the MuSGD optimizer, a hybrid of SGD and Muon — inspired by Moonshot AI's Kimi K2 breakthroughs in LLM training. This optimizer brings enhanced stability and faster convergence, transferring optimization advances from language models into computer vision.
• Task-Specific Optimizations: YOLO26 introduces targeted improvements for specialized tasks, including semantic segmentation loss and multi-scale proto modules for Segmentation, Residual Log-Likelihood Estimation (RLE) for high-precision Pose estimation, and optimized decoding with angle loss to resolve boundary issues in OBB.

Together, these innovations deliver a model family that achieves higher accuracy on small objects, provides seamless deployment, and runs up to 43% faster on CPUs — making YOLO26 one of the most practical and deployable YOLO models to date for resource-constrained environments.

Key Features

• DFL Removal
  The Distribution Focal Loss (DFL) module, while effective, often complicated export and limited hardware compatibility. YOLO26 removes DFL entirely, simplifying inference and broadening support for edge and low-power devices.

• End-to-End NMS-Free Inference
  Unlike traditional detectors that rely on NMS as a separate post-processing step, YOLO26 is natively end-to-end. Predictions are generated directly, reducing latency and making integration into production systems faster, lighter, and more reliable.

• ProgLoss + STAL
  Improved loss functions increase detection accuracy, with notable improvements in small-object recognition, a critical requirement for IoT, robotics, aerial imagery, and other edge applications.

• MuSGD Optimizer
  A new hybrid optimizer that combines SGD with Muon. Inspired by Moonshot AI's Kimi K2, MuSGD introduces advanced optimization methods from LLM training into computer vision, enabling more stable training and faster convergence.

• Up to 43% Faster CPU Inference
  Specifically optimized for edge computing, YOLO26 delivers significantly faster CPU inference, ensuring real-time performance on devices without GPUs.

• Instance Segmentation Enhancements
  Introduces semantic segmentation loss to improve model convergence and an upgraded proto module that leverages multi-scale information for superior mask quality.

• Precision Pose Estimation
  Integrates Residual Log-Likelihood Estimation (RLE) for more accurate keypoint localization and optimizes the decoding process for increased inference speed.

• Refined OBB Decoding
  Introduces a specialized angle loss to improve detection accuracy for square-shaped objects and optimizes OBB decoding to resolve boundary discontinuity issues.

Supported Tasks and Modes

YOLO26 builds upon the versatile model range established by earlier Ultralytics YOLO releases, offering enhanced support across various computer vision tasks:

This unified framework ensures YOLO26 is applicable across real-time detection, segmentation, classification, pose estimation, and oriented object detection — all with training, validation, inference, and export support.

Performance Metrics

Usage Examples

This section provides simple YOLO26 training and inference examples. For full documentation on these and other modes, see the Predict, Train, Val, and Export docs pages.

Note that the example below is for YOLO26 Detect models for object detection. For additional supported tasks, see the Segment, Classify, OBB, and Pose docs.

from ultralytics import YOLO

# Load a COCO-pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

# Run inference with the YOLO26n model on the 'bus.jpg' image
results = model("path/to/bus.jpg")

# Load a COCO-pretrained YOLO26n model and train it on the COCO8 example dataset for 100 epochs
yolo train model=yolo26n.pt data=coco8.yaml epochs=100 imgsz=640

# Load a COCO-pretrained YOLO26n model and run inference on the 'bus.jpg' image
yolo predict model=yolo26n.pt source=path/to/bus.jpg

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Use one-to-one head (default, no NMS required)
results = model.predict("image.jpg")  # inference
metrics = model.val(data="coco.yaml")  # validation
model.export(format="onnx")  # export

# Use one-to-many head (requires NMS)
results = model.predict("image.jpg", end2end=False)  # inference
metrics = model.val(data="coco.yaml", end2end=False)  # validation
model.export(format="onnx", end2end=False)  # export

# Use one-to-one head (default, no NMS required)
yolo predict model=yolo26n.pt source=image.jpg
yolo val model=yolo26n.pt data=coco.yaml
yolo export model=yolo26n.pt format=onnx

# Use one-to-many head (requires NMS)
yolo predict model=yolo26n.pt source=image.jpg end2end=False
yolo val model=yolo26n.pt data=coco.yaml end2end=False
yolo export model=yolo26n.pt format=onnx end2end=False

YOLOE-26: Open-Vocabulary Instance Segmentation

YOLOE-26 integrates the high-performance YOLO26 architecture with the open-vocabulary capabilities of the YOLOE series. It enables real-time detection and segmentation of any object class using text prompts, visual prompts, or a prompt-free mode for zero-shot inference, effectively removing the constraints of fixed-category training.

By leveraging YOLO26's NMS-free, end-to-end design, YOLOE-26 delivers fast open-world inference. This makes it a powerful solution for edge applications in dynamic environments where the objects of interest represent a broad and evolving vocabulary.

Usage Example

YOLOE-26 supports both text-based and visual prompting. Using prompts is straightforward—just pass them through the predict method as shown below:

from ultralytics import YOLO

# Initialize model
model = YOLO("yoloe-26l-seg.pt")  # or select yoloe-26s/m-seg.pt for different sizes

# Set text prompt to detect person and bus. You only need to do this once after you load the model.
names = ["person", "bus"]
model.set_classes(names, model.get_text_pe(names))

# Run detection on the given image
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

import numpy as np

from ultralytics import YOLO
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

# Initialize model
model = YOLO("yoloe-26l-seg.pt")

# Define visual prompts using bounding boxes and their corresponding class IDs.
# Each box highlights an example of the object you want the model to detect.
visual_prompts = dict(
    bboxes=np.array(
        [
            [221.52, 405.8, 344.98, 857.54],  # Box enclosing person
            [120, 425, 160, 445],  # Box enclosing glasses
        ],
    ),
    cls=np.array(
        [
            0,  # ID to be assigned for person
            1,  # ID to be assigned for glasses
        ]
    ),
)

# Run inference on an image, using the provided visual prompts as guidance
results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)

# Show results
results[0].show()

from ultralytics import YOLO

# Initialize model
model = YOLO("yoloe-26l-seg-pf.pt")

# Run prediction. No prompts required.
results = model.predict("path/to/image.jpg")

# Show results
results[0].show()

For a deep dive into prompting techniques, training from scratch, and full usage examples, visit the YOLOE Documentation.

Citations and Acknowledgments

If you use YOLO26 or other Ultralytics software in your work, please cite it as:

@software{yolo26_ultralytics,
  author = {Glenn Jocher and Jing Qiu},
  title = {Ultralytics YOLO26},
  version = {26.0.0},
  year = {2026},
  url = {https://github.com/ultralytics/ultralytics},
  orcid = {0000-0001-5950-6979, 0000-0003-3783-7069},
  license = {AGPL-3.0}
}

DOI pending. YOLO26 is available under AGPL-3.0 and Enterprise licenses.

FAQ

What are the key improvements in YOLO26 compared to YOLO11?

• DFL Removal: Simplifies export and expands edge compatibility
• End-to-End NMS-Free Inference: Eliminates NMS for faster, simpler deployment
• ProgLoss + STAL: Boosts accuracy, especially on small objects
• MuSGD Optimizer: Combines SGD and Muon (inspired by Moonshot's Kimi K2) for more stable, efficient training
• Up to 43% Faster CPU Inference: Major performance gains for CPU-only devices

What tasks does YOLO26 support?

YOLO26 is a unified model family, providing end-to-end support for multiple computer vision tasks:

• Object Detection
• Instance Segmentation
• Image Classification
• Pose Estimation
• Oriented Object Detection (OBB)

Each size variant (n, s, m, l, x) supports all tasks, plus open-vocabulary versions via YOLOE-26.

Why is YOLO26 optimized for edge deployment?

YOLO26 delivers state-of-the-art edge performance with:

• Up to 43% faster CPU inference
• Reduced model size and memory footprint
• Architecture simplified for compatibility (no DFL, no NMS)
• Flexible export formats including TensorRT, ONNX, CoreML, TFLite, and OpenVINO

How do I get started with YOLO26?

YOLO26 models were released on January 14, 2026, and are available for download. Install or update the ultralytics package and load a model:

from ultralytics import YOLO

# Load a pretrained YOLO26 nano model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("image.jpg")

See the Usage Examples section for training, validation, and export instructions.

📅 Created 4 months ago ✏️ Updated 5 days ago

Comments