roboflow/rf-detrPublic

RF-DETR is a real-time object detection and segmentation model architecture developed by Roboflow, SOTA on COCO, designed for fine-tuning. [ICLR 2026]

AI summary: Real-time transformer architecture for object detection, segmentation, and keypoint detection.

Star on GitHub

Stars: 9.4K; +20 today
Forks: 1.2K
Watchers: 81
Open issues: 75
Open PRs: 21
Contributors: ~97
Commits: 1.1K
Branches: 21

PythonApache-2.0Created Mar 19, 2025Last push 1d agoLatest release 1.10.1+38 stars this week+38 this month

Star history

since Sep 21, 2025

9.4K stars as of Sep 9, 2026, tracked back to Sep 21, 2025. Historical curve reconstructed from public GitHub event archives, calibrated to the current total.

Signals and awards

derived from tracked data

Actively maintained
Pushed within 48 hours
Well documented
High community health score
Permissive license
Apache-2.0
Continuous integration
Automated checks passing

What rf-detr does

Provides a real-time transformer architecture designed for advanced computer vision tasks. Built on a DINOv2 vision transformer backbone to deliver state-of-the-art accuracy and latency trade-offs. Supports object detection, instance segmentation, and keypoint detection through a single, consistent API. Offers open-source models optimized for immediate deployment in performance-critical environments.

Computer vision engineers and researchers requiring state-of-the-art, real-time transformer models. Developers building advanced applications involving object tracking and segmentation.

DINOv2 backbone: Leverages a powerful vision transformer for high-accuracy feature extraction.
Real-time performance: Optimized for low-latency inference suitable for live video streams.
Unified API: Handles object detection, segmentation, and keypoint detection seamlessly.
State-of-the-art accuracy: Achieves top-tier results on Microsoft COCO and RF100-VL benchmarks.
Open-source models: Provides accessible models for community use and rapid deployment.

Where teams use it

Real-time object detection

Identify and track multiple objects continuously in live video feeds.

Instance segmentation

Precisely outline individual objects in complex scenes for detailed analysis.

Keypoint detection

Estimate human poses or track specific structural points on objects.

Edge deployment

Deploy highly accurate vision models to devices where low latency is critical.

Getting started: https://github.com/roboflow/rf-detr

README

develop branch

RF-DETR: Real-Time SOTA Object Detection, Instance Segmentation, and Keypoint Detection

RF-DETR is a real-time transformer architecture for object detection, instance segmentation, and keypoint detection (preview) developed by Roboflow. Built on a DINOv2 vision transformer backbone, RF-DETR delivers state-of-the-art accuracy and latency trade-offs on Microsoft COCO and RF100-VL.

RF-DETR uses a DINOv2 vision transformer backbone and supports object detection, instance segmentation, and keypoint detection (preview) in a single, consistent API. The open-source rfdetr package and Apache-designated models are released under Apache 2.0, while Plus components (rfdetr_plus, including RF-DETR-XL/2XL detection models) are licensed under PML 1.0.

The published RF-DETR sizes were created with neural architecture search (NAS) — and the same NAS method is now available on the Roboflow platform, so you can discover the best architecture for your own dataset. Learn more in the NAS docs.

rf-detr-segmentation-promo.mp4

Install

To install RF-DETR, install the rfdetr package in a Python>=3.10 environment with pip.

pip install rfdetr

Install from source

By installing RF-DETR from source, you can explore the most recent features and enhancements that have not yet been officially released. Please note that these updates are still in development and may not be as stable as the latest published release.

pip install https://github.com/roboflow/rf-detr/archive/refs/heads/develop.zip

Benchmarks

RF-DETR achieves state-of-the-art results in both object detection and instance segmentation, with benchmarks reported on Microsoft COCO and RF100-VL (RF100-VL for detection only). The charts and tables below compare RF-DETR against other top real-time models across accuracy and latency for detection and segmentation. All COCO accuracy numbers are measured in-house for every model shown, computed with pycocotools in SAB over the full 5,000-image val2017 split, so every row is directly comparable and may differ from vendor-reported figures. The sole exception is rows marked †, which are quoted from the original authors' paper and were not measured in SAB. All latency numbers were measured on an NVIDIA T4 using TensorRT, FP16, and batch size 1. Parameter counts are deployment (fused) nn.Module parameter counts (model.parameters(), not the raw tensor count of the saved checkpoint), except rows marked †, which are the authors' reported counts. For full benchmarking methodology and reproducibility details, see roboflow/sab.

Detection

See object detection benchmark numbers

Architecture	COCO AP₅₀	COCO AP_50:95	RF100VL AP₅₀	RF100VL AP_50:95	Latency (ms)	Params (M)	Resolution	License
RF-DETR-N	67.6	48.4	85.0	57.7	2.3	30.5	384x384	Apache 2.0
RF-DETR-S	72.1	53.0	86.7	60.2	3.5	32.1	512x512	Apache 2.0
RF-DETR-M	73.6	54.7	87.4	61.2	4.4	33.7	576x576	Apache 2.0
RF-DETR-L	75.1	56.5	88.2	62.2	6.8	33.9	704x704	Apache 2.0
RF-DETR-XL △	77.4	58.6	88.5	62.9	11.5	126.4	700x700	PML 1.0
RF-DETR-2XL △	78.5	60.1	89.0	63.2	17.2	126.9	880x880	PML 1.0
YOLO11-N	52.0	37.4	81.4	55.3	2.5	2.6	640x640	AGPL-3.0
YOLO11-S	59.7	44.4	82.3	56.2	3.2	9.4	640x640	AGPL-3.0
YOLO11-M	64.1	48.6	82.5	56.5	5.1	20.1	640x640	AGPL-3.0
YOLO11-L	64.9	49.9	82.2	56.5	6.5	25.3	640x640	AGPL-3.0
YOLO11-X	66.1	50.9	81.7	56.2	10.5	56.9	640x640	AGPL-3.0
YOLO26-N	55.8	40.3	76.7	52.0	1.7	2.6	640x640	AGPL-3.0
YOLO26-S	64.3	47.7	82.7	57.0	2.6	9.4	640x640	AGPL-3.0
YOLO26-M	69.7	52.5	84.4	58.7	4.4	20.1	640x640	AGPL-3.0
YOLO26-L	71.1	54.1	85.0	59.3	5.7	25.3	640x640	AGPL-3.0
YOLO26-X	74.0	56.9	85.6	60.0	9.6	56.9	640x640	AGPL-3.0
LW-DETR-T	60.7	42.9	84.7	57.1	1.9	12.1	640x640	Apache 2.0
LW-DETR-S	66.8	48.0	85.0	57.4	2.6	14.6	640x640	Apache 2.0
LW-DETR-M	72.0	52.6	86.8	59.8	4.4	28.2	640x640	Apache 2.0
LW-DETR-L	74.6	56.1	87.4	61.5	6.9	46.8	640x640	Apache 2.0
LW-DETR-X	76.9	58.3	87.9	62.1	13.0	118.0	640x640	Apache 2.0
D-FINE-N	60.2	42.7	84.4	58.2	2.1	3.8	640x640	Apache 2.0
D-FINE-S	67.6	50.6	85.3	60.3	3.5	10.2	640x640	Apache 2.0
D-FINE-M	72.6	55.0	85.5	60.6	5.4	19.2	640x640	Apache 2.0
D-FINE-L	74.9	57.2	86.4	61.6	7.5	31.0	640x640	Apache 2.0
D-FINE-X	76.8	59.3	86.9	62.2	11.5	62.0	640x640	Apache 2.0
SAM 3 †	—	—	—	61.6	—	~850	1008x1008	N/A

† Reported by the SAM 3 authors (arXiv:2511.16719, Table 36), not measured by us in SAB. The value is SAM 3 fine-tuned on the full RF100-VL training set, which is the same setting as the RF100VL columns above — SAM 3's paper reports LW-DETR-m at 59.8 on this benchmark, matching our own measurement, so the numbers line up. Dashes mark results SAM 3 does not report under this protocol. Parameter count is the paper's stated ~850 M (~450 M vision + ~300 M text encoders + ~100 M detector/tracker).

Segmentation

See instance segmentation benchmark numbers

Architecture	COCO AP₅₀	COCO AP_50:95	Latency (ms)	Params (M)	Resolution	License
RF-DETR-Seg-N	63.0	40.3	3.4	33.6	312x312	Apache 2.0
RF-DETR-Seg-S	66.2	43.1	4.4	33.7	384x384	Apache 2.0
RF-DETR-Seg-M	68.4	45.3	5.9	35.7	432x432	Apache 2.0
RF-DETR-Seg-L	70.5	47.1	8.8	36.2	504x504	Apache 2.0
RF-DETR-Seg-XL	72.2	48.8	13.5	38.1	624x624	Apache 2.0
RF-DETR-Seg-2XL	73.1	49.9	21.8	38.6	768x768	Apache 2.0
YOLOv8-N-Seg	45.6	28.3	3.5	3.4	640x640	AGPL-3.0
YOLOv8-S-Seg	53.8	34.0	4.2	11.8	640x640	AGPL-3.0
YOLOv8-M-Seg	58.2	37.3	7.0	27.3	640x640	AGPL-3.0
YOLOv8-L-Seg	60.5	39.0	9.7	46.0	640x640	AGPL-3.0
YOLOv8-XL-Seg	61.3	39.5	14.0	71.8	640x640	AGPL-3.0
YOLOv11-N-Seg	47.8	30.0	3.6	2.9	640x640	AGPL-3.0
YOLOv11-S-Seg	55.4	35.0	4.6	10.1	640x640	AGPL-3.0
YOLOv11-M-Seg	60.0	38.5	6.9	22.4	640x640	AGPL-3.0
YOLOv11-L-Seg	61.5	39.5	8.3	27.6	640x640	AGPL-3.0
YOLOv11-XL-Seg	62.4	40.1	13.7	62.1	640x640	AGPL-3.0
YOLO26-N-Seg	54.3	34.7	2.31	2.7	640x640	AGPL-3.0
YOLO26-S-Seg	62.4	40.2	3.47	10.4	640x640	AGPL-3.0
YOLO26-M-Seg	67.8	44.0	6.32	23.6	640x640	AGPL-3.0
YOLO26-L-Seg	69.8	45.5	7.58	28.0	640x640	AGPL-3.0
YOLO26-X-Seg	71.6	46.8	12.92	62.8	640x640	AGPL-3.0

Keypoints

See keypoint detection benchmark numbers

Architecture	COCO AP_50:95	Latency (ms)	Params (M)	License
RF-DETR Keypoint (Preview)	71.8	9.7	40.7	Apache 2.0
YOLO11-pose N	48.9	3.2	2.9	AGPL-3.0
YOLO11-pose S	57.5	3.4	9.9	AGPL-3.0
YOLO11-pose M	64.2	5.2	20.9	AGPL-3.0
YOLO11-pose L	65.2	6.6	26.2	AGPL-3.0
YOLO11-pose X	68.6	10.6	58.8	AGPL-3.0
YOLO26-pose N	55.9	1.9	2.9	AGPL-3.0
YOLO26-pose S	62.0	2.7	10.4	AGPL-3.0
YOLO26-pose M	68.0	4.6	21.5	AGPL-3.0
YOLO26-pose L	69.2	5.9	25.9	AGPL-3.0
YOLO26-pose X	71.0	9.8	57.6	AGPL-3.0

Keypoint benchmarks report AP_50:95 (OKS-based); this is the standard COCO keypoint comparison metric.

NAS on the Roboflow Platform

Since the paper release, we have improved RF-DETR NAS training on the Roboflow platform even further. A single training run gives you every model size, with results that beat not only the open-source checkpoints but also our own paper NAS results. Try it now!

Run Models

Detection

RF-DETR provides multiple model sizes, ranging from Nano to 2XLarge. To use a different model size, replace the class name in the code snippet below with another class from the table.

import supervision as sv
from rfdetr import RFDETRMedium
from rfdetr.assets.coco_classes import COCO_CLASSES

model = RFDETRMedium()

detections = model.predict("https://media.roboflow.com/dog.jpg", threshold=0.5)

labels = [f"{COCO_CLASSES[class_id]}" for class_id in detections.class_id]

annotated_image = sv.BoxAnnotator().annotate(detections.metadata["source_image"], detections)
annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels)

Note: COCO_CLASSES works for COCO-pretrained models. For fine-tuned models, use detections.data["class_name"] instead — it resolves class names from the checkpoint and works for both COCO and custom datasets.

Run RF-DETR with Inference

You can also run RF-DETR models using the Inference library. To switch model size, select the appropriate inference package alias from the table below.

import requests
import supervision as sv
from PIL import Image
from inference import get_model

model = get_model("rfdetr-medium")

image = Image.open(requests.get("https://media.roboflow.com/dog.jpg", stream=True).raw)
predictions = model.infer(image, confidence=0.5)[0]
detections = sv.Detections.from_inference(predictions)

annotated_image = sv.BoxAnnotator().annotate(image, detections)
annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections)

Size	RF-DETR package class	Inference package alias	COCO AP₅₀	COCO AP_50:95	Latency (ms)	Params (M)	Resolution	License
N	`RFDETRNano`	`rfdetr-nano`	67.6	48.4	2.3	30.5	384x384	Apache 2.0
S	`RFDETRSmall`	`rfdetr-small`	72.1	53.0	3.5	32.1	512x512	Apache 2.0
M	`RFDETRMedium`	`rfdetr-medium`	73.6	54.7	4.4	33.7	576x576	Apache 2.0
L	`RFDETRLarge`	`rfdetr-large`	75.1	56.5	6.8	33.9	704x704	Apache 2.0
XL	`RFDETRXLarge` △	`rfdetr-xlarge`	77.4	58.6	11.5	126.4	700x700	PML 1.0
2XL	`RFDETR2XLarge` △	`rfdetr-2xlarge`	78.5	60.1	17.2	126.9	880x880	PML 1.0

△ Requires the rfdetr_plus extension: pip install rfdetr[plus]. See License for details.

Segmentation

RF-DETR supports instance segmentation with model sizes from Nano to 2XLarge. To use a different model size, replace the class name in the code snippet below with another class from the table.

import supervision as sv
from rfdetr import RFDETRSegMedium
from rfdetr.assets.coco_classes import COCO_CLASSES

model = RFDETRSegMedium()

detections = model.predict("https://media.roboflow.com/dog.jpg", threshold=0.5)

labels = [f"{COCO_CLASSES[class_id]}" for class_id in detections.class_id]

annotated_image = sv.MaskAnnotator().annotate(detections.metadata["source_image"], detections)
annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels)

Run RF-DETR-Seg with Inference

You can also run RF-DETR-Seg models using the Inference library. To switch model size, select the appropriate inference package alias from the table below.

import requests
import supervision as sv
from PIL import Image
from inference import get_model

model = get_model("rfdetr-seg-medium")

image = Image.open(requests.get("https://media.roboflow.com/dog.jpg", stream=True).raw)
predictions = model.infer(image, confidence=0.5)[0]
detections = sv.Detections.from_inference(predictions)

annotated_image = sv.MaskAnnotator().annotate(image, detections)
annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections)

Size	RF-DETR package class	Inference package alias	COCO AP₅₀	COCO AP_50:95	Latency (ms)	Params (M)	Resolution	License
N	`RFDETRSegNano`	`rfdetr-seg-nano`	63.0	40.3	3.4	33.6	312x312	Apache 2.0
S	`RFDETRSegSmall`	`rfdetr-seg-small`	66.2	43.1	4.4	33.7	384x384	Apache 2.0
M	`RFDETRSegMedium`	`rfdetr-seg-medium`	68.4	45.3	5.9	35.7	432x432	Apache 2.0
L	`RFDETRSegLarge`	`rfdetr-seg-large`	70.5	47.1	8.8	36.2	504x504	Apache 2.0
XL	`RFDETRSegXLarge`	`rfdetr-seg-xlarge`	72.2	48.8	13.5	38.1	624x624	Apache 2.0
2XL	`RFDETRSeg2XLarge`	`rfdetr-seg-2xlarge`	73.1	49.9	21.8	38.6	768x768	Apache 2.0

Keypoints

RF-DETR supports keypoint detection (preview) with RFDETRKeypointPreview, pretrained on COCO person keypoints.

from rfdetr import RFDETRKeypointPreview

model = RFDETRKeypointPreview()
key_points = model.predict("image.jpg", threshold=0.5)

Size	RF-DETR package class	COCO AP_50:95	Latency (ms)	Params (M)	Resolution	License
Keypoint (Preview)	`RFDETRKeypointPreview`	71.8	9.7	40.7	576x576	Apache 2.0

Train Models

RF-DETR supports training for object detection, instance segmentation, and keypoint detection (preview). You can train models in Google Colab or directly on the Roboflow platform. Below you will find a step-by-step video fine-tuning tutorial.

Documentation

Visit our documentation website to learn more about how to use RF-DETR.

License

Licensing is split by component:

The open-source rfdetr package and Apache-designated model weights are licensed under Apache License 2.0. See LICENSE.
Plus components, including the rfdetr_plus extension and RF-DETR-XL / RF-DETR-2XL detection models, are licensed under PML 1.0.

Acknowledgements

Our work is built upon LW-DETR, DINOv2, and Deformable DETR. Thanks to their authors for their excellent work!

Citation

If you find our work helpful for your research, please consider citing the following BibTeX entry.

@inproceedings{robinson2026rfdetr,
  title     = {RF-DETR: Real-Time Detection Transformer},
  author    = {Robinson, Isaac and Robicheaux, Peter and Popov, Matvei and Ramanan, Deva and Peri, Neehar},
  booktitle = {International Conference on Learning Representations (ICLR)},
  year      = {2026},
  url       = {https://arxiv.org/abs/2511.09554}
}

Contribute

We welcome and appreciate all contributions! If you notice any issues or bugs, have questions, or would like to suggest new features, please open an issue or pull request. By sharing your ideas and improvements, you help make RF-DETR better for everyone.

View on GitHub

Recent activity

commits and pull requests

Fix incorrect TFLite INT8 calibration guidanceOpen
#1364 by amanharshx · updated 3d ago
feat(datasets): add weighted multi-source batch samplerOpen
#1287 by Maryyyyyyyam142 · updated 3d ago
refactor(datasets): outsource synthetic generatorOpen
#1435 by Borda · updated 3d ago
docs: update chlog after `1.10.1`
Borda committed 1312bf0 · 3d ago
releasing `1.10.1` [rebase & merge]Merged
#1439 by Borda · updated 3d ago
OpenVINO IR model exportOpen
#1238 by avbelova · updated 3d ago
feat(export): export backbone feature projectors instead of the detectorMerged
#1438 by JESUSROYETH · updated 3d ago
feat(export): export backbone feature projectors instead of the detector (#1438)
JESUSROYETH committed 76be022 · 3d ago
fix(models): avoid batch-wide float target masks on CUDAMerged
#1437 by JESUSROYETH · updated 3d ago
fix(models): avoid batch-wide float target masks on CUDA (#1437)
JESUSROYETH committed 2ea38f7 · 3d ago
fix(training): let compile=True reach the CUDA path with multi-scale trainingMerged
#1436 by JESUSROYETH · updated 3d ago
fix(training): let compile=True reach the CUDA path with multi-scale training (#1436)
JESUSROYETH committed dd4a9e5 · 3d ago

Recent open issues

view all

TPU: XLA recompiles on the ground-truth box-count tuple, not just image shape
#1433 · 6d ago · by JESUSROYETH
Issue with drawing overlapping bounding boxes during the prediction phase after training a multiclass detection using RF-DETR
#1414 · 10d ago · by enescicek · 1 comments
Investigation: faster training throughput without accuracy regression — starting with `torch.compile`
#1410 · 11d ago · by Borda · 1 comments
enhancement
Docs/CI: Self-Contained Weekly Metrics SVG Generator
#1408 · 12d ago · by Borda · 3 comments

Releases and announcements

30 total

v1.10.1: CUDA Compile Fixes & Memory Reduction1.10.1Sep 7, 20262 downloads
RF-DETR 1.10.1 is a patch release: `compile=True` now actually reaches CUDA's `torch.compile` path under the default `multi_scale=True` recipe, and peak CUDA memory in segmentation loss drops by sampling ground-truth masks one image at a time. It also carries several device-sync and strategy-selection fixes for the still-experimental, undocumented TPU/XLA training path (tracked under issue #1058) — see Notable Changes below. No breaking changes in this release. ## ✨ Spotlights ### ⚡ `compile=True` now actually compiles on CUDA with the default `multi_scale=True` The compile gate previously excluded multi-scale training, but the exclusion sat behind checks that already required a CUDA device *and* CUDA accelerator — so it only ever blocked the CUDA path, where `dynamic=True` already handles the varying input size. Setting `compile=True` on a default recipe previously logged a notice and trained eagerly instead. ([#1436]; [#1411], shipped in 1.10.0, made compilation reachable in the first place) ```python from rfdetr import RFDETRSmall model = RFDETRSmall() model.train(dataset_dir="...", compile=True) # multi_scale=True by default — now actually compiles on CUDA ``
v1.10.0: Faster Training & Inference1.10.0Sep 4, 202621 downloads
🎉 **RF-DETR 1.10.0 is a training-focused release: a 10k-image dataset trained for 10 epochs on an L4 went from 55 minutes to 31 minutes.** **Faster, with no code change:** - **−23% per training step** at the default batch size, from the optimizer parameter-group merge. - **Up to −46% on `predict()`** for large input frames, from moving uint8 widening onto the accelerator. - **1.25–2.26× DataLoader throughput** on input-bound runs, from packed targets and draft JPEG decoding. **New:** a **GPU batched linear-assignment solver** for the matcher on CUDA, active automatically on eligible devices. **Six changes alter behavior for callers who change nothing. Read the Migration guide before you retrain:** - Validation evaluates **one model per epoch instead of two**, so `val/*` metrics now describe the EMA model. - `grad_accum_steps` defaults to **`1` instead of `4`**, moving the default effective batch from 16 to 4. - Optimizer parameter groups collapse from **one-per-parameter to one-per-hyperparameter**. - Dataset builders **validate their config** instead of silently falling back to wrong defaults. - `log_per_class_metrics` defaults to **`False`**, dropping per-c
v1.9.4: Export & Aug Correctness Fixes1.9.4Aug 24, 2026239 downloads
RF-DETR 1.9.4 is a maintenance release: no public API removed or renamed, no new public API — the new arguments below sit on private ONNX/TFLite reference helpers. It fixes seven bugs — two in export (ONNX/TFLite background-logit-slot assumption, a keypoint tensor misidentified as a segmentation mask), two silent annotation-corruption bugs in augmentation (keypoint flip with empty flip-pairs, Albumentations `TimeReverse`/`SquareSymmetry`), one training-correctness bug (`BestModelCallback` scoring PyTorch Lightning's sanity-check pass as a real epoch), one non-square training resize bug, and one environment-dependent TFLite export failure. Users exporting sparse-ID COCO checkpoints — including the official pretrained weights — or legacy background-first keypoint checkpoints, training keypoint models with the pydantic-default empty `keypoint_flip_pairs`, using custom Albumentations `TimeReverse`/`SquareSymmetry` configs, starting a new training run seeded from `pretrain_weights`, or training non-square models benefit most from this release. See the migration guide below — three behavior changes may need action on upgrade. ## ✨ Spotlights / highlights ### Export: configurable
v1.9.3: Faster Predict, Correct YOLO Test-Split & Export Fixes1.9.3Aug 17, 202628 downloads
RF-DETR 1.9.3 is a maintenance release: no breaking changes, no new top-level public API. It fixes ten user-facing bugs and improves five behavior refinements, spanning training (YOLO test-split evaluation, auto-batch memory estimation, resumed-run metrics history, EMA epoch-boundary double-counting), inference (`predict()` no longer blocks per-image on a CUDA sync for CUDA-tensor inputs), export (ONNX/TFLite no longer silently drop multi-label detections, ONNX Runtime benchmark now honors `--device`), and segmentation (`skip_blocks` path now applies the learned feature projection it was missing during training). Users training on YOLO-format datasets with a `test` split, exporting to ONNX/TFLite, or relying on `batch_size="auto"` benefit most from this release. Callers passing CUDA tensors directly to `predict()` get a small inference speedup from the sync fix; everyone should note the `PostProcess` tie-breaking change described below — non-breaking, but worth a glance if code depends on exact output order. ## ✨ Spotlights / highlights ### `predict()` no longer blocks on a per-image CUDA sync for CUDA-tensor inputs ([#1341](https://github.com/roboflow/rf-detr/pull/1341))
v1.9.2: Fixed Roboflow COCO & perf. optim1.9.2Aug 11, 202628 downloads
RF-DETR 1.9.2 is a fix-and-performance release: one breaking change, no new public APIs. Hierarchical COCO datasets — most commonly Roboflow exports carrying a synthetic unannotated grouping category — now get a correct, shared label mapping across `train`/`valid`/`test`, closing a case where per-class metrics could silently corrupt on the smaller split. The matcher's compact cost-matrix path is faster and lower-memory on real batches, training-resume from `BestModelCallback`'s lightweight checkpoints now restores per-callback state instead of restarting cold, and a handful of training/eval fixes round it out. ## ✨ Spotlights / highlights ### Breaking: hierarchical COCO datasets get a correct, shared label space Roboflow COCO exports prepend a synthetic root category (unannotated, `supercategory: "none"`) that every real class lists as its own `supercategory`. It never carried annotations but still consumed a label slot — training such a dataset built an *N+1*-class head instead of *N*. ```python from rfdetr.datasets.coco import filter_parent_categories, annotated_category_ids categories = [ {"id": 0, "name": "project-root", "supercategory": "none"}, {"id"

When work happens

weekday and hour

Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Date	List	Rank	Stars gained
Sep 8, 2026	weekly	#14	+224
Sep 7, 2026	weekly	#14	+224

public-apis/public-apis
A collective list of free APIs
478.6K stars · Python
donnemartin/system-design-primer
Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.
369.3K stars · Python
practical-tutorials/project-based-learning
Curated list of project-based tutorials
282.9K stars · Python
NousResearch/hermes-agent
The agent that grows with you
244.2K stars · Python
yt-dlp/yt-dlp
A feature-rich command-line audio/video downloader
190.2K stars · Python
Significant-Gravitas/AutoGPT
AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
187.2K stars · Python