YOLO26 by Ultralytics: Open-Weight Model

Model Card

By Ultralytics, published under agpl-3.0, revision 070ac3c51435.

Ultralytics creates cutting-edge, state-of-the-art (SOTA) YOLO models built on years of foundational research in computer vision and AI. Constantly updated for performance and flexibility, our models are fast, accurate, and easy to use. They excel at object detection, instance segmentation, semantic segmentation, image classification, depth estimation, pose estimation and oriented object detection tasks, and can track detected objects across video frames. Find detailed documentation in the Ultralytics Docs. Get support via GitHub Issues. Join discussions on Discord, Reddit, and the Ultralytics Community Forums!

Read Ultralytics's full model card

Ultralytics creates cutting-edge, state-of-the-art (SOTA) YOLO models built on years of foundational research in computer vision and AI. Constantly updated for performance and flexibility, our models are fast, accurate, and easy to use. They excel at object detection, instance segmentation, semantic segmentation, image classification, depth estimation, pose estimation and oriented object detection tasks, and can track detected objects across video frames.

Find detailed documentation in the Ultralytics Docs. Get support via GitHub Issues. Join discussions on Discord, Reddit, and the Ultralytics Community Forums!

Request an Enterprise License for commercial use at Ultralytics Licensing.

Read the technical details on our official YOLO26 paper.

Documentation

See below for quickstart installation and usage examples. For comprehensive guidance on training, validation, prediction, and deployment, refer to our full Ultralytics Docs.

Install

Install the `ultralytics` package, including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml), in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [![PyPI - Version](https://img.shields.io/pypi/v/ultralytics?logo=pypi&logoColor=white)](https://pypi.org/project/ultralytics/) [![Ultralytics Downloads](https://img.shields.io/pepy/dt/ultralytics?color=blue)](https://clickpy.clickhouse.com/dashboard/ultralytics) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ultralytics?logo=python&logoColor=gold)](https://pypi.org/project/ultralytics/)

pip install ultralytics

For alternative installation methods, including [Conda](https://anaconda.org/conda-forge/ultralytics), [Docker](https://hub.docker.com/r/ultralytics/ultralytics), and building from source via Git, please consult the [Quickstart Guide](https://docs.ultralytics.com/quickstart). [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics?logo=condaforge)](https://anaconda.org/conda-forge/ultralytics) [![Docker Image Version](https://img.shields.io/docker/v/ultralytics/ultralytics?sort=semver&logo=docker)](https://hub.docker.com/r/ultralytics/ultralytics) [![Ultralytics Docker Pulls](https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker)](https://hub.docker.com/r/ultralytics/ultralytics)

Usage

### CLI You can use Ultralytics YOLO directly from the Command Line Interface (CLI) with the `yolo` command:

# Predict using a pretrained YOLO model (e.g., YOLO26n) on an image
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'

The `yolo` command supports various tasks and modes, accepting additional arguments like `imgsz=640`. Explore the YOLO [CLI Docs](https://docs.ultralytics.com/usage/cli) for more examples. ### Python Ultralytics YOLO can also be integrated directly into your Python projects. It accepts the same [configuration arguments](https://docs.ultralytics.com/usage/cfg) as the CLI:

from ultralytics import YOLO

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

# Train the model on the COCO8 dataset for 100 epochs
train_results = model.train(
    data="coco8.yaml",  # Path to dataset configuration file
    epochs=100,  # Number of training epochs
    imgsz=640,  # Image size for training
    device="cpu",  # Device to run on (e.g., 'cpu', 0, [0,1,2,3])
)

# Evaluate the model's performance on the validation set
metrics = model.val()

# Perform object detection on an image
results = model("path/to/image.jpg")  # Predict on an image
results[0].show()  # Display results

# Export the model to ONNX format for deployment
path = model.export(format="onnx")  # Returns the path to the exported model

Discover more examples in the YOLO [Python Docs](https://docs.ultralytics.com/usage/python).

Models

Ultralytics supports a wide range of YOLO models, from early versions like YOLOv3 to the latest YOLO26. The tables below showcase YOLO26 models pretrained on COCO for Detection, Segmentation, and Pose Estimation. Semantic Segmentation models are pretrained on Cityscapes, Depth Estimation models are pretrained on a broad multi-dataset mix and evaluated on NYU Depth V2, Classification models are pretrained on ImageNet, and OBB models are pretrained on DOTAv1. Tracking mode is compatible with Detection, Segmentation, Pose, and OBB models. All Models download automatically from the latest Ultralytics release on first use.

Detection (COCO)

Explore the [Detection Docs](https://docs.ultralytics.com/tasks/detect) for usage examples. These models are trained on the [COCO dataset](https://cocodataset.org/), featuring 80 object classes. | Model | size
^(pixels) | mAP^val
50-95 | mAP^{val
50-95(e2e)} | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) | | ---------------------------------------------------------------------- | --------------------------- | -------------------------- | ------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | [YOLO26n](https://platform.ultralytics.com/ultralytics/yolo26/yolo26n) | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.5 | | [YOLO26s](https://platform.ultralytics.com/ultralytics/yolo26/yolo26s) | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.9 | | [YOLO26m](https://platform.ultralytics.com/ultralytics/yolo26/yolo26m) | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.4 | | [YOLO26l](https://platform.ultralytics.com/ultralytics/yolo26/yolo26l) | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.8 | | [YOLO26x](https://platform.ultralytics.com/ultralytics/yolo26/yolo26x) | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 194.4 | - **mAP^val** values refer to single-model single-scale performance on the [COCO val2017](https://cocodataset.org/) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics) for details.
Reproduce with `yolo val detect data=coco.yaml device=0` - **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export.
Reproduce with `yolo val detect data=coco.yaml batch=1 device=0|cpu`

Segmentation (COCO)

Refer to the [Segmentation Docs](https://docs.ultralytics.com/tasks/segment) for usage examples. These models are trained on [COCO-Seg](https://docs.ultralytics.com/datasets/segment/coco), including 80 classes. | Model | size
^(pixels) | mAP^{box
50-95(e2e)} | mAP^{mask
50-95(e2e)} | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) | | ------------------------------------------------------------------------------ | --------------------------- | ------------------------------- | -------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | [YOLO26n-seg](https://platform.ultralytics.com/ultralytics/yolo26/yolo26n-seg) | 640 | 39.6 | 33.9 | 53.3 ± 0.5 | 2.1 ± 0.0 | 2.7 | 9.3 | | [YOLO26s-seg](https://platform.ultralytics.com/ultralytics/yolo26/yolo26s-seg) | 640 | 47.3 | 40.0 | 118.4 ± 0.9 | 3.3 ± 0.0 | 10.4 | 34.5 | | [YOLO26m-seg](https://platform.ultralytics.com/ultralytics/yolo26/yolo26m-seg) | 640 | 52.5 | 44.1 | 328.2 ± 2.4 | 6.7 ± 0.1 | 23.6 | 121.7 | | [YOLO26l-seg](https://platform.ultralytics.com/ultralytics/yolo26/yolo26l-seg) | 640 | 54.4 | 45.5 | 387.0 ± 3.7 | 8.0 ± 0.1 | 28.0 | 140.1 | | [YOLO26x-seg](https://platform.ultralytics.com/ultralytics/yolo26/yolo26x-seg) | 640 | 56.5 | 47.0 | 787.0 ± 6.8 | 16.4 ± 0.1 | 62.8 | 314.0 | - **mAP^val** values are for single-model single-scale on the [COCO val2017](https://cocodataset.org/) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics) for details.
Reproduce with `yolo val segment data=coco.yaml device=0` - **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export.
Reproduce with `yolo val segment data=coco.yaml batch=1 device=0|cpu`

Semantic Segmentation (Cityscapes)

See the [Semantic Segmentation Docs](https://docs.ultralytics.com/tasks/semantic) for usage examples. These models are trained on [Cityscapes](https://docs.ultralytics.com/datasets/semantic/cityscapes), including 19 classes. | Model | size
^(pixels) | mIoU^val | Speed
^{RTX3090 PyTorch
(ms)} | params
^(M) | FLOPs
^(B) | | ------------------------------------------------------------------------------ | --------------------------- | ------------------ | ------------------------------------------- | ------------------------ | ----------------------- | | [YOLO26n-sem](https://platform.ultralytics.com/ultralytics/yolo26/yolo26n-sem) | 1024 × 2048 | 78.3 | 4.4 ± 0.0 | 1.6 | 23.8 | | [YOLO26s-sem](https://platform.ultralytics.com/ultralytics/yolo26/yolo26s-sem) | 1024 × 2048 | 80.8 | 8.4 ± 0.0 | 6.5 | 91.0 | | [YOLO26m-sem](https://platform.ultralytics.com/ultralytics/yolo26/yolo26m-sem) | 1024 × 2048 | 82.0 | 19.9 ± 0.1 | 14.3 | 305.5 | | [YOLO26l-sem](https://platform.ultralytics.com/ultralytics/yolo26/yolo26l-sem) | 1024 × 2048 | 82.9 | 26.5 ± 0.1 | 17.8 | 388.2 | | [YOLO26x-sem](https://platform.ultralytics.com/ultralytics/yolo26/yolo26x-sem) | 1024 × 2048 | 83.6 | 48.9 ± 0.2 | 40.1 | 866.9 | - **mIoU^val** values are for single-model single-scale on the [Cityscapes](https://www.cityscapes-dataset.com/) validation set.
Reproduce with `yolo semantic val data=cityscapes.yaml device=0 imgsz=2048` - **Speed** metrics are averaged over Cityscapes validation images using an RTX3090 instance.
Reproduce with `yolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048`

Depth Estimation (NYU Depth V2)

See the [Depth Estimation Docs](https://docs.ultralytics.com/tasks/depth) for usage examples. These models are pretrained on a broad multi-dataset mix and evaluated on the [NYU Depth V2](https://cs.nyu.edu/~fergus/datasets/nyu_depth_v2.html) Eigen test split, predicting per-pixel depth in meters. | Model | size
^(pixels) | delta1^NYU | abs_rel^NYU | rmse^NYU | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) | | ---------------------------------------------------------------------------------- | --------------------------- | -------------------- | --------------------- | ------------------ | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | [YOLO26n-depth](https://platform.ultralytics.com/ultralytics/yolo26/yolo26n-depth) | 768 | 0.882 | 0.109 | 0.414 | 272.0 ± 27.2 | 2.7 ± 0.1 | 6.3 | 46.9 | | [YOLO26s-depth](https://platform.ultralytics.com/ultralytics/yolo26/yolo26s-depth) | 768 | 0.896 | 0.104 | 0.399 | 393.7 ± 13.1 | 3.8 ± 0.0 | 13.2 | 68.0 | | [YOLO26m-depth](https://platform.ultralytics.com/ultralytics/yolo26/yolo26m-depth) | 768 | 0.921 | 0.089 | 0.364 | 621.5 ± 49.7 | 6.0 ± 0.1 | 23.3 | 130.4 | | [YOLO26l-depth](https://platform.ultralytics.com/ultralytics/yolo26/yolo26l-depth) | 768 | 0.930 | 0.083 | 0.351 | 821.9 ± 50.7 | 7.7 ± 0.1 | 27.7 | 157.0 | | [YOLO26x-depth](https://platform.ultralytics.com/ultralytics/yolo26/yolo26x-depth) | 768 | 0.933 | 0.080 | 0.344 | 1240.9 ± 73.3 | 13.6 ± 0.2 | 57.0 | 301.7 | - **delta1^NYU** is the percentage of pixels where the predicted depth is within a factor of 1.25 of the ground truth, on the NYU Depth V2 Eigen test split (654 images) with multi-scale + horizontal-flip TTA and log-least-squares alignment. - Single-scale accuracy without TTA is reproducible with `yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0` (substitute `model=` for each size), which uses median (scale-only) alignment and scores lower: delta1 0.783 (n), 0.793 (s), 0.840 (m), 0.853 (l), 0.860 (x). - **abs_rel** is the mean absolute relative error between predicted and ground-truth depth values. - **rmse** is the root mean squared error in meters. - **Speed** is inference-only latency (pre/post-processing excluded) at `imgsz=768`, `batch=1`, reported as mean ± std over timed runs after warmup. **CPU ONNX** is ONNX Runtime fp32 on a 32-core Intel Xeon (Skylake); **T4 TensorRT10** is TensorRT fp16 on a Tesla T4. - **params** and **FLOPs** are measured at 768×768, the training resolution of the released weights.

Classification (ImageNet)

Consult the [Classification Docs](https://docs.ultralytics.com/tasks/classify) for usage examples. These models are trained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet), covering 1000 classes. | Model | size
^(pixels) | acc
^top1 | acc
^top5 | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^{(B) at 224} | | ------------------------------------------------------------------------------ | --------------------------- | ---------------------- | ---------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ------------------------------ | | [YOLO26n-cls](https://platform.ultralytics.com/ultralytics/yolo26/yolo26n-cls) | 224 | 71.4 | 90.1 | 5.0 ± 0.3 | 1.1 ± 0.0 | 2.8 | 0.4 | | [YOLO26s-cls](https://platform.ultralytics.com/ultralytics/yolo26/yolo26s-cls) | 224 | 76.0 | 92.9 | 7.9 ± 0.2 | 1.3 ± 0.0 | 6.7 | 1.5 | | [YOLO26m-cls](https://platform.ultralytics.com/ultralytics/yolo26/yolo26m-cls) | 224 | 78.1 | 94.2 | 17.2 ± 0.4 | 2.0 ± 0.0 | 11.6 | 4.8 | | [YOLO26l-cls](https://platform.ultralytics.com/ultralytics/yolo26/yolo26l-cls) | 224 | 79.0 | 94.6 | 23.2 ± 0.3 | 2.8 ± 0.0 | 14.1 | 6.0 | | [YOLO26x-cls](https://platform.ultralytics.com/ultralytics/yolo26/yolo26x-cls) | 224 | 79.9 | 95.0 | 41.4 ± 0.9 | 3.8 ± 0.0 | 29.6 | 13.5 | - **acc** values represent model accuracy on the [ImageNet](https://www.image-net.org/) dataset validation set.
Reproduce with `yolo val classify data=path/to/ImageNet device=0` - **Speed** metrics are averaged over ImageNet val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export.
Reproduce with `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`

Pose (COCO)

See the [Pose Estimation Docs](https://docs.ultralytics.com/tasks/pose) for usage examples. These models are trained on [COCO-Pose](https://docs.ultralytics.com/datasets/pose/coco), focusing on the 'person' class. | Model | size
^(pixels) | mAP^{pose
50-95(e2e)} | mAP^pose
50(e2e) | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) | | -------------------------------------------------------------------------------- | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | [YOLO26n-pose](https://platform.ultralytics.com/ultralytics/yolo26/yolo26n-pose) | 640 | 57.2 | 83.3 | 40.3 ± 0.5 | 1.8 ± 0.0 | 2.9 | 7.6 | | [YOLO26s-pose](https://platform.ultralytics.com/ultralytics/yolo26/yolo26s-pose) | 640 | 63.0 | 86.6 | 85.3 ± 0.9 | 2.7 ± 0.0 | 10.4 | 24.1 | | [YOLO26m-pose](https://platform.ultralytics.com/ultralytics/yolo26/yolo26m-pose) | 640 | 68.8 | 89.6 | 218.0 ± 1.5 | 5.0 ± 0.1 | 21.5 | 73.3 | | [YOLO26l-pose](https://platform.ultralytics.com/ultralytics/yolo26/yolo26l-pose) | 640 | 70.4 | 90.5 | 275.4 ± 2.4 | 6.5 ± 0.1 | 25.9 | 91.7 | | [YOLO26x-pose](https://platform.ultralytics.com/ultralytics/yolo26/yolo26x-pose) | 640 | 71.6 | 91.6 | 565.4 ± 3.0 | 12.2 ± 0.2 | 57.6 | 202.3 | - **mAP^val** values are for single-model single-scale on the [COCO Keypoints val2017](https://docs.ultralytics.com/datasets/pose/coco) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics) for details.
Reproduce with `yolo val pose data=coco-pose.yaml device=0` - **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export.
Reproduce with `yolo val pose data=coco-pose.yaml batch=1 device=0|cpu`

Oriented Bounding Boxes (DOTAv1)

Check the [OBB Docs](https://docs.ultralytics.com/tasks/obb) for usage examples. These models are trained on [DOTAv1](https://docs.ultralytics.com/datasets/obb/dota-v2#dota-v10), including 15 classes. | Model | size
^(pixels) | mAP^{test
50-95(e2e)} | mAP^test
50(e2e) | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) | | ------------------------------------------------------------------------------ | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- | | [YOLO26n-obb](https://platform.ultralytics.com/ultralytics/yolo26/yolo26n-obb) | 1024 | 52.4 | 78.9 | 97.7 ± 0.9 | 2.8 ± 0.0 | 2.4 | 14.8 | | [YOLO26s-obb](https://platform.ultralytics.com/ultralytics/yolo26/yolo26s-obb) | 1024 | 54.8 | 80.9 | 218.0 ± 1.4 | 4.9 ± 0.1 | 9.8 | 56.7 | | [YOLO26m-obb](https://platform.ultralytics.com/ultralytics/yolo26/yolo26m-obb) | 1024 | 55.3 | 81.0 | 579.2 ± 3.8 | 10.2 ± 0.3 | 21.2 | 184.9 | | [YOLO26l-obb](https://platform.ultralytics.com/ultralytics/yolo26/yolo26l-obb) | 1024 | 56.2 | 81.6 | 735.6 ± 3.1 | 13.0 ± 0.2 | 25.6 | 232.4 | | [YOLO26x-obb](https://platform.ultralytics.com/ultralytics/yolo26/yolo26x-obb) | 1024 | 56.7 | 81.7 | 1485.7 ± 11.5 | 30.5 ± 0.9 | 57.6 | 520.1 | - **mAP^test** values are for single-model multiscale performance on the [DOTAv1 test set](https://captain-whu.github.io/DOTA/dataset.html).
Reproduce by `yolo val obb data=DOTAv1.yaml device=0 split=test` and submit merged results to the [DOTA evaluation server](https://captain-whu.github.io/DOTA/evaluation.html). - **Speed** metrics are averaged over [DOTAv1 val images](https://docs.ultralytics.com/datasets/obb/dota-v2#dota-v10) using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export.
Reproduce by `yolo val obb data=DOTAv1.yaml batch=1 device=0|cpu`

Integrations

Our key integrations with leading AI platforms extend the functionality of Ultralytics' offerings, enhancing tasks like dataset labeling, training, visualization, and model management. Discover how Ultralytics, in collaboration with partners like Weights & Biases, Comet ML, Roboflow, and Intel OpenVINO, can optimize your AI workflow. Explore more at Ultralytics Integrations.

Contribute

We thrive on community collaboration! Ultralytics YOLO wouldn't be the SOTA framework it is without contributions from developers like you. Please see our Contributing Guide to get started. We also welcome your feedback—share your experience by completing our Survey. A huge Thank Youto everyone who contributes!

We look forward to your contributions to help make the Ultralytics ecosystem even better!

License

Ultralytics offers two licensing options to suit different needs:

AGPL-3.0 License: This OSI-approved open-source license is perfect for students, researchers, and enthusiasts. It encourages open collaboration and knowledge sharing. See the LICENSE file for full details.
Ultralytics Enterprise License: For development and production use, this license enables seamless integration of Ultralytics software and AI models into business products and services, including internal tools, automated workflows, and production deployments, bypassing the open-source requirements of AGPL-3.0. To get started, please contact us via Ultralytics Licensing.

Contact

For bug reports and feature requests related to Ultralytics software, please visit GitHub Issues. For questions, discussions, and community support, join our active communities on Discord, Reddit, and the Ultralytics Community Forums. We're here to help with all things Ultralytics!

Identity and Version

Repository: Ultralytics/YOLO26
Publisher: Ultralytics
Task: Object detection
Modality: Image
Library: ultralytics
Parameters: Not stated by the source
Languages: en, zh, ja, ru, de, fr, es, pt
Revision: 070ac3c51435984d992ba92eb3f234daf4e4500d
First published: 2026-01-26
Last updated: 2026-09-06

Files and Weights

27 files, 1.2 GB in total. The weights are 25 files totalling 1.2 GB in pt.

Weights25 files · 1.2 GB

Documentation1 file · 35.4 KB

Repository1 file · 1.5 KB

Every file

File	Type	Size	SHA-256
yolo26l-cls.pt	Weights	28.5 MB	7a3aebb7de6f
yolo26l-obb.pt	Weights	57.3 MB	8674b0c24bf6
yolo26l-pose.pt	Weights	58.0 MB	ad33da8a29ea
yolo26l-seg.pt	Weights	63.7 MB	636024306410
yolo26l.pt	Weights	53.2 MB	9fe3c544f2b1
yolo26m-cls.pt	Weights	23.5 MB	9f6546f33a70
yolo26m-obb.pt	Weights	48.4 MB	23e0630f6685
yolo26m-pose.pt	Weights	49.0 MB	2fbf16367022
yolo26m-seg.pt	Weights	54.8 MB	16b636f04e8f
yolo26m.pt	Weights	44.3 MB	401cea9ab23a
yolo26n-cls.pt	Weights	5.8 MB	0dd6f8dbc448
yolo26n-obb.pt	Weights	5.9 MB	6f51c78197aa
yolo26n-pose.pt	Weights	7.9 MB	eb3bb8268828
yolo26n-seg.pt	Weights	6.7 MB	361fbfabab28
yolo26n.pt	Weights	5.5 MB	9b09cc8bf347
yolo26s-cls.pt	Weights	13.6 MB	816790029d5d
yolo26s-obb.pt	Weights	21.7 MB	38dbd72ef680
yolo26s-pose.pt	Weights	24.2 MB	a083adb42303
yolo26s-seg.pt	Weights	23.5 MB	3da1d83e31ca
yolo26s.pt	Weights	20.4 MB	646f8bc3fe0a
yolo26x-cls.pt	Weights	59.6 MB	ee88a0c71e95
yolo26x-obb.pt	Weights	126.9 MB	d7b1d805b0ec
yolo26x-pose.pt	Weights	126.2 MB	08ed9e01d22a
yolo26x-seg.pt	Weights	142.1 MB	92b3de006576
yolo26x.pt	Weights	118.7 MB	9fdd44a31c50
README.md	Documentation	35.4 KB	—
.gitattributes	Repository	1.5 KB	—

License and Download

License: agpl-3.0
Access: Open weights, no gate
Download size: 1.2 GB

Download from Ultralytics

Released by Ultralytics through its official repository on Hugging Face. Read the license.

Built From

Described by arXiv:2606.03748

Evaluations

Each result is shown as reported, with the conditions its reporter stated. None is a SAVRN measurement. A comparison lines two results up only when their configuration, unit and setup are all stated and identical.

Benchmark	Conditions	Result	Reported by	Revision	Date
coco	Task object-detectionMetric [email protected]:0.95Comparison conditions not established	57.5	Ultralytics Publisher reported	Evaluated revision not stated	—

Memory Requirements

Precision	Weights in memory
As published	1.2 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Questions About YOLO26

Can I use YOLO26 commercially?

Yes, with conditions. YOLO26 is released under GNU Affero General Public License 3.0. The AGPL 3.0 is a strong copyleft license. Commercial use is allowed, but a modified version made available to users over a network must be released with its source code under the same license.

Similar Models

Model · Object detection

locate-anything.cpp-gguf

Mudler

GGUF builds of nvidia/LocateAnything-3B for locate-anything.cpp - a C++/ggml inference engine for open-vocabulary detection / visual grounding, no Python at inference time. Brought to you by the LocalAI team. The detections are the same as the official PyTorch implementation (the engine is parity-gated against it), and it runs faster - on CPU and GPU. The full-precision f32 GGUF (~15 GB) is reproducible from the HF weights with scripts/convertlocateanythingtogguf.py in the repo. Same detections as the official model, faster. Full methodology, the warm/median setup, parity checks, and more images are in the repo's Slow-mode inference on the 448 fixture; vs official divides the official…

Open weights other gguf

View model

Model · Object detection

Anzhcs_YOLOs

Anzhc

YOLOs in this repo are trained with datasets that i have annotated myself, or with the help of my friends(They will be appropriately mentioned in those cases). YOLOs on open datasets will have their own pages. Ultralytics 8.3.217 updates mask handling, which breaks function in main Adetailer repo. Install Ultralytics==8.3.216 or lower. Alternatively - use forks that fix this. - Fixed in main repo. I've added some features to make Adetailer more usable and less manual - https://github.com/Anzhc/aadetailer-reforge Im open to commissions, hit me up in Discord - anzhc P.S. All model names in tables have download links attached:3 Series of models aiming at detecting and segmenting face…

Open weights agpl-3.0 ultralytics

View model

Model · Object detection

yolov11-license-plate-detection

Nuttapong Chimwai

This is a fine-tuned version of YOLOv11 (n, s, m, l, x) specialized for License Plate Detection, using a public dataset from Roboflow Universe: The upstream Roboflow dataset (license-plate-recognition-rxg4e) contains train/test contamination — the same source images appear in both the training and test splits with only minor manual augmentation applied (see Discussion #2 for concrete examples). As a result: - The reported metrics below are likely overestimated, because the test set is not a true held-out evaluation. - Real-world generalization performance is expected to be lower than the numbers in the table. - Treat all evaluation figures with caution and validate the model on your own…

Open weights agpl-3.0 ultralytics

View model

Model · Object detection

yolov8m-table-extraction

Kerem

Open weights agpl-3.0 ultralytics

View model

Model · Object detection

surya_layout2

Datalab

A lightweight document layout detection model used by Surya. It detects layout regions (text, tables, figures, headers, captions, equations, etc.) on a page image and runs on CPU or GPU. This is the "fast" layout detector — a compact object detector that serves as a drop-in alternative to Surya's VLM-based layout model. Documentation, installation, and everything else lives in the Point the fast layout predictor at this checkpoint: Or make it the default so the CLI and library use it without an explicit path: Released under the AI Pubs OpenRAIL-M license (see LICENSE) — the same license as the surya-ocr-2 model weights.

Open weights openrail surya

View model

Model · Object detection

detr-resnet-50

Joshua

https://huggingface.co/facebook/detr-resnet-50 with ONNX weights to be compatible with Transformers.js. If you haven't already, you can install the Transformers.js JavaScript library from NPM using: Test it out here, or create your own object-detection demo with 1 click! Note: Having a separate repo for ONNX weights is intended to be a temporary solution until WebML gains more traction. If you would like to make your models web-ready, we recommend converting to ONNX using Optimum and structuring your repo like this one (with ONNX weights located in a subfolder named onnx).

Open weights 1,024 tokens transformers.js

View model