YOLO26 vs YOLO11 vs YOLOv8: which YOLO should you use?

"Which YOLO should I use?" is the question I get most, usually as a matchup: YOLO26 vs YOLOv8, or YOLO26 vs YOLO11. This post puts all three side by side with the numbers their makers actually published, explains what changed between them in plain words, compares speed on CPU and GPU, and gives you a straight answer for common situations.

No re-run benchmarks and no hype: every accuracy number below is COCO val2017 mAP50-95 at 640px as published by Ultralytics, the same figures on the model weights pages. Where I quote speed numbers, they come from Ultralytics' own tables and I say which hardware they were measured on.

First, the hard words in plain English

This post uses a few technical terms. Here is what each one means, so the rest reads easily. Skip ahead if you already know them.

• YOLO: "You Only Look Once", a family of models that find objects in an image in a single, fast pass.
• Object detection: finding objects in a picture and drawing a box around each one.
• mAP (mean Average Precision): one score, from 0 to about 60 here, for how accurate a detector is. Higher is better.
• COCO: a big, standard image dataset everyone tests on, so different models can be compared fairly.
• Parameters: the numbers a model learns during training. More parameters usually means a bigger, slower, more accurate model.
• FLOPs: roughly how much math the model does per image. More FLOPs means slower.
• Inference: running the trained model to get predictions (the opposite of training it).
• Latency: how long one image takes to process. Lower is better.
• FPS (frames per second): how many images or video frames the model handles each second. Higher is better.
• CPU / GPU: a CPU is a normal processor; a GPU is a graphics card that runs AI models much faster.
• Edge device: a small, low-power computer like a phone, a Raspberry Pi, or a smart camera, instead of a big server.
• Anchor-free: a newer design that predicts boxes directly, instead of adjusting from a set of preset box shapes called "anchors". Fewer settings to tune.
• Backbone, neck, head: the three parts of the model: the backbone reads the image, the neck mixes the features together, and the head outputs the boxes.
• NMS (non-maximum suppression): a clean-up step that deletes duplicate, overlapping boxes so each object keeps just one.
• NMS-free / end-to-end: the model outputs final boxes directly, with no separate clean-up step. Faster and simpler.
• DFL (Distribution Focal Loss): a training trick older YOLOs used to place boxes more precisely. YOLO26 drops it to keep the model simple.
• Checkpoint / weights (.pt file): the saved, trained model you download and load.
• ONNX / TensorRT / TFLite / OpenVINO: formats and tools you convert a model into so it runs fast on different hardware.
• Quantization (INT8 / FP16): shrinking a model to use smaller numbers so it runs faster and lighter, usually with little accuracy lost.
• Segmentation: outlining an object's exact shape, not just a box around it.
• Pose estimation: finding body keypoints (joints) like elbows, shoulders and knees.
• OBB (oriented bounding box): a box that can tilt, for angled objects such as aerial photos or text.
• AGPL-3.0: a free, open-source license. Free for open-source projects, research and learning; closed-source commercial use is covered by an Ultralytics Enterprise license.

What these models do

All three take one image and return boxes around the objects in it, each with a label ("person", "car") and a confidence score. They can also do more than boxes: outline exact shapes (segmentation), find body joints (pose), and handle tilted boxes (OBB). Same idea, three generations, getting faster and more accurate each time.

They are also built the same way, in three parts: a backbone that reads the image, a neck that mixes the features together, and a head that draws the boxes. Loading any of them is one line of code (from ultralytics import YOLO). What changed between versions is what happens inside those parts, and, in YOLO26, what happens after the head.

The short version

• YOLOv8 (2023): the anchor-free workhorse that made multi-task YOLO mainstream. Biggest ecosystem, most tutorials, most transfer-learning checkpoints in the wild. Trails the newer two on accuracy-per-parameter.
• YOLO11 (2024): the safe all-round default. Matches YOLOv8 accuracy with fewer parameters, supports all five tasks, and has enough real-world mileage to trust in production.
• YOLO26 (2026): the newest and most accurate here, and the first of the three that is NMS-free and end-to-end, which makes it faster on CPU and edge and simpler to export.

Published accuracy and size, per variant

All numbers are COCO val2017 mAP50-95 at 640px (higher is better), with parameters in millions.

Variant	YOLOv8 mAP	YOLO11 mAP	YOLO26 mAP	YOLOv8 params	YOLO11 params	YOLO26 params
n (nano)	37.3	39.5	40.9	3.2M	2.6M	2.4M
s (small)	44.9	47.0	48.6	11.2M	9.4M	9.5M
m (medium)	50.2	51.5	53.1	25.9M	20.1M	20.4M
l (large)	52.9	53.4	55.0	43.7M	25.3M	24.8M
x (extra)	53.9	54.7	57.5	68.2M	56.9M	55.7M

Two things jump out:

1. Accuracy climbs with each generation at every size. YOLO26 leads its row in all five tiers, and the gap is widest at the large end (YOLO26x is +3.6 mAP over YOLOv8x).
2. The parameter count fell hard between YOLOv8 and YOLO11, then held. YOLO11l reaches higher accuracy than YOLOv8l with almost half the parameters (25.3M vs 43.7M). That efficiency jump is the headline reason to leave YOLOv8 behind for new work.

How each generation is built

The numbers above are the result. Here is why they moved. Each version changed a specific part of the network.

YOLOv8 (2023): the anchor-free baseline

YOLOv8 made two changes that everything since builds on. It went anchor-free: it predicts box centers directly, instead of adjusting from a grid of preset "anchor" box shapes. That meant far fewer settings to tune. It also used a decoupled head, giving the "what is it" and "where is it" jobs their own branches so each does its task better. Its backbone is built from C2f blocks, a design that helps the model learn better than YOLOv5's older C3 block. This is the version that made one YOLO cover detection, segmentation, pose, classification and OBB.

YOLO11 (2024): same idea, more efficient

YOLO11 kept the anchor-free, multi-task design and tightened the internals:

• C3k2 blocks replace YOLOv8's C2f in the backbone and neck. C3k2 uses two smaller convolutions instead of one large one, which is cheaper to compute while keeping accuracy. This is where the big parameter drop comes from.
• C2PSA module adds a light "attention" step near the end of the backbone. Attention lets the model focus on the important parts of the image, which helps it hold onto small and partly-hidden objects, exactly where accuracy is won or lost.
• An optimized feature-pyramid neck fuses multi-scale features more effectively.

The payoff is the efficiency you saw in the table: YOLO11m matches YOLOv8m accuracy with roughly 22% fewer parameters.

YOLO26 (2026): the head and the post-processing change

YOLO26 keeps YOLO11's efficient backbone but changes the end of the pipeline, and that is the part that matters most when you deploy the model.

The change that matters most: YOLO26 is NMS-free

For years every YOLO produced a pile of overlapping candidate boxes and then ran non-maximum suppression (NMS) to filter them down to one box per object. NMS works, but it is a separate post-processing step that runs on the CPU, adds latency, and is awkward to export to formats like ONNX and TensorRT.

YOLO26 drops it. Its head is trained to output the final boxes directly, so there is no clean-up step at the end. At the same time it removes Distribution Focal Loss (DFL) from the box part of the head. DFL helped older YOLOs place boxes precisely, but it adds an extra step that small devices run slowly. Taking it out makes the model simpler to convert and deploy. Together, these two removals mean:

• Faster CPU and edge inference, where NMS was a real slice of the per-frame budget. Ultralytics reports up to 43% faster CPU ONNX inference for YOLO26n versus YOLO11n (measured on an Intel Xeon at 2.00 GHz).
• Cleaner exports and easier shrinking. With no NMS and no DFL, the model converts to ONNX, TensorRT, CoreML, TFLite and OpenVINO more cleanly, which makes the smaller, faster INT8 and FP16 versions easier to build with little accuracy lost.
• Simpler, more predictable timing. The biggest gains show up when processing one image at a time, the usual case for live video and edge devices, where the old clean-up step used to eat a large share of the time.

YOLOv8 and YOLO11 still use NMS. If most of your deployment is CPU or embedded, this single difference is often worth more than the couple of mAP points. If you want to see it on your own footage rather than trust a generic claim, I built a harness for exactly this in YOLO26 vs YOLO11: real-time ONNX FPS benchmark.

What's new in YOLO26's training (not just its architecture)

Some of YOLO26's gains come from how it is trained, not from the network shape, which is why it can be more accurate and smaller at the same time:

• ProgLoss (Progressive Loss Balancing). During training, the model gradually shifts its focus toward what matters most when the model is actually used. This makes training steadier and lifts accuracy, and it costs nothing extra at run time.
• STAL (Small-Target-Aware Label assignment). A smarter way of teaching the model about small, hard-to-see objects, the tiny, faraway ones that usually drag scores down. It is a big reason YOLO26 improves most on the difficult cases.
• MuSGD optimizer. The "optimizer" is the method that adjusts the model during training. YOLO26 uses a new one that borrows ideas from how large language models are trained, so training is more stable.

None of these change the final model you download. They only happen during training, so you get the benefit for free when you use the pretrained weights or fine-tune your own.

Speed: CPU and GPU

Accuracy is only half the decision; here is how the three behave at runtime.

• On CPU (ONNX Runtime) YOLO26 is the clear leader, because removing NMS + DFL cuts the post-processing that dominates CPU latency at batch size 1. This is the deployment where the generation gap is largest.
• On GPU (TensorRT) all three are fast enough that the differences shrink to a few milliseconds. Ultralytics lists YOLO26 at roughly 1.7 ms (nano) to 11.8 ms (x) per image on an NVIDIA T4 with TensorRT, comfortably real-time across the ladder.
• Memory: YOLO26 also reports lower GPU memory use in both training and inference, which helps on smaller cards and embedded GPUs.

The practical takeaway: pick your model by CPU speed if you deploy on CPU or edge (YOLO26 wins clearly there), and by accuracy if you deploy on GPU (where all three are fast and YOLO26 still leads on mAP).

Beyond detection: segmentation, pose and OBB

All three are multi-task, but YOLO26's gains are not limited to detection. Against YOLO11, Ultralytics reports YOLO26 improving instance segmentation (up to +2.5 box AP / +3.7 mask AP), pose estimation (up to +7.2 AP), and oriented bounding boxes (up to +3.4 mAP). If your project is segmentation or pose rather than plain detection, that pose gain in particular is a strong reason to reach for YOLO26.

Tasks and ecosystem

All three are multi-task and anchor-free. YOLOv8, YOLO11 and YOLO26 each cover detection, segmentation, classification, pose and oriented bounding boxes (OBB) from one architecture. Where they differ is maturity:

• YOLOv8 has the deepest bench of tutorials, third-party integrations, and pretrained community weights. If you are searching for "how do I do X with YOLO," the answer was probably written against YOLOv8.
• YOLO11 inherited almost all of that tooling and is now the default in most Ultralytics docs.
• YOLO26 is the newest, so expect fewer third-party guides for a while, even though the API is the same from ultralytics import YOLO.

Licensing (read this before you ship)

All three are AGPL-3.0, and for most people that is good news: they are completely free to use, study, modify and share for open-source projects, research, learning and evaluation. If your own project is open-source, you are already covered.

For a closed-source commercial product or a paid service, Ultralytics offers an Enterprise license that removes the open-source requirement. It is a simple, officially supported path that also comes with commercial support and priority updates, and it helps fund the continued development of these models. Because the terms are identical across YOLOv8, YOLO11 and YOLO26, you can choose purely on accuracy and speed and know the licensing story is the same either way.

So which one should you use?

• Starting a new project? Use YOLO11n or YOLO26n. Both are small, fast and accurate. Go YOLO11 for maximum stability and community support; go YOLO26 for the best accuracy and NMS-free export.
• Deploying on CPU, mobile or embedded? Prefer YOLO26 for its NMS-free speed, then confirm with a real FPS test on your target device.
• Chasing the top accuracy number? YOLO26 leads at every size, most clearly at m/l/x.
• Extending an existing YOLOv8 codebase or fine-tuning from YOLOv8 weights? Stay on YOLOv8; the upgrade is not worth breaking a working pipeline unless you need the accuracy or speed.
• Want the widest set of tutorials and integrations? YOLOv8 still wins on sheer volume, with YOLO11 close behind.

Whatever you pick, grab the checkpoints from the model weights pages: YOLO26, YOLO11 and YOLOv8, each with per-variant accuracy, size and license in view.

Cheat-sheet: pick in 10 seconds

What you care about most	Best pick	Why
Highest accuracy	YOLO26	Leads mAP at every size, most clearly on the bigger models.
Fastest on CPU / phone / edge	YOLO26	NMS-free, so it skips the slow clean-up step; up to 43% faster CPU inference.
Safe, well-supported default	YOLO11	Great accuracy, tons of tutorials and integrations, proven in production.
Most tutorials and community code	YOLOv8	Oldest of the three, so the biggest pile of guides and ready-made weights.
Segmentation or pose work	YOLO26	Biggest gains here versus YOLO11 (up to +3.7 mask AP, +7.2 pose AP).
Reusing an existing YOLOv8 project	YOLOv8	Don't break a working pipeline unless you need the extra speed or accuracy.
Closed-source commercial product	any of them + Enterprise license	All three are AGPL-3.0; an Ultralytics Enterprise license covers closed-source use, with official support.

For most people starting fresh in 2026, the honest one-liner is: try YOLO11n first for stability, or YOLO26n if you want the newest and fastest, and both download and run the same way.

The honest caveat

Cross-generation mAP numbers tell you the tier, not the whole story. Your dataset, image resolution, training recipe and the hardware you deploy on move real-world results more than a point or two of COCO mAP. Treat this table as the starting point, then train the two finalists on your data and measure speed on your device before you commit.

References

• Ultralytics YOLO26 documentation: features, tasks and published metrics.
• YOLO26 vs YOLOv8 and YOLO26 vs YOLO11 comparison tables.
• Ultralytics YOLO11 documentation and YOLOv8 documentation.
• YOLO26: An Analysis of the NMS-Free End-to-End Framework (arXiv) and Ultralytics YOLO Evolution overview (arXiv).