Open-source project
Tencent/YOLO-Master avatar
Tencent/YOLO-Master

YOLO-Master's build metadata still names the package ultralytics, and its two 26.08 tags disagree on their own name

[CVPR2026]🚀🚀🚀Official code for the paper "YOLO-Master: MOE-Accelerated with Specialized Transformers for Enhanced Real-time Detection." *(YOLO = You Only Look Once)* 🔥🔥🔥

784 stars162 forksPythonAGPL-3.0

At a glance

What is it?
The CVPR 2026 detection framework mixes sparse mixture-of-experts routing into a YOLO-style architecture and reports 42.4 AP at 1.62 ms on MS COCO. What the page does not give you is the hardware, the input size or a per-benchmark table, and what the repository does show you is a fork that still installs under the ultralytics distribution name, with three different version schemes in play.
Who is it for?
Read YOLO-Master as an Ultralytics fork with a routing layer added, not as a standalone framework, because that is what the tree and the packaging metadata say. The research claim is a single headline number against YOLOv13-N on one benchmark, with no hardware, resolution or batch size given, so if latency matters to you, the wiki page on deployment for GPU, CPU and NPU is where the real detail has been moved.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • Tencent/YOLO-Master784 ★ · +90
Star history
Repository2026-08-272026-11-15
Tencent/YOLO-Master694784

90 Stars in the last 80 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The build metadata names the package ultralytics, and the header is stock boilerplate

The packaging file is not YOLO-Master's own. Its opening comment block describes itself as managing the build of the Ultralytics library, gives the command `pip install ultralytics` as the installation method, and points documentation at the Ultralytics docs site.

toml
[build-system]
requires = ["setuptools>=70.0.0,<=82.0.1", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "ultralytics"
dynamic = ["version"]
description = "Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation, classification, and oriented object detection."
readme = "README.md"
requires-python = ">=3.8"
license = { "text" = "AGPL-3.0" }

So a build from this tree produces a distribution called `ultralytics`, with a version resolved at build time rather than declared, and a Python floor of 3.8. The dependency list matches that lineage too: `requirements.txt` carries the Ultralytics runtime set of numpy, matplotlib, opencv-python, pillow, pyyaml, requests, scipy, torch, torchvision, psutil, polars and ultralytics-thop, then a short block of extras this repository uses often, and finally `peft>=0.18.0,<0.20.0` for the LoRA path.

The tree agrees. There is a top-level `ultralytics/` directory next to the YOLO-Master specific ones, and the page's badge row links the upstream Ultralytics repository. What YOLO-Master adds lives in `agent/`, `configs/`, `benchmarks/`, `experiments/`, `tools/` and `model-zoo/`. Treat it as a fork if you plan to depend on it, because that is what the packaging, the dependency list and the directory layout all say, and because the licence is AGPL-3.0 as declared in both the manifest header and the project metadata.

Three version schemes are in use, and 26.08 exists under two tag names

Reading the version numbers takes a minute, because the repository uses three different shapes.

The release list contains `v26.08` titled YOLO-Master v26.08 dated 2026-08-08, a second entry tagged `YOLO-Master-v26.08` with the same title dated 2026-08-21, and `YOLO-Master-v26.02` from 2026-02-13. So the same August version is published twice under different tag names, thirteen days apart. Whether the second is a re-tag, a rebuild or a separate artefact is not stated anywhere on the page, and if you pin by tag you could end up with either one.

The page's own badge row links a release tag named `YOLO-Master-v26.02`, so the most prominent download link on the front page points at the February build while two August builds exist. That is the kind of mismatch that produces a support question about the wrong version number.

Then there is the features section heading, which is labelled as new features for `v2026.02`, a fourth shape using a four digit year. Any script that sorts or compares these names has to cope with `v26.02`, `v26.08`, `YOLO-Master-v26.08` and `v2026.02` in the same repository. For a research repository that is ordinary untidiness; for anything automating a download from it, it is a real failure mode. The last recorded push to the default branch is 2026-09-28 and the repository is not archived, so work is continuing on a branch whose commits sit past every one of these tags.

42.4 AP at 1.62 ms is the only measurement on the page, with no hardware named

The headline claim appears in two places, the highlights list and the abstract, and it is the same sentence both times. On MS COCO, YOLO-Master-N reaches 42.4 percent AP at 1.62 ms latency, beating YOLOv13-N by 0.8 mAP while running 17.8 percent faster.

What is not on the page matters as much. There is no input resolution, no hardware, no batch size, no precision setting, no table broken out per benchmark. The abstract says experiments cover five large-scale benchmarks and that gains are most pronounced on dense scenes while efficiency is preserved on typical inputs, but it does not name the other four benchmarks in the visible text. The 1.62 ms figure is therefore not something you can reproduce or even compare against your own hardware from what is written here.

The deployment detail is deliberately elsewhere. The architecture section refers readers to a wiki page, `wiki/MoE_Modules_Explanation_EN.md`, for the design philosophy behind the MoE modules, the routing mechanisms, and optimisation guides for deployment on GPU, CPU and NPU. The latency question is answered in a file that the front page only links to, which is a reasonable choice for length and a poor one for anyone deciding whether to adopt the model.

The comparison baseline is also worth noting. YOLOv13-N is the comparison point, and the description expands YOLO as You Only Look Once. The paper is linked twice by arXiv identifier, once as 2512.23273 and once as 2608.07051, and a hosted demo exists both as a Hugging Face space and as a Colab notebook, so the fastest way to see what the latency claim looks like in practice is the notebook rather than the paper.

Sparse routing is the contribution, and pruning plus a NaN debug note ship in the tree

The mechanism is an Efficient Sparse Mixture-of-Experts block, abbreviated ES-MoE, plus a lightweight dynamic routing network. During training the routing network drives expert specialisation under a diversity enhancing objective, which is what stops the experts converging on the same behaviour. At inference it activates only the most relevant experts. The framing in the page is instance-conditional adaptive computation, described as moving from static dense computation to input-adaptive allocation, with FLOPs assigned according to scene complexity.

The motivation given is a specific one: existing YOLO-style models spend the same budget on an empty sky as on a crowded intersection. The stated benefit follows from that, since gains concentrate in dense or difficult scenes rather than uniformly.

The repository also ships the maintenance tools that such a design needs. The highlights name MoE pruning and two diagnostics, `diagnose_model` and `prune_moe_model`, alongside CW-NMS and sparse SAHI inference modes. A block of debug output in the right place is what keeps a dynamic router stable, and the presence of a committed file named `debug-router-nan-activations.md` at the repository root says the router has produced NaN activations at least once. It sits next to `coverage.json` and `.idea/`, both of which are development leftovers rather than documentation, and the examples directory has a committed `.DS_Store`. None of this is harmful, and all of it is a signal that the tree is worked in directly rather than assembled for reading.

The feature list reaches past detection into LoRA, SAHI, NMS variants, MoA and MoT

The table of contents shows how far the repository has spread beyond the core contribution, and one entry is cut off mid-heading.

The listed items are mixture-of-experts support, LoRA fine-tuning described as parameter-efficient, a sparse SAHI mode, cluster-weighted NMS, mixture-of-attention support, and mixture-of-transformers, where the table of contents entry for the last one terminates inside the heading anchor. So the anchor in the page's own navigation is broken for the final item.

LoRA is the item with a packaging consequence. Its dependency, `peft>=0.18.0,<0.20.0`, is the only entry in `requirements.txt` with an upper bound, while every other runtime dependency uses a floor alone: torch from 1.8.0, torchvision from 0.9.0, numpy from 1.23.0, opencv-python from 4.6.0, and so on. An upper bound on the fine-tuning library means an unattended reinstall can start failing while the rest of the stack keeps drifting forward.

Sparse SAHI and cluster-weighted NMS are inference-time changes rather than training-time ones, which is worth separating when you read the results. SAHI slices a large image into overlapping tiles and merges detections back, and the sparse mode changes what is merged. Cluster-weighted NMS changes how overlapping boxes are suppressed. Both alter post-processing, so they can move your numbers independently of anything the routing block does, and neither is explained in the visible text beyond a name and a link to the wiki.

Twenty-two example directories, and more deployment targets than framework code

The examples directory is the largest single thing in the repository, and its shape says something about where this project expects to be used. Counting the listed entries gives twenty-two directories plus a README and a `cpp/` folder, and they are organised by deployment target rather than by feature.

Python inference examples cover ONNX Runtime, TFLite and OpenVINO. The C++ set covers ONNX Runtime, OpenVINO, LibTorch, MNN and Triton. There is a Rust pair for ONNX Runtime. RT-DETR gets its own ONNX Runtime example, YOLO11 has a Triton C++ one, YOLOv10 has a MoA one, and YOLOv8 accounts for most of the rest: action recognition, C++ inference against ONNX Runtime, segmentation, region counting, a SAHI video inference example, and an interactive tracking user interface.

Three of them name hardware or platforms directly: an Axelera Python example, an edge deployment folder, and a cross platform edge deployment folder. One is a VisDrone edge example tied to the ES-MoE model specifically. So the deployment story runs from a Python notebook to an NPU vendor SDK, while the training-side code that produces those artefacts lives elsewhere in the tree under `configs/` and `experiments/`.

The page also links a project homepage at the Tencent GitHub Pages domain, a Hugging Face space for a web interface demo, and the Colab notebook. With `.nojekyll` at the repository root and generated pages like `index.html`, `docs.html` and `model-zoo.html` committed alongside `mkdocs.yml` and a `model-zoo/` directory, the documentation site is built from files that are versioned with the code, which is convenient for offline reading and means the docs you read are always the docs of some commit.

A Chinese README sits beside the English one, and the docs build is committed to the tree

The repository root is crowded in a way that describes how the project is actually used. Alongside `README.md` and `README_CN.md` there is `CHANGELOG.md`, `CITATION.cff`, `CONTRIBUTING.md`, `SECURITY.md`, and two agent-facing instruction files, `AGENTS.md` and `CLAUDE.md`, which suggests contributors are expected to work with coding assistants against written conventions.

Documentation is present in several forms at once. There is a `docs/` directory for prose, a `wiki/` directory with the MoE explanation the architecture section links to, a `wiki-content/` directory, `wiki-assets/` for images, and pre-rendered HTML for the front page, the docs, the model zoo and the wiki in both English and Chinese. `mkdocs.yml` is the build configuration. `.nojekyll` tells GitHub Pages to serve the tree as plain files. Five copies of the same documentation, three of them generated, tracked in version control.

The remaining top-level directories split cleanly by purpose: `configs/` for configurations, `experiments/` for runs, `benchmarks/` for measurement, `reports/` and `archive/` for outputs kept after the fact, `scripts/` for automation, `smoke/` for quick checks, `tests/` for the suite, `tools/` for utilities, and `agent/` plus `app.py` for something that appears to be a host application. A single `coverage.json` at the root is the only measurement artefact left outside those directories.

Attribution is at least unambiguous. Five authors are listed, Xu Lin and Jinlong Peng marked as equal contribution, with Zhenye Gan, Jiawen Zhu and Jun Liu, split between Tencent Youtu Lab and Singapore Management University, and the work marked as accepted by CVPR 2026. The `CITATION.cff` file in the root is what tooling will read for a formal citation, which is a better answer than the paper links alone.

Editorial conclusion

Read YOLO-Master as an Ultralytics fork with a routing layer added, not as a standalone framework, because that is what the tree and the packaging metadata say. The research claim is a single headline number against YOLOv13-N on one benchmark, with no hardware, resolution or batch size given, so if latency matters to you, the wiki page on deployment for GPU, CPU and NPU is where the real detail has been moved. Before you build on it, check two things: which tag you actually want, since the 26.08 release exists under two names and the page's badge still points at 26.02, and what the AGPL-3.0 terms mean for whatever you ship. The pruning and diagnostic utilities are genuinely useful and are not covered by the headline numbers.

Frequently asked questions

What is YOLO-Master and what does it change about a YOLO detector?

It is a YOLO-style framework for real-time object detection that integrates a mixture-of-experts block with a lightweight dynamic routing network. Routing is specialised during training with a diversity enhancing objective and activates only the most relevant experts at inference, which the project describes as instance-conditional adaptive computation.

What accuracy and speed does YOLO-Master-N reach?

On MS COCO it reports 42.4 percent AP at 1.62 ms latency, ahead of YOLOv13-N by 0.8 mAP and 17.8 percent faster. The page does not name the input resolution, hardware, batch size or precision, and the abstract states that experiments cover five large-scale benchmarks without naming the other four in the visible text.

Is YOLO-Master a standalone package or a fork?

It ships as a fork. The packaging metadata declares the project name as `ultralytics` with a dynamically resolved version, the dependency list is the Ultralytics runtime set plus LoRA's `peft`, the tree contains a top-level `ultralytics/` directory, and the licence is AGPL-3.0.

Which YOLO-Master release should I install?

Two August builds exist under different tag names, `v26.08` dated 2026-08-08 and `YOLO-Master-v26.08` dated 2026-08-21, with the page's badge still linking the February tag `YOLO-Master-v26.02`. The page does not say what distinguishes the two August tags, so verify which one you want before pinning.

What extra features does YOLO-Master add on top of mixture-of-experts routing?

LoRA fine-tuning, a sparse SAHI inference mode, cluster-weighted NMS, mixture-of-attention support and mixture-of-transformers, plus MoE pruning and the `diagnose_model` and `prune_moe_model` diagnostics. LoRA brings `peft>=0.18.0,<0.20.0`, the only dependency in `requirements.txt` carrying an upper bound.

Where are the deployment and pruning details documented?

The architecture section points to `wiki/MoE_Modules_Explanation_EN.md` for the MoE modules, the routing mechanisms, and optimisation guides for GPU, CPU and NPU. The examples directory carries twenty-two target-specific folders covering ONNX Runtime, TensorRT-adjacent C++ stacks, TFLite, OpenVINO, MNN, LibTorch, Triton, Rust and an Axelera NPU example.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/tencent-yolo-master.svg)](https://hysenlabs.com/projects/tencent-yolo-master)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/tencent-yolo-master.svg)](https://hysenlabs.com/projects/tencent-yolo-master)

Was this useful?