Best YOLOv8 Alternatives in 2026: Data, Licenses and Code

The best YOLOv8 alternative for fine-tuning on a modern GPU is RF-DETR. If you need a convolutional detector, YOLO-NAS has the strongest transfer result we measured, while YOLOv9 is the cleaner permissive choice for a commercial product. All three run in LibreYOLO, so you can compare them behind one API instead of rebuilding your pipeline for every repository.

YOLOv8 is still a capable detector. In 2026, the case for replacing it comes down to three practical questions:

• License: Ultralytics distributes YOLOv8 code and trained models under AGPL-3.0 by default. Its own licensing page directs proprietary and closed-source users to a paid Enterprise License.
• Transfer accuracy: newer detectors now have measured results on 100 real datasets, not only COCO.
• Architecture choice: a transformer can be the better fit on a CUDA GPU, while a CNN may still be easier to export to a constrained edge runtime.

The benchmark data below compares the alternatives as fine-tuning starting points, then the license and deployment sections narrow the choice for production.

The short answer

Our default recommendation is therefore simple: try RF-DETR-S first when a capable GPU is available. Choose YOLOv9-S when you specifically need a CNN and permissive terms. Treat YOLO-NAS as an accuracy option whose official pretrained weights require a careful license decision.

What the RF100-VL data says

RF100-VL contains 100 object-detection datasets from seven real-world domains. Each model is fine-tuned independently on datasets covering aerial imagery, documents, flora and fauna, industry, medicine, sports and miscellaneous applications. That makes it more useful for selecting a model to fine-tune than a COCO-only leaderboard.

The published RF100-VL paper provides the YOLOv8 baseline. LibreYOLO separately completed the same 100-dataset sweep for RF-DETR, YOLO-NAS and YOLOv9. All rows below use COCO-pretrained checkpoints, 100 training epochs per dataset, each dataset's test split, and pycocotools evaluation at maxDets=500.

A note on the YOLOv8 figures: the paper's main Table 1 reports YOLOv8n/s/m at 54.9, 56.2 and 56.4, while Appendix Tables 4 and 7 report 55.4, 56.5 and 56.9. We use the appendix values because Table 4 identifies them as the standardized pycocotools results and Table 7 repeats them in the full domain breakdown. Using the higher values also avoids understating YOLOv8's performance.

The important comparisons are in percentage points, not vague claims. RF-DETR-S finishes 3.5 points above YOLOv8m. YOLO-NAS-S finishes 1.5 points above YOLOv8s and 1.1 points above YOLOv8m. YOLOv9-S finishes 0.6 points below YOLOv8s, so its case is licensing and deployment, not an RF100-VL accuracy win.

Roboflow independently reports RF-DETR-S at 60.2 on RF100-VL, nearly identical to LibreYOLO's 60.41.

The YOLOv8 values come from the NeurIPS paper, while the alternative-model values come from LibreYOLO's campaign. The high-level protocol matches, but the library implementations and family-specific training recipes differ. Use this table to choose what to test, then validate the finalists on your own dataset and hardware. Every LibreYOLO campaign artifact, including configs, per-epoch metrics, logs and scoring inputs, is available in the RF100-VL results repository.

1. RF-DETR: the best YOLOv8 alternative for a GPU

RF-DETR is our first recommendation when inference will run on a modern NVIDIA GPU. It uses a DINOv2 vision-transformer backbone and an end-to-end DETR head. It predicts a fixed set of objects and needs no NMS step at inference.

Transformer detectors are a natural fit for hardware built to execute large tensor operations efficiently. RF-DETR's 60.41 RF100-VL score is the best completed result in LibreYOLO's campaign. Teams targeting CPUs or specialized NPUs should compare exported models on that hardware before choosing it over a CNN.

The core RF-DETR Nano, Small, Medium and Large code and weights are Apache-2.0. Roboflow's larger XL and 2XL detection models use a different PML license, so do not assume every size has the same terms.

• RF-DETR documentation in LibreYOLO
• LibreRFDETRs weights
• Official Roboflow RF-DETR library
• Official RF-DETR documentation

Run it through LibreYOLO:

pip install "libreyolo[rfdetr]"

from libreyolo import LibreYOLO

model = LibreYOLO("LibreRFDETRs.pt")
model.train(data="my-dataset.yaml", epochs=100, imgsz=512, batch=8)
results = model("image.jpg", save=True)

Or use Roboflow's upstream library directly:

pip install rfdetr

from rfdetr import RFDETRSmall

model = RFDETRSmall()
model.train(dataset_dir="path/to/dataset", epochs=100)

Choose upstream when you want Roboflow's native trainer and release cadence. Choose LibreYOLO when you want to compare RF-DETR with CNNs, keep one result format, or use LibreYOLO's wider validation and export workflow.

2. YOLO-NAS: a strong CNN, with a weights-license catch

YOLO-NAS is the strongest convolutional alternative in our completed RF100-VL campaigns. The Small model reached 58.00 mAP50-95, narrowly ahead of Medium at 57.99. Both beat the published YOLOv8s and YOLOv8m values in the comparison above.

It is a good technical choice when you want a CNN, especially if your deployment toolchain handles convolutional networks more reliably than DETRs. Its model family also exports through a broad range of runtimes in LibreYOLO.

The SuperGradients source repository is Apache-2.0, but Deci's published YOLO-NAS checkpoints are under a separate license that forbids commercial use without another agreement and forbids redistribution. LibreYOLO therefore hosts no YOLO-NAS weights. A named checkpoint is downloaded from Deci's CDN after showing the terms.

That makes YOLO-NAS an accuracy alternative to YOLOv8, but not automatically a license alternative. For a commercial project, either obtain terms for the official weights or train the Apache-2.0 architecture from random initialization on data you are licensed to use.

• YOLO-NAS documentation in LibreYOLO
• Official SuperGradients repository
• Official YOLO-NAS weights license

from libreyolo import LibreYOLONAS

# Starts from random weights and does not download a Deci checkpoint.
model = LibreYOLONAS(None, size="s")
model.train(data="my-dataset.yaml", epochs=100, imgsz=640, batch=16)

Starting from random weights avoids deriving the result from Deci's checkpoint, but it also gives up the transfer-learning advantage measured in the table. Benchmark the result you will actually ship, not a differently licensed checkpoint you cannot use in production.

3. YOLOv9: the permissive CNN alternative

YOLOv9 is the practical choice when you want to stay with a YOLO-style convolutional detector and avoid both AGPL and the YOLO-NAS checkpoint restriction. LibreYOLO follows the authors' newer official MIT-licensed YOLO repository, not the older GPL-3.0 YOLOv9 repository.

The RF100-VL results are solid but mixed. YOLOv9-S is the best of the three tested sizes at 55.91. It is close to YOLOv8s at 56.5, but it does not beat it in these independent campaigns. Medium scoring below Small is also a useful warning that a larger model does not guarantee better transfer.

Use YOLOv9 because it gives you permissive terms, a familiar CNN, and a normal export path, not because a benchmark proves a universal accuracy win.

• YOLOv9 documentation in LibreYOLO
• LibreYOLO9s weights
• Official MIT-licensed YOLOv9 repository

pip install libreyolo

from libreyolo import LibreYOLO

model = LibreYOLO("LibreYOLO9s.pt")
model.train(data="my-dataset.yaml", epochs=100, imgsz=640, batch=16)
results = model("image.jpg", save=True)

Licensing is part of model selection

"Open source" is not specific enough for a production decision. The framework, architecture, pretrained checkpoint and training dataset can each carry different terms.

This is a practical summary, not legal advice. Read the linked license for the exact artifact you download and ask counsel when the deployment matters.

Migrate once, then benchmark on your data

The point of LibreYOLO is not to declare one architecture the winner forever. It is to make the next comparison one changed filename:

from libreyolo import LibreYOLO

candidates = [
    "LibreRFDETRs.pt",
    "LibreYOLO9s.pt",
]

for checkpoint in candidates:
    model = LibreYOLO(checkpoint)
    metrics = model.val(data="my-dataset.yaml")
    print(checkpoint, metrics["metrics/mAP50-95"])

Start with RF-DETR-S on a GPU. Add YOLOv9-S when a CNN or a permissive MIT path matters. Add YOLO-NAS-S only when its checkpoint terms fit your use case, or when you are prepared to train it from scratch. Then measure latency after export on the device you will actually ship.

For the broader library comparison, see Best Ultralytics Alternatives in 2026. For a version-by-version license explanation, see Is YOLO Free for Commercial Use?.

FAQ

What is the best YOLOv8 alternative in 2026?

For fine-tuning on a modern GPU, RF-DETR-S is our first choice. It reached 60.41 mAP50-95 in LibreYOLO's complete RF100-VL campaign, while the published RF100-VL paper reports 56.9 for YOLOv8m under a similar 100-epoch protocol. Use YOLOv9-S when you specifically need a permissively licensed CNN.

Does RF-DETR outperform YOLOv8?

On RF100-VL transfer learning, yes. LibreYOLO measured RF-DETR-S at 60.41 mAP50-95, and Roboflow independently reports 60.2. The RF100-VL paper reports 56.5 for YOLOv8s and 56.9 for YOLOv8m. The runs use similar protocols but different implementations, so benchmark both on your own data before deployment.

Is YOLOv8 free for commercial use?

Ultralytics distributes YOLOv8 code and trained models under AGPL-3.0 by default. Teams that cannot satisfy its open-source requirements need a separate Ultralytics Enterprise License. This is general information, not legal advice.

Is YOLO-NAS a commercially safe YOLOv8 replacement?

Not when you start from Deci's published checkpoints. The architecture and SuperGradients code are Apache-2.0, but the official YOLO-NAS pretrained weights use a separate non-commercial license and cannot be redistributed. Training the architecture from random initialization avoids deriving the result from those checkpoints.

Try LibreYOLO

pip install libreyolo

LibreYOLO is MIT-licensed and runs on Linux, macOS and Windows. It gives RF-DETR, YOLOv9, YOLO-NAS and many other detector families one API for prediction, fine-tuning, validation and export.

Star it on GitHub: github.com/LibreYOLO/libreyolo | Browse all models and weights: libreyolo.com/models