{"id":50310414,"url":"https://github.com/mudler/rf-detr.cpp","last_synced_at":"2026-05-31T23:00:42.092Z","repository":{"id":360792666,"uuid":"1249173002","full_name":"mudler/rf-detr.cpp","owner":"mudler","description":"rt-detr implementation in C++ with ggml","archived":false,"fork":false,"pushed_at":"2026-05-29T13:56:27.000Z","size":7028,"stargazers_count":7,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-05-30T22:03:52.254Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/mudler.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2026-05-25T12:28:47.000Z","updated_at":"2026-05-30T06:43:30.000Z","dependencies_parsed_at":null,"dependency_job_id":"b5f2645f-f04d-41e1-b052-6f660d9930f0","html_url":"https://github.com/mudler/rf-detr.cpp","commit_stats":null,"previous_names":["mudler/rf-detr.cpp"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/mudler/rf-detr.cpp","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mudler%2Frf-detr.cpp","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mudler%2Frf-detr.cpp/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mudler%2Frf-detr.cpp/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mudler%2Frf-detr.cpp/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/mudler","download_url":"https://codeload.github.com/mudler/rf-detr.cpp/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mudler%2Frf-detr.cpp/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33752286,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-05-31T02:00:06.040Z","response_time":95,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-05-28T20:30:49.761Z","updated_at":"2026-05-31T23:00:42.049Z","avatar_url":"https://github.com/mudler.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# rf-detr.cpp\n\n**Brought to you by the [LocalAI](https://github.com/mudler/LocalAI) team**, the creators of LocalAI: the open-source AI engine that runs any model (LLMs, vision, voice, image, video) on any hardware. No GPU required.\n\n[![Models on HF](https://img.shields.io/badge/HuggingFace-Models-yellow)](https://huggingface.co/mudler?search_models=rfdetr-cpp)\n[![License](https://img.shields.io/badge/License-Apache_2.0-green)](LICENSE)\n[![LocalAI](https://img.shields.io/badge/LocalAI-Run_Locally-orange)](https://github.com/mudler/LocalAI)\n\nA C++ inference engine for Roboflow [RF-DETR](https://github.com/roboflow/rf-detr), built on\n[ggml](https://github.com/ggml-org/ggml). Supports the full RF-DETR family: 5 detection\nvariants (Nano/Small/Base/Medium/Large) and 3 segmentation variants\n(SegNano/SegSmall/SegMedium), with F32 / F16 / Q8_0 / Q4_K quantizations published as GGUFs\non [HuggingFace](https://huggingface.co/mudler).\n\n\u003e Status: end-to-end detection and segmentation work on real model weights. C++ F16 is\n\u003e about 9% faster than PyTorch CPU on every COCO image we tested, matches F32 accuracy\n\u003e (max |Δscore| ≤ 0.006), and is 1.86x smaller. Detection match vs PyTorch is 54/55 at\n\u003e IoU ≥ 0.95 across 7 COCO val2017 images. Mask IoU is 0.9924 mean across segmentation\n\u003e variants.\n\n## Examples\n\nDetection (rfdetr-base, F16):\n\n| Bus + pedestrians | Kitchen scene |\n|---|---|\n| ![Bus + pedestrians detection](benchmarks/examples/det_bus.png) | ![Kitchen scene detection](benchmarks/examples/det_kitchen.png) |\n\nSegmentation (rfdetr-seg-nano, F16) with per-class mask overlay:\n\n| Street scene | Cats + remotes |\n|---|---|\n| ![Street segmentation](benchmarks/examples/seg_street.png) | ![Cats segmentation](benchmarks/examples/seg_cats.png) |\n\nAll outputs above were produced by `rfdetr-cli detect --annotated \u003cpath\u003e.png`; the\nrenderer draws per-class colored boxes with class name + score labels, and for\nsegmentation models overlays the per-detection mask in the same class color.\n\n## Quickstart: prebuilt models\n\nAll 32 GGUF models (8 variants x 4 quantizations) are published on HuggingFace. Pull one\nand run detection in three commands:\n\n```bash\n# `--recursive` is mandatory: third_party/ggml is a submodule.\n# If you've already cloned without it: git submodule update --init --recursive\ngit clone --recursive https://github.com/mudler/rf-detr.cpp \u0026\u0026 cd rf-detr.cpp\n\ncmake -B build -DRFDETR_BUILD_CLI=ON \u0026\u0026 cmake --build build -j\n\n# F16 is the default we recommend: fastest on CPU, matches F32 accuracy, 1.86x smaller.\nmkdir -p models\nhf download mudler/rfdetr-cpp-base rfdetr-base-f16.gguf --local-dir models/\n\n# Detect\n./build/bin/rfdetr-cli detect \\\n    --model models/rfdetr-base-f16.gguf \\\n    --input my_image.jpg \\\n    --output detections.json \\\n    --threshold 0.5 --threads 8\n```\n\n### Available pre-built repositories\n\n| Variant     | HuggingFace                                                                                  | F32 | F16 | Q8_0 | Q4_K |\n|-------------|----------------------------------------------------------------------------------------------|----:|----:|-----:|-----:|\n| Nano        | [`mudler/rfdetr-cpp-nano`](https://huggingface.co/mudler/rfdetr-cpp-nano)                    | 113 MB | 61 MB | 36 MB | 30 MB |\n| Small       | [`mudler/rfdetr-cpp-small`](https://huggingface.co/mudler/rfdetr-cpp-small)                  | 119 MB | 64 MB | 38 MB | 31 MB |\n| Base        | [`mudler/rfdetr-cpp-base`](https://huggingface.co/mudler/rfdetr-cpp-base)                    | 119 MB | 64 MB | 38 MB | 31 MB |\n| Medium      | [`mudler/rfdetr-cpp-medium`](https://huggingface.co/mudler/rfdetr-cpp-medium)                | 125 MB | 67 MB | 40 MB | 32 MB |\n| Large       | [`mudler/rfdetr-cpp-large`](https://huggingface.co/mudler/rfdetr-cpp-large)                  | 126 MB | 68 MB | 41 MB | 33 MB |\n| Seg-Nano    | [`mudler/rfdetr-cpp-seg-nano`](https://huggingface.co/mudler/rfdetr-cpp-seg-nano)            | 127 MB | 68 MB | 40 MB | 32 MB |\n| Seg-Small   | [`mudler/rfdetr-cpp-seg-small`](https://huggingface.co/mudler/rfdetr-cpp-seg-small)          | 128 MB | 68 MB | 40 MB | 32 MB |\n| Seg-Medium  | [`mudler/rfdetr-cpp-seg-medium`](https://huggingface.co/mudler/rfdetr-cpp-seg-medium)        | 134 MB | 72 MB | 42 MB | 34 MB |\n| Seg-Large   | [`mudler/rfdetr-cpp-seg-large`](https://huggingface.co/mudler/rfdetr-cpp-seg-large)          | 134 MB | 72 MB | 43 MB | 34 MB |\n| Seg-XLarge  | [`mudler/rfdetr-cpp-seg-xlarge`](https://huggingface.co/mudler/rfdetr-cpp-seg-xlarge)        | 141 MB | 76 MB | 45 MB | 36 MB |\n| Seg-2XLarge | [`mudler/rfdetr-cpp-seg-2xlarge`](https://huggingface.co/mudler/rfdetr-cpp-seg-2xlarge)      | 143 MB | 78 MB | 48 MB | 38 MB |\n\nUse F16 by default. It matches F32 accuracy, is 1.86x smaller, and is the fastest variant\non CPU on every model we measured. See [Benchmarks](#benchmarks) for the full numbers.\n\n## Quickstart: segmentation with mask output\n\n```bash\nhf download mudler/rfdetr-cpp-seg-nano rfdetr-seg-nano-f16.gguf --local-dir models/\n\nmkdir -p /tmp/seg_masks\n./build/bin/rfdetr-cli detect \\\n    --model models/rfdetr-seg-nano-f16.gguf \\\n    --input /tmp/coco_sample.jpg \\\n    --threshold 0.5 --threads 8 \\\n    --masks  /tmp/seg_masks \\\n    --output /tmp/seg.json\n\nls /tmp/seg_masks/\n# det_000_class1_score93.png   \u003c- person silhouette\n# det_001_class51_score84.png  \u003c- bowl silhouette\n# ...\n```\n\nThe `--masks \u003cdir\u003e` flag writes one PNG per detection (binary mask at the original\nimage resolution). Mask quality matches PyTorch at IoU 0.997 and 99.98% pixel agreement\non Seg-Nano F32; the remaining differences are sub-pixel boundary FP rounding.\n\n## Quickstart: convert from upstream\n\nTo roll your own (different variant, custom checkpoint, different quant):\n\n```bash\n# One-time: convert upstream RF-DETR .pth to GGUF (requires .venv with rfdetr).\npython3 -m venv .venv \u0026\u0026 .venv/bin/pip install rfdetr\n\n# F16: fastest on CPU, 1.86x smaller than F32, matches F32 accuracy.\n.venv/bin/python scripts/convert_rfdetr_to_gguf.py \\\n    --variant base --dtype f16 \\\n    --output models/rfdetr-base-f16.gguf\n\n# Pick a variant (nano|small|base|medium|large|seg-nano|seg-small|seg-medium|seg-large|seg-xlarge|seg-2xlarge)\n.venv/bin/python scripts/convert_rfdetr_to_gguf.py \\\n    --variant nano --dtype f16 \\\n    --output models/rfdetr-nano-f16.gguf\n\n# Re-quantize an existing F32 GGUF to any ggml type (incl. K-quants) without re-converting\n./build/bin/rfdetr-cli quantize \\\n    models/rfdetr-base-f32.gguf models/rfdetr-base-q6_K.gguf q6_K\n# Supported: f32 | f16 | q4_0 | q4_1 | q5_0 | q5_1 | q8_0 | q4_K | q5_K | q6_K\n\n# Convert all detection variants in one shot\nscripts/convert_all_variants.sh\n\n# Build the full matrix (5 detection + 3 seg, 4 quants each, = 32 models)\nscripts/build_all_quants.sh\n```\n\n## Quickstart: fine-tuning\n\nrf-detr.cpp is inference-only. To fine-tune RF-DETR on a custom dataset, train with the\nupstream [rfdetr](https://github.com/roboflow/rf-detr) Python library, then convert the\nresulting checkpoint to GGUF:\n\n```bash\n.venv/bin/python scripts/convert_rfdetr_to_gguf.py \\\n    --checkpoint runs/my_train/checkpoint_best_total.pth \\\n    --variant base --dtype f16 \\\n    --output models/my_finetune-f16.gguf\n```\n\nThe converter reads the head size directly from the checkpoint tensor and resizes the\nclassification head before loading, so arbitrary `num_classes` values are handled\nautomatically. See [`docs/finetuning.md`](docs/finetuning.md) for the end-to-end walkthrough\n(dataset prep, train, convert, quantize, serve), plus a smoke test using a synthetic 5-class\ncheckpoint at `scripts/build_custom_checkpoint.py`.\n\n## Benchmarks\n\nEnd-to-end CPU inference on AMD Ryzen 9 9950X3D (single batch, `--threads 8`). C++ F16 is\nfaster than PyTorch on every image, at 1.86x smaller:\n\n![Latency comparison: PyTorch vs rf-detr.cpp F32 vs F16 vs Q8_0 across 7 COCO images](benchmarks/plots/latency_comparison.png)\n\n| Impl                            | Median ms/image | Model size | vs PyTorch | Detection match (IoU ≥ 0.95) |\n|---------------------------------|----------------:|-----------:|-----------:|------------------------------:|\n| Python rfdetr (PyTorch + oneDNN) |           149.5 |     120 MB | 1.00x (ref) | reference                     |\n| C++ rf-detr.cpp F32 (T=8)        |           142.5 |     120 MB |     1.05x | 54/55, max \\|Δscore\\| 0.045   |\n| **C++ rf-detr.cpp F16** (T=8)    |       **136.9** |  **64 MB** | **1.09x** | 54/55, max \\|Δscore\\| 0.044   |\n| C++ rf-detr.cpp Q8_0 (T=8)       |           147.6 |  39 MB     |     1.01x | 54/55, max \\|Δscore\\| 0.046   |\n\nNumbers are medians (median-of-medians across 7 diverse COCO val2017 images, 3 passes of 20\niterations each, 5 warmup, 8 s cooldown between cells; see `--rigorous` mode in\n[`scripts/bench_community.py`](scripts/bench_community.py)). Build uses `-march=native` plus\nggml's tinyBLAS SGEMM (`GGML_LLAMAFILE=ON`) plus OpenMP plus a persistent ggml graph\nallocator.\n\nSee [`BENCHMARK.md`](BENCHMARK.md) for the per-image breakdown, F16 fast-path explanation,\nthread-scaling sweep, methodology, and reproduction recipe.\n\n### Variants comparison\n\nAll 5 detection variants share the DINOv2-small backbone; they differ in input resolution\nand decoder layer count. C++ F16 is faster than PyTorch on each:\n\n| Variant | Resolution | Dec layers | C++ F16 median ms @ T=8 | PyTorch median ms |\n|---------|-----------:|-----------:|------------------------:|------------------:|\n| Nano    |        384 |          2 |                **61.5** |              88.4 |\n| Small   |        512 |          3 |                **116.0** |             120.5 |\n| Base    |        560 |          3 |                **136.9** |             149.5 |\n| Medium  |        576 |          4 |                **149.6** |             182.8 |\n| Large   |        704 |          4 |                **237.8** |             228.7* |\n\n\\* Large is the one variant where PyTorch is competitive at T=8 (within run-to-run variance).\n\n![Variants overview](benchmarks/plots/variants_overview.png)\n\n### Quantization tradeoffs\n\nK-quants (Q4_K / Q5_K / Q6_K) produced via the C++ quantizer beat legacy block quants\n(Q4_0 / Q5_0) at the same target bit-width. The full matrix:\n\n![Quant tradeoffs](benchmarks/plots/quant_tradeoffs.png)\n\n| Variant      | Recall@0.5 | Recall@0.95 | Max \\|Δscore\\| | Notes |\n|--------------|-----------:|------------:|---------------:|-------|\n| F32          |      1.000 |       0.989 |         0.008 | Reference |\n| **F16**      |      1.000 |       0.989 |         0.008 | Matches F32, fastest variant |\n| Q8_0         |      1.000 |       0.989 |         0.009 | 3.10x compression, no accuracy loss |\n| Q6_K         |      1.000 |       0.989 |         0.011 | 3.40x compression, about 10% slower than Q8_0 |\n| Q5_K         |      0.953 |       0.879 |         0.014 | Mild accuracy loss; still usable |\n| Q4_K         |      0.953 |       0.879 |         0.020 | Halves Δscore vs legacy Q4_0 at same size |\n| Q4_0 (legacy) | 0.891 |       0.727 |         0.226 | Steep accuracy drop; not recommended |\n\nRecommendation (numbers are for rfdetr-base):\n\n1. **F16**: production default. Fastest, matches F32, 1.86x smaller than F32.\n2. **Q8_0**: when disk size matters. 3.10x compression, no accuracy loss, about 7% latency\n   tax vs F16.\n3. **Q6_K**: when you need slightly smaller than Q8_0 with near-identical accuracy.\n4. **Q4_K**: last resort for ≤32 MB deployments. Real but not catastrophic accuracy loss.\n\nSee [`BENCHMARK.md`](BENCHMARK.md) for mask quality across all 12 seg cells (mask IoU stays\n≥ 0.99 across F32/F16/Q8_0 on every segmentation variant).\n\n## Embedding via the C API\n\nrf-detr.cpp exposes a flat C ABI in [`include/rfdetr.h`](include/rfdetr.h) for `dlopen` and\n`purego.RegisterLibFunc` consumers, intended for embedding in Go, Python, or any host\nlanguage that can call C. It follows the same pattern LocalAI uses for its other ggml\nbackends:\n\n```c\n#include \"rfdetr.h\"\n\nrfdetr_init_params p = {\n    .model_path = \"models/rfdetr-base-f16.gguf\",\n    .n_threads  = 8,\n};\nrfdetr_context* ctx;\nrfdetr_init(\u0026p, \u0026ctx);\n\nrfdetr_detect_params dp = {\n    .image_path = \"my_image.jpg\",\n    .threshold  = 0.5f,\n};\nrfdetr_detection dets[100];\nint n;\nrfdetr_detect(ctx, \u0026dp, dets, 100, \u0026n);\n\nfor (int i = 0; i \u003c n; i++) {\n    printf(\"class=%d score=%.3f bbox=[%.1f,%.1f,%.1f,%.1f]\\n\",\n           dets[i].class_id, dets[i].score,\n           dets[i].bbox[0], dets[i].bbox[1], dets[i].bbox[2], dets[i].bbox[3]);\n}\n\nrfdetr_free(ctx);\n```\n\nBuild the shared library with `cmake -DRFDETR_SHARED=ON`. For segmentation models,\ndetection structs additionally carry a `mask` field (binary uint8 buffer, owned by the\ncontext until the next detect call).\n\n## Why rf-detr.cpp\n\nThe upstream Roboflow RF-DETR runtime is Python + PyTorch + Transformers + Supervision.\nrf-detr.cpp provides:\n\n- A native CPU runtime with no Python at inference time. The CLI is a single binary that\n  takes a GGUF file and an image.\n- Faster than PyTorch CPU on every variant we measured (1.05x to 1.45x across\n  Nano-to-Medium).\n- Quantization down to about 30 MB (Q4_K) with measured accuracy tradeoffs.\n- CUDA / Metal / Vulkan support via ggml backends. CPU is the only one we ship and\n  benchmark today; the others compile but are not yet validated.\n- A flat C ABI ([`include/rfdetr.h`](include/rfdetr.h)) for embedding via dlopen, purego,\n  or cgo.\n- End-to-end parity validation against the upstream PyTorch reference, per-module and\n  end-to-end (see `tests/test_parity_*.cpp`).\n\n## Build\n\n```bash\ngit clone --recursive https://github.com/mudler/rf-detr.cpp\ncd rf-detr.cpp\ncmake -B build -DRFDETR_BUILD_TESTS=ON -DRFDETR_BUILD_CLI=ON\ncmake --build build -j\nctest --test-dir build --output-on-failure\n```\n\nThe build applies two patches to `third_party/ggml` at configure time (stored in\n[`third_party/ggml-patches/`](third_party/ggml-patches/)). These are local performance and\ndebug-instrumentation improvements not yet upstreamed. Re-running CMake is a no-op once\nthey're in place. Run `scripts/apply_ggml_patches.sh` manually to inspect the patch flow.\n\n### CMake options\n\n| Option                    | Default | Purpose                                                  |\n|---------------------------|---------|----------------------------------------------------------|\n| `RFDETR_BUILD_CLI`        | ON      | Build the `rfdetr-cli` binary                            |\n| `RFDETR_BUILD_TESTS`      | OFF     | Build the ctest test suite (24 tests)                    |\n| `RFDETR_SHARED`           | OFF     | Build `librfdetr.so` (shared library for embedding)      |\n| `GGML_NATIVE`             | ON      | Compile ggml with `-march=native`                        |\n| `GGML_LLAMAFILE`          | ON      | Enable ggml's tinyBLAS SGEMM (closes most of the PyTorch gap) |\n| `GGML_CUDA` / `GGML_METAL` | OFF    | Enable GPU backends (untested for rf-detr.cpp, may need work) |\n\n## Tests\n\n```bash\nctest --test-dir build --output-on-failure   # 24 ctest targets\n```\n\nTests cover per-module parity vs the upstream torch reference (backbone, projector,\ntwo-stage, decoder, heads, segmentation), end-to-end detection parity, quantization\nsanity (F16/Q8_0/Q4_K load correctly), and per-variant load checks. The parity tests\nuse precomputed baseline tensor bundles stored as GGUFs; regenerate them with\n`scripts/gen_torch_baseline.py` if you change the architecture.\n\n## Documentation\n\n- [`BENCHMARK.md`](BENCHMARK.md): full benchmark results, methodology, reproduction recipe\n- [`docs/finetuning.md`](docs/finetuning.md): end-to-end fine-tuning walkthrough\n- [`docs/conversion.md`](docs/conversion.md): GGUF schema (v2 format), tensor naming\n- [`models/MANIFEST.md`](models/MANIFEST.md): full variant x quant matrix with file sizes\n- [`AGENTS.md`](AGENTS.md): maintenance reference for humans and agents\n\n## Citation\n\nIf you use rf-detr.cpp in a publication, please cite both this work and the upstream\nRF-DETR paper:\n\n```bibtex\n@misc{rfdetrcpp2026,\n  author       = {Di Giacinto, Ettore and Palethorpe, Richard},\n  title        = {rf-detr.cpp: C++/ggml inference engine for RF-DETR},\n  year         = {2026},\n  publisher    = {GitHub},\n  howpublished = {\\url{https://github.com/mudler/rf-detr.cpp}},\n}\n\n@software{rfdetr2025,\n  author    = {Robicheaux, Peter and Popov, Matvei and Madan, Anish and Robinson, Isaac and Nelson, Joseph and Galuba, Wojciech and Wood, James and Kakanos, Sergei and Nemcek, Matthew and Hoshmand, Onur and Ramirez Castro, Carlos},\n  title     = {RF-DETR},\n  publisher = {GitHub},\n  year      = {2025},\n  url       = {https://github.com/roboflow/rf-detr},\n}\n```\n\nThe upstream RF-DETR builds on LW-DETR, DINOv2, and Deformable DETR; cite those too if\nrelevant to your work:\n\n```bibtex\n@article{chen2024lwdetr,\n  title   = {{LW-DETR}: A Transformer Replacement to {YOLO} for Real-Time Detection},\n  author  = {Chen, Qiang and Su, Xiangbo and Zhang, Xinyu and Wang, Jian and Chen, Jiahui and Shen, Yunpeng and Han, Chuchu and Chen, Ziliang and Xu, Weixiang and Li, Fanrong and Zhang, Shan and Wang, Kun and Liu, Yong and Han, Jingdong and Ma, Zhaoxiang and Zhang, Erjin},\n  journal = {arXiv preprint arXiv:2406.03459},\n  year    = {2024},\n}\n\n@article{oquab2023dinov2,\n  title   = {{DINOv2}: Learning Robust Visual Features without Supervision},\n  author  = {Oquab, Maxime and Darcet, Timothée and Moutakanni, Théo and Vo, Huy and Szafraniec, Marc and Khalidov, Vasil and Fernandez, Pierre and Haziza, Daniel and Massa, Francisco and El-Nouby, Alaaeldin and others},\n  journal = {arXiv preprint arXiv:2304.07193},\n  year    = {2023},\n}\n\n@article{zhu2020deformabledetr,\n  title   = {{Deformable DETR}: Deformable Transformers for End-to-End Object Detection},\n  author  = {Zhu, Xizhou and Su, Weijie and Lu, Lewei and Li, Bin and Wang, Xiaogang and Dai, Jifeng},\n  journal = {arXiv preprint arXiv:2010.04159},\n  year    = {2020},\n}\n```\n\n## Author\n\nEttore Di Giacinto ([@mudler](https://github.com/mudler)), maintainer of\n[LocalAI](https://github.com/mudler/LocalAI). PRs welcome; see\n[issues](https://github.com/mudler/rf-detr.cpp/issues) for the current roadmap (GPU\nbackend validation, end-to-end seg quant comparison, etc.).\n\n## License\n\nApache-2.0; see [LICENSE](LICENSE). Copyright © 2026 Ettore Di Giacinto.\n\nThe model weights remain under their upstream license: RF-DETR is Apache-2.0\n([roboflow/rf-detr](https://github.com/roboflow/rf-detr/blob/main/LICENSE)).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmudler%2Frf-detr.cpp","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmudler%2Frf-detr.cpp","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmudler%2Frf-detr.cpp/lists"}