LocalAI is a modular AI inference server providing OpenAI-compatible APIs for running diverse models (LLMs, vision, audio, video) locally. It features a polyglot architecture with Go core services, pluggable backends (C++/Go/Python), and a React-based web UI. The system supports distributed deployment via NATS/PostgreSQL, model gallery management, and multimodal processing. Key capabilities include model loading from Hugging Face, quantization, PII detection, and real-time transcription. The codebase demonstrates strong engineering practices with dependency injection, middleware chains, and clean separation of concerns.
Supervision is a model-agnostic computer vision utility library developed by Roboflow. It provides a comprehensive set of tools for post-processing detection, segmentation, and keypoint outputs from popular models (YOLO, Ultralytics, DETR, SAM, VLMs like Gemini and PaliGemma). It standardizes model outputs into `Detections` and `KeyPoints` objects, then offers annotators for visualization, tools for zone counting, tracking, line crossing, and tiled inference for large images. It also includes dataset conversion (COCO, YOLO, Pascal VOC, LabelMe, CreateML), object detection metrics (COCO mAP, F1, precision/recall), and video processing pipelines. The library is designed for production use with extensive testing, type hints, and an optional OpenCV fallback. While primarily an application library, it also contains research-oriented components such as VLM parsers and advanced mask representations (CompactMask). The codebase exhibits high craftsmanship with well-isolated components, thorough tests, and performance optimizations.
Frigate is a production-grade, full-stack Network Video Recorder (NVR) with real-time AI object detection. It ingests IP camera streams, performs motion detection, object detection (via TFLite/ONNX/OpenVINO/TensorRT on CPU/GPU/NPU), tracking, and recording. The backend is Python with FastAPI, Peewee ORM, and ZMQ-based inter-process communication. The frontend is a React/TypeScript single-page application with live views, timeline review, config editing, and GenAI enrichments (face recognition, license plates, semantic search, chat). It supports hardware acceleration across a wide range of devices (Coral, Intel iGPU, NVIDIA Jetson, Hailo, Rockchip NPU, etc.) and integrates deeply with Home Assistant. While primarily an application, it contains substantial data/research components including ML model runners, embedding pipelines, and post-processing logic for classification and transcription.
Ultralytics is a production-grade computer vision library built around the YOLO model family. In production it provides a unified Python/CLI API for loading pretrained and custom models, running inference, training, validation, export, benchmarking, and object tracking across detection, instance and semantic segmentation, pose estimation, oriented bounding boxes, classification, and depth estimation. The architecture is a modular Python package: an engine layer (Model, BasePredictor, BaseTrainer, BaseValidator), a unified AutoBackend inference dispatcher supporting 20+ formats from PyTorch to TensorRT/ONNX/OpenVINO/CoreML/TFLite, a YAML-driven model configuration system, dataset loaders with caching and augmentation, pluggable experiment-tracking callbacks, and a family of ready-to-use solution classes for counting, heatmaps, queue management, and similar vision applications. The CLI entrypoint (`yolo`) and Python classes (`YOLO`, `SAM`, `RTDETR`, etc.) are the primary entry points, backed by active CI, Docker images, and extensive examples in Python, C++, and Rust.
RF-DETR is a production-grade computer vision library by Roboflow for real-time object detection, instance segmentation, and keypoint estimation. It implements a DETR-family architecture (LW-DETR, Deformable DETR) with a DINOv2 backbone, providing a complete training-to-deployment pipeline. The library is published as the `rfdetr` PyPI package and serves as the open-source core of Roboflow's detection platform, with larger models available under a separate license. The system is structured as a Python library with a CLI entry point (`rfdetr`). The main model class `RFDETR` (and variants like `RFDETRNano`) provides `predict()`, `train()`, `export()`, and `evaluate()` methods. Training is built on PyTorch Lightning with custom `LightningModule` and `LightningDataModule`, plus callbacks for EMA, COCO evaluation, GPU memory monitoring, and drop-path scheduling. The export subsystem uses a registry pattern with format-specific exporters (ONNX, TensorRT, TFLite, CoreML, OpenVINO, ExecuTorch, LiteRT) that share preprocessing and decoding utilities. Dataset loaders support COCO, YOLO, WebDataset, and Roboflow formats with configurable augmentation backends (torchvision, Albumentations, Kornia). The primary data flow: input images → preprocessing (resize, normalize) → DINOv2 backbone → multi-scale feature projector → deformable attention transformer encoder-decoder → task-specific heads (detection, segmentation, keypoints) → post-processing (top-k selection, NMS-free decoding). Training uses COCO-style datasets with Hungarian matching for label assignment. External dependencies include PyTorch, PyTorch Lightning, HuggingFace Transformers, and optional backends for export. The library integrates with Roboflow's platform for dataset management and deployment. The codebase is actively maintained with extensive test coverage (pytest, CI workflows for CPU/GPU/XLA), backward compatibility testing for legacy checkpoints, and a formal changelog. It demonstrates high craftsmanship in areas like safe checkpoint loading, atomic file operations, custom fused optimizers (Triton), and export robustness. The large optional dependency surface and reliance on some private PyTorch APIs introduce maintenance risk, but overall it is a well-engineered library suitable for production use.
ADetailer is an extension for the Stable Diffusion WebUI that provides automatic object detection and masking for inpainting tasks. It integrates models like YOLOv8 and MediaPipe to detect faces, hands, persons, and other objects, creates masks from these detections, and then performs inpaint operations on the masked regions using the Stable Diffusion model. The extension features configurable detection parameters, mask preprocessing options, ControlNet integration, and advanced prompting capabilities. It follows the WebUI extension architecture with proper script callbacks and UI integration.
Detectron2 is a production-grade, modular computer vision library from Facebook AI Research, designed for object detection, instance/semantic/panoptic segmentation, keypoint detection, and dense pose estimation. It provides a full training and inference pipeline with configurable architectures (Mask R-CNN, RetinaNet, FCOS, etc.), a flexible configuration system (CfgNode and LazyConfig), extensive data loading and augmentation, evaluation metrics for standard benchmarks (COCO, LVIS, Cityscapes), and deployment support via TorchScript and ONNX. The codebase is organized around registries and configurable classes, enabling easy extension. It also includes several research projects (DensePose, PointRend, DeepLab, etc.) as subdirectories, demonstrating its use as a research platform. While the core is well-maintained, some legacy features (Caffe2 export, deprecated LR schedulers) and project-specific code introduce moderate technical drift.
YOLOv5 is a production-oriented PyTorch framework for object detection, instance segmentation, and image classification, with a hybrid research/educational flavour from its tutorial notebooks. The dominant character is application: the repository provides CLI tools (`train.py`, `val.py`, `detect.py`, `export.py`, plus `segment/` and `classify/` variants), a Flask REST API, Docker images, PyTorch Hub support, CI smoke tests, benchmarking scripts, and experiment-tracking integrations for W&B, ClearML, and Comet. It is not just an experiment repo; it is designed to be deployed and exported to edge and cloud inference targets. Core architecture is config-driven: model YAMLs are parsed by `models/yolo.py` into `DetectionModel`, `SegmentationModel`, or `ClassificationModel` geometries, while `models/common.py` holds reusable layers and the central `DetectMultiBackend` inference wrapper for PyTorch, TorchScript, ONNX Runtime, OpenVINO, TensorRT, CoreML, TensorFlow, TFLite/Edge TPU, Paddle, and Triton. The primary data flow is dataset YAML -> dataloaders with augmentation (`utils/augmentations.py`) -> model forward -> task-specific loss (`utils/loss.py`, `utils/segment/loss.py`) -> train/val loops. `export.py` converts trained checkpoints into 12+ deployment formats using a decorated `@try_export` pattern, and `data/` embeds dataset download/conversion scripts for COCO, ImageNet subsets, VOC, VisDrone, and others. Maintenance is active, but the codebase sits in a legacy/support position relative to the unified `ultralytics` package. Technical drift is medium: some loggers are deprecated, many `models/hub/` configs are experimental, and the code depends heavily on the external `ultralytics` package, which creates version-compatibility risk. The code is generally clean and modular, though it has task-level duplication across detection, segmentation, and classification paths and limited unit test coverage outside smoke tests.
X-AnyLabeling is a cross-platform desktop application (PyQt6) for AI-assisted annotation of images, videos, and 3D point clouds. It serves as a unified interface for a vast model zoo including YOLO (v5-v26), SAM (1/2/3), Grounding DINO, Florence-2, PP-OCR, and many others, enabling auto-labeling for detection, segmentation, pose estimation, OCR, tracking, and more. The application features a plugin-based model architecture, abstracted inference engines (ONNX, TensorRT, PyTorch), and a comprehensive settings system. It also integrates an Ultralytics YOLO training pipeline and a secure in-app update mechanism. While primarily an application, it has a strong hybrid nature due to its deep integration of research code (vendored Grounding DINO, SAHI) and data pipeline utilities (format converters, COCO evaluators). The codebase demonstrates high craftsmanship in its model abstraction layer and inference engine design, though the sheer volume of integrated models introduces a medium risk of technical drift. It is actively maintained with a large community and extensive test coverage.
AlbumentationsX is a production-grade Python library for fast, flexible image augmentation in deep learning and computer vision pipelines. It provides a comprehensive catalog of 70+ transforms covering pixel-level (blur, noise, color, weather effects), geometric (flip, rotate, crop, resize, distortion, perspective), dropout (coarse, grid, mask, pixel), mixing (mosaic, copy-paste, overlay), and domain adaptation (FDA, histogram matching, stain normalization). The library supports 2D and 3D data, including images, masks, bounding boxes (HBB and OBB), keypoints, and volumes, with seamless integration into PyTorch via tensor transforms. Its architecture is built on a clean inheritance hierarchy (BasicTransform → DualTransform/ImageOnlyTransform/Transform3D) with Pydantic-based parameter validation, serialization to JSON/YAML, and deterministic replay via ReplayCompose. The codebase is backed by an extensive test suite (property-based, regression, contract, and golden vector tests), ASV benchmarks, and a sophisticated CI/CD system with path-aware planning, performance budgets, and legal integrity checks. Telemetry (opt-out) collects anonymous usage statistics to guide development. While primarily a software library, it incorporates research-level transforms (e.g., PlanckianJitter, HEStain, dithering) and is used in both academic and production settings.
DEIMv2 is a production-grade object detection framework built upon the DETR architecture, specifically implementing the DEIM (DETR with Improved Matching) algorithm extended with DINOv3 features. The codebase provides a modular design with multiple backbone options (HGNetv2, DINOv3, ResNet variants), hybrid encoders, and transformer decoders (DEIM, D-FINE, RT-DETRv2). It includes comprehensive training scripts, YAML-based configuration inheritance, data augmentation pipelines, and deployment tools for ONNX, TensorRT, and OpenVINO. The repository directly trains and evaluates on standard detection benchmarks like COCO and Objects365, and is structured for reproducibility and extensibility. While heavily inspired by prior works (RT-DETR, D-FINE), the implementation demonstrates solid engineering with clean abstractions, distributed training support, and a well-organized module hierarchy.
Moondream is a lightweight, open-source vision-language model (VLM) library and inference framework. The core of the repository is a PyTorch model (`MoondreamModel`) that comprises a vision encoder, a text decoder (based on a transformer with optional MoE layers), and a region model for spatial grounding. It supports image captioning, visual question answering, object detection, pointing, and gaze detection through a unified API. The library is designed for efficient inference on both GPU and CPU, with support for quantization (via torchao) and LoRA-based fine-tuning. The codebase is cleanly structured into modular components for vision, text, and region processing, each with clear configuration dataclasses. The repository also includes a HuggingFace integration (`HfMoondream`) for easy loading via the transformers library, and several ready-to-use demos (Gradio apps, CLI samples). Beyond the core library, the repo contains a rich set of evaluation scripts (ChartQA, POPE, DocVQA, COCO mAP, etc.) that benchmark the model on standard VLM tasks, and finetuning examples that demonstrate how to adapt the model to custom datasets using reinforcement learning or supervised fine-tuning. Additionally, there are recipe applications (promptable video redaction, content moderation, gaze detection) that showcase practical use cases built on top of Moondream. While the primary character is an application/library, the presence of extensive evaluation and finetuning code gives it a hybrid research-engineering flavor. The code is well-maintained, with active commits and CI, and uses up-to-date dependencies, resulting in low technical drift.
This repository implements a modern Automatic Number Plate Recognition (ANPR) pipeline as a production-ready application. It ingests images (via HTTP upload or WebSocket stream), runs detection using the `fast-alpr` library (YOLO-based ONNX model), performs OCR with `fast-plate-ocr`, applies post-processing (confusion-pair correction, Turkish plate format parsing, temporal majority voting), optionally tracks vehicles via an IoU-based multi-object tracker, and stores only HMAC-SHA256 hashed plate texts for privacy compliance. The system is exposed through a FastAPI REST API with WebSocket support and a HTMX web UI, plus a Typer CLI for inference and server management. It is containerized with Docker and publishes to PyPI and GHCR. The repository also contains a legacy directory (`legacy/`) with a complete YOLOv5 training pipeline for license plate detection, but that code is explicitly unmaintained and serves as historical reference only. The modern codebase is actively maintained, well-tested, and demonstrates strong software engineering practices including protocol-based abstractions, structured logging, Prometheus metrics, and privacy-by-design persistence.
GeoWombat is an open-source Python library for geospatial raster data processing and remote sensing analysis at scale. It provides a high-level API built on xarray, rasterio, Dask, and geopandas, enabling lazy, parallel processing of multi-spectral satellite imagery (Landsat, Sentinel-2, NAIP, etc.). The library's architecture centers on a custom xarray accessor (`.gw`) that exposes geospatial properties and methods, and a configuration context manager for setting sensor profiles, reprojection parameters, and other global settings. Key capabilities include raster I/O with on-the-fly warping/mosaicking, vegetation indices, radiometric corrections (BRDF, 6S, topographic), QA masking, time-series analysis, moving-window statistics (Cython-accelerated), and machine/deep learning classification and object detection (YOLO, TorchGeo, SAM). It supports STAC cloud access and distributed computation via Dask. The codebase demonstrates solid engineering with modular backends, extensible patterns, and comprehensive test coverage, though it carries some technical debt from pinned dependencies and large monolithic modules. It is actively maintained, with a broad user community and integrations with wider geospatial ecosystems.
MegaDetector is a production-grade object detection pipeline specifically designed for camera trap images in wildlife conservation. It detects animals, people, and vehicles in images and videos, outputting bounding boxes with confidence scores in a standardized JSON format (MegaDetector output format). The system provides a comprehensive set of command-line tools for batch inference, post-processing (repeat detection elimination, classification smoothing, format conversion), and integration with platforms like Wildlife Insights and LILA. The architecture is a modular Python package with separate modules for detection (supporting PyTorch and TensorFlow backends), classification, data management, post-processing, visualization, and taxonomy mapping. Key entry points include `run_detector_batch.py` for batch inference, `run_detector.py` for single-image inference, `postprocess_batch_results.py` for generating HTML previews, and `separate_detections_into_folders.py` for organizing results. Data flows from raw images through the detector to JSON results, which are then post-processed (e.g., false positive reduction, confidence thresholding) and optionally converted to other formats (COCO, YOLO, Wildlife Insights). External dependencies include PyTorch, TensorFlow, ultralytics, OpenCV, PIL, and various utility libraries. The repository also includes a C# Windows GUI application for JSON subsetting and integration guides for Timelapse and digiKam.
Photonix is a self-hosted, full-stack photo management application with AI-powered classification and search. The backend is a Django monolith exposing a GraphQL API, with background workers for importing, thumbnail generation, raw processing, and ML classification (color, objects, faces, location, style, events). The frontend is a React 19 single-page app built with TanStack Router, Apollo Client, Zustand state management, and a dark-themed shadcn/ui component library. The system supports multi-user libraries, invitations, map view, albums, and fine-grained search with facets. The architecture relies on a PostgreSQL database, Redis for task coordination and locks, and supervisor to manage numerous background processes. While the project shows solid engineering and a modern tech stack, it carries some technical debt from vendored ML models, TensorFlow 1.x compatibility, and hardcoded download URLs, and is explicitly not yet feature-complete.
Dioptra is a NIST-developed open-source platform for designing, managing, and executing reproducible machine learning experiments with a strong emphasis on adversarial robustness evaluation. The system provides a full-stack application including a REST API (Flask-RESTx with dependency injection, SQLAlchemy ORM, and Alembic migrations), a Vue.js frontend (Quasar framework), a Python client library, a plugin-based task execution engine, and a declarative YAML workflow system. It supports experiment tracking via MLflow integration, artifact versioning, user and group management, and job queuing via Redis RQ. The platform is designed to be deployed using Docker and Cookiecutter templates, with support for custom worker containers and GPU acceleration. While primarily an application for experiment lifecycle management, Dioptra also incorporates research-oriented components such as object detection modules (YOLOv1 architecture with TensorFlow backends), adversarial attack and defense plugins (using ART), and a custom type system for plugin parameter validation. The codebase is well-structured with clear separation of concerns (controllers, services, repositories), generic endpoint generators to reduce boilerplate, and a comprehensive test suite. Notable architectural patterns include unit of work, dependency injection, and a custom pyplugs decorator-based plugin registration system. However, the codebase shows signs of technical drift with some deprecated syntax, monkey-patching of third-party libraries, and complex draft/resource locking logic that may be brittle. Overall, Dioptra is a solid, professional-grade platform that effectively addresses the challenge of reproducible ML experimentation in adversarial contexts.
This is an official Meta-published Unity sample repository demonstrating the Passthrough Camera API for Quest 3/3S headsets. It contains five distinct sample scenes: CameraViewer (live camera feed display), CameraToWorld (camera-space to world-space coordinate mapping with debug visualization), BrightnessEstimation (ambient light estimation from camera pixels), MultiObjectDetection (real-time object detection using YOLO via Unity Sentis, with 3D marker spawning), and ShaderSample (water shader using camera texture as reflection source). The architecture is a collection of independent scenes, each with its own manager MonoBehaviour and shared utility scripts (InputManager, DebugUIBuilder). The project targets Android via OpenXR and the Meta XR SDK (MRUK 85.0.0), with hand tracking and controller support. It is a learning resource, not a production application, but the code is well-structured with consistent conventions and several reusable patterns.
This repository provides a template for training YOLO models on custom datasets (primarily from Kaggle) and performing inference. It includes command-line scripts for training and inference, a Streamlit app for interactive use, a Jupyter notebook for step-by-step execution, and utility scripts for data preprocessing, dataset exploration, and auto-labeling. The system allows users to download datasets, preprocess them (cleaning and augmentation), train YOLO models of various sizes, run inference on images/videos/webcam, export models to NCNN format, and automatically label images using GroundingDINO. The code is structured into modular components, with notable reusable parts in the data preprocessing and dataset exploration modules.
MetaSeg is a Python library that packages Facebook's Segment Anything Model (SAM) into an easy-to-use interface for automatic and manual image/video segmentation. It provides high-level predictors (SegAutoMaskPredictor, SegManualMaskPredictor) that handle model loading, inference, and output visualization. The library integrates with SAHI for sliced inference and FalAI for cloud GPU execution, and includes a Gradio web application. The codebase is primarily a thin orchestration layer over the official SAM implementation, with additional utility functions for data loading, video processing, and model download. It is designed for developers who want to quickly apply SAM without deep model internals.