# Ultralytics YOLO: Python Library for Object Detection, Segmentation, and Pose Estimation

> Ultralytics is the Python package behind YOLO11, YOLOv8, and YOLO26, providing a unified interface for object detection, instance segmentation, semantic segmentation, depth estimation, image classification, pose estimation, and oriented object detection. It ships with a CLI and a Python API, and carries an AGPL-3.0 license that requires a paid Enterprise License for commercial deployment.

**ultralytics/ultralytics** — Ultralytics YOLO26, YOLO11, YOLOv8 : object detection, instance segmentation, semantic segmentation, image classification, pose estimation, object tracking

- Repository: https://github.com/ultralytics/ultralytics
- Website: https://platform.ultralytics.com
- Stars: 62,103 · Forks: 11,806
- Language: Python
- License: AGPL-3.0
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/ultralytics-ultralytics

## What Ultralytics YOLO Handles and Who Needs It

The ultralytics package is the official Python implementation of the YOLO family of models. According to the README, it supports object detection, instance segmentation, semantic segmentation, depth estimation, image classification, pose estimation, oriented object detection, and multi-object tracking across video frames. That breadth means a team working on any of those tasks can use a single library and a consistent API rather than assembling separate tools for each.

The target audience is Python developers and computer vision researchers who want to train, validate, predict, or export YOLO models without building the training and inference pipeline from scratch. The library is not a GUI tool or a no-code platform, though Ultralytics also offers a separate hosted platform at platform.ultralytics.com. The repository itself is the code library.

The library supports pretrained models ready to use for inference without any training. For teams that need a fine-tuned model on their own dataset, the Python API accepts a dataset configuration YAML file and handles the training loop directly.

## Installing the ultralytics Package

The README states that installation requires Python 3.8 or later and PyTorch 1.8 or later. The standard installation is:

```bash
pip install ultralytics
```

This installs the package with all listed requirements from pyproject.toml. The README also documents alternative paths: Conda via conda-forge, Docker using the official ultralytics image from Docker Hub, and building from source by cloning the repository. For most developers, pip is the starting point.

The pyproject.toml sets a PyTorch requirement but does not pin a maximum version, so in principle the library tracks current PyTorch releases. The build system uses setuptools in the range of 70.0.0 to 84.0.0, which is reflected in the package installation process.

## Running a Prediction from the CLI and the Python API

After installation, the `yolo` command is available from the shell. The README gives this example for running a prediction on a remote image:

```bash
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'
```

The `yolo` command accepts various tasks and modes, with additional arguments such as `imgsz=640` for image size. The same functionality is available through the Python API:

```python
from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model("path/to/image.jpg")
results[0].show()
```

To train a model on a custom dataset, the README shows this pattern:

```python
train_results = model.train(
    data="coco8.yaml",
    epochs=100,
    imgsz=640,
    device="cpu",
)
```

The `device` argument accepts `"cpu"`, a GPU index like `0`, or a list like `[0, 1, 2, 3]` for multi-GPU training. Setting `device="cpu"` makes the code run portably on any machine; switching to a GPU index requires that the matching CUDA toolkit and a CUDA-enabled PyTorch build are in place.

After training, `model.val()` evaluates the model on the validation set. The outputs of a prediction call include the detection results; `results[0].show()` renders the annotated image for inspection.

## Model Variants: From YOLOv3 to YOLO26 and YOLO11

The README documents support for a wide range of YOLO generations, from YOLOv3 through YOLOv8, YOLO11, and the current YOLO26. The YOLO26 family includes size variants pretrained on COCO for detection, segmentation, and pose estimation. Semantic segmentation models in the YOLO26 family are pretrained on Cityscapes. The naming convention uses a letter suffix for size: `yolo26n.pt` is the nano variant, with successively larger models available.

YOLO27 is described in the README as coming soon and currently undergoing R&D. The README notes that models are not yet available and no launch date is set. That preview notice is the extent of the information; no architecture details or benchmarks are given.

The examples directory in the repository shows how to use the models beyond the basic CLI and Python API, including ONNX Runtime integration, action recognition, region counting, interactive tracking UI, and segmentation with ONNX. These are practical starting points for deployment scenarios beyond the default PyTorch path.

## The AGPL-3.0 License and Its Commercial Implications

The library is licensed under AGPL-3.0. That license requires that any software incorporating ultralytics, or any derivative of it, must also be distributed under AGPL-3.0 and that source code must be made available to end users. For open-source projects this is generally manageable, but for commercial products where distributing source code is not acceptable, the AGPL-3.0 terms create a real conflict.

The README addresses this directly: commercial use requires requesting an Enterprise License from Ultralytics. The README provides a link to Ultralytics Licensing for this purpose. The README does not state the price; the Enterprise License terms are handled separately.

This license structure is relevant to any team that plans to ship a product using ultralytics as a dependency. Internal research and open-source projects are not affected by the commercial use requirement, but any customer-facing deployment needs legal review against the AGPL-3.0 terms before proceeding.

## Limitations and What the Library Does Not Handle

The ultralytics library is tightly coupled to the YOLO architecture family. If a team needs a transformer-based detection architecture like DETR, or a two-stage detector like Faster R-CNN, they need a different tool; the library's scope is YOLO variants and RT-DETR as listed in the pyproject.toml keywords, but the primary focus is YOLO.

The library depends on PyTorch. Teams working in TensorFlow or JAX cannot use it directly, though export to ONNX, TensorRT, Core ML, and other formats is supported, which separates training from inference runtime.

The YOLO models require meaningful compute for training. The README's Python example sets `device="cpu"` for portability, but training a detection model on CPU is impractical for non-trivial datasets. Users without GPU access should plan for cloud-based training. The README points to Google Colab and Kaggle notebooks as accessible compute paths.

Detectron2, the PyTorch-based computer vision library from Meta, offers an alternative for teams that need Mask R-CNN or Faster R-CNN architectures rather than YOLO. Detectron2 uses a modular registry-based configuration system and is oriented more toward research extensibility. The trade-off is a steeper API surface compared to ultralytics, which exposes a simpler `model.predict()` and `model.train()` interface.

## Conclusion

Engineers who need YOLO-based object detection or segmentation in Python and are working on open-source or research projects will find the ultralytics package a direct fit. Commercial teams must budget for an Enterprise License before shipping a product; the AGPL-3.0 terms are not optional and Ultralytics is explicit about enforcement. Before adopting it, verify that your PyTorch version meets the stated minimum and test the device argument against your target hardware.

## FAQ

### What do Ultralytics do?

Ultralytics creates the YOLO family of computer vision models and the ultralytics Python package that implements them. The package covers object detection, instance segmentation, semantic segmentation, depth estimation, image classification, pose estimation, and multi-object tracking.

### Is Ultralytics a company?

Yes. The README describes Ultralytics as a company that builds YOLO models and offers a hosted platform at platform.ultralytics.com alongside the open-source library.

### How do you install ultralytics?

Run `pip install ultralytics` in a Python 3.8 or later environment with PyTorch 1.8 or later already installed. The README also documents Conda, Docker, and source installation paths.

### How do you make ultralytics use a GPU?

Set the `device` argument in the `model.train()` or prediction call. The README shows `device="cpu"` for CPU and accepts a GPU index such as `0`, or a list like `[0, 1, 2, 3]` for multiple GPUs. A CUDA-enabled PyTorch installation is required.

## Sources

- [Official documentation](https://platform.ultralytics.com)
- [Official README](https://github.com/ultralytics/ultralytics#readme)
- [Project repository](https://github.com/ultralytics/ultralytics)
- [Release notes](https://github.com/ultralytics/ultralytics/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ultralytics-ultralytics