YOLO26 is Here: Finally Killed NMS

Ultralytics released YOLO26 this week, marking the most important architectural innovation in the nine-year development of the YOLO series. The core change can be summed up in one sentence: native NMS-free end-to-end inference.

What does this mean? From now on, the YOLO inference pipeline no longer needs that headache-inducing post-processing step.

Why NMS Deserves to Die

Non-Maximum Suppression (NMS) has always been the "dirty work" in the object detection pipeline. The model outputs a bunch of overlapping candidate boxes, and NMS filters out the redundant ones, keeping only the one with the highest confidence.

Sounds simple, but deployment is full of issues:

• Uncontrollable latency: The more objects, the longer NMS takes. An image with 10 objects vs. 100 objects can differ significantly in inference time.
• Deployment fragmentation: The main model can run on TensorRT, ONNX, OpenVINO, but NMS often needs to be implemented separately on the CPU, breaking the pipeline.
• Nightmare on edge devices: On compute-limited embedded platforms, NMS often becomes the bottleneck.

In the past few years, academia has tried to eliminate NMS. DETR uses a Transformer for set prediction but is too slow; RT-DETR is faster, but still lags YOLO in latency.

YOLO26 took a different approach—it didn’t change the overall architecture, but solved the problem within the YOLO framework.

Dual Detection Heads: One for Training, One for Inference

The core design of YOLO26 is a dual detection head architecture.

During training, it uses an "auxiliary head"—complex structure, dense outputs, allowing the model to learn richer feature representations. During inference, it switches to the "main head"—lighter structure, outputs are final results directly, no NMS post-processing.

The cleverness here is trading training complexity for inference simplicity. The auxiliary head is discarded after training, so it doesn’t affect deployment size or speed.

Technically, YOLO26 also completely removed the DFL (Distribution Focal Loss) module. DFL was introduced in YOLOv8 for bounding box regression, improving accuracy but adding computational overhead and bounding range constraints. YOLO26 replaces it with a new regression method, reducing parameters and removing range restrictions.

MuSGD: Borrowed from LLM Training

With the new architecture comes a change in training methods.

YOLO26 uses a new optimizer called MuSGD, short for "Hybrid Muon-SGD." The inspiration comes from large language model training—Muon is a recently effective optimizer for LLMs, and YOLO26 blends it with traditional SGD.

Why borrow LLM training techniques? Because modern vision models are getting larger, and training stability and convergence speed are increasingly important. MuSGD performs more stably in large-scale training, especially for large models like YOLO26-x.

According to the paper, MuSGD uses Muon in early training to accelerate convergence, then switches to SGD later for stability. This staged strategy is common in LLM training and now ported to vision models.

Five Model Sizes, Full Benchmark Refresh

Like earlier YOLO versions, YOLO26 offers five sizes: n/s/m/l/x, covering ultra-lightweight to high-accuracy needs.

According to Ultralytics, YOLO26 refreshes the accuracy-latency Pareto frontier at all sizes. In other words, at the same inference speed, mAP is higher; at the same mAP, inference is faster.

| Model | Parameters | COCO mAP | Latency | Scenario | |----------|------------|----------|-----------|----------| | YOLO26-n | Minimum | Baseline | <1ms | Edge devices, ultra real-time | | YOLO26-s | Small | +2-3% | ~1ms | Mobile, embedded devices | | YOLO26-m | Medium | +5-6% | ~2ms | General use, balanced | | YOLO26-l | Large | +7-8% | ~3ms | High accuracy needs | | YOLO26-x | Maximum | Highest | ~5ms | Accuracy priority, ample compute |

Note: Actual figures per official paper. Table shows relative improvement.

Importantly, these latency numbers are end-to-end—from image input to detection output, no extra NMS time. This is the true value of NMS-free design: predictable, guaranteed latency.

Unified Deployment: Export Once, Run Anywhere

For developers, another big improvement is unified deployment.

Without NMS, YOLO26 can be exported as a complete inference graph. Whether ONNX, TensorRT, OpenVINO or CoreML, the exported model is a full detector, with no hand-written NMS logic in inference code.

This is a game changer for edge deployment. Previously, YOLO’s model ran on NPU, NMS ran on CPU, requiring data transfers and increasing latency. Now, the whole pipeline runs entirely on the accelerator, data stays on chip.

Ultralytics’ docs have updated YOLO26’s export guide:

from ultralytics import YOLO

# Load YOLO26 model
model = YOLO("yolo26m.pt")

# Export to ONNX (end-to-end, no NMS)
model.export(format="onnx")

# Export to TensorRT (auto optimization)
model.export(format="engine")

# Export to OpenVINO (Intel hardware optimization)
model.export(format="openvino")

Exported model I/O is standardized: input is preprocessed image tensor, output is [x, y, w, h, class_id, confidence] detection results. No middle steps, no post-processing dependencies.

Training API: Almost Zero Changes

If you’ve used YOLOv8 or YOLO11, migrating to YOLO26 requires virtually no code changes.

from ultralytics import YOLO

# Load pretrained model
model = YOLO("yolo26m.pt")

# Train on custom dataset
model.train(
    data="path/to/dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=16
)

# Validate
metrics = model.val()

# Inference
results = model.predict("image.jpg")

Training configs, data formats, callbacks remain compatible. Ultralytics’s philosophy is “stable API, iterative implementation,” and YOLO26 continues that tradition.

New config options mainly relate to dual detection heads. If you want to adjust auxiliary head weights or distillation parameters, you can use new fields. For most users, defaults suffice.

Built-in Distillation: Compress Large Model to Small

In addition to the main model, Ultralytics added built-in distillation to YOLO26.

Knowledge distillation means using a large model (teacher) to guide training of a small model (student) so the latter retains speed while gaining accuracy. Previously, distillation required custom scripts; now YOLO26 integrates it into standard training.

from ultralytics import YOLO

# Load large teacher model
teacher = YOLO("yolo26x.pt")

# Load small student model
student = YOLO("yolo26n.pt")

# Distillation training
student.train(
    data="dataset.yaml",
    epochs=100,
    teacher=teacher,  # specify teacher model
    distill=True
)

This is practical for edge scenarios: you can achieve top accuracy with YOLO26-x on server, then distill to YOLO26-n for edge deployment, keeping performance close to the large model.

Comparison with RT-DETR

Before YOLO26, we must mention RT-DETR—another mainstream end-to-end real-time detector with NMS-free design.

RT-DETR is based on DETR architecture improvements, using a Transformer for detection head. It excels with large objects and occlusion, but isn’t great for small objects, and Transformer computation may be hardware-unfriendly.

YOLO26 takes a different path. It retains YOLO’s convolution backbone and FPN structure, modifying only the detection head for end-to-end. Pros:

1. Small-object friendly: FPN’s multi-scale feature maps suit small-object detection.
2. Hardware compatibility: Pure convolution ops run on any CNN-compatible accelerator.
3. Low migration cost: Upgrading from YOLOv8/YOLO11 requires almost no code changes.

RT-DETR still has advantages in some scenarios. If your task is mainly large objects and small-object detection is less important, RT-DETR may be more suitable. But for most generic detection tasks, YOLO26 should perform better overall.

Roadmap: 3D Perception and VLM Integration

Ultralytics’ roadmap reveals YOLO’s next steps.

YOLO-3D is their 3D perception version, expected at YOLO Vision 2026 conference. This extends detection to three-dimensional space, valuable for autonomous driving and robotics.

Another direction is YOLO-VLM, integrating YOLO as a vision frontend with LLMs. The idea: YOLO does rapid scene understanding and object localization, then passes structured info to the LLM for high-level reasoning, combining YOLO’s speed with LLM’s comprehension.

Also interesting is LLM-driven training analysis—LLM automatically diagnosing training issues and suggesting config optimizations. For example, detect loss oscillation, recommend lowering learning rate; see low AP for small objects, suggest increasing augmentation. This "AI tuning assistant" concept is novel.

Should You Upgrade?

If you’re using YOLOv8 or YOLO11, should you upgrade to YOLO26?

Recommended upgrade scenarios:

• Edge deployment with high latency stability requirements
• Need to export complete end-to-end model, no NMS logic in inference code
• Pursue latest accuracy-speed balance
• Plan to compress model via distillation

Wait-and-see scenarios:

• Current solution is stable, no obvious pain points
• Dependent third-party toolchain not yet adapted for YOLO26
• Concerned about new version stability (wait for minor updates)

Ultralytics’ advice: for new projects, use YOLO26; for stable production workloads, YOLO26 or YOLO11 are both good choices.

Installation & Quick Start

# Install latest ultralytics
pip install -U ultralytics

# Download pretrained model and test
yolo detect predict model=yolo26m.pt source=image.jpg

Or via Python API:

from ultralytics import YOLO

# Load model
model = YOLO("yolo26m.pt")

# Inference
results = model("image.jpg")

# Show results
results[0].show()

The model downloads automatically. First run may take minutes, depending on network.

Final Words

From YOLO v1 in 2016 to YOLO26 today, nine years of iteration. The core pursuit remains: faster, more accurate, easier deployment.

YOLO26’s NMS-free design solves an engineering problem that’s plagued the community for years. It may not feel as exciting as architectural revolutions, but for developers dealing with deployment daily, this is the truly valuable improvement.

The paper is on arXiv, code integrated into the ultralytics library—try it out if interested.

---

References

• Ultralytics YOLO26: Next-gen real-time vision model designed for edge computing - Zhihu – detailed technical and edge deployment analysis