Alpamayo 1 is a Vision-Language-Action (VLA) model designed for autonomous driving applications. It implements the Alpamayo-R1 architecture that combines a Qwen3-VL backbone for vision-language reasoning with a diffusion-based action expert for trajectory prediction. The system takes multi-camera video and egomotion history as inputs, generates Chain-of-Causation (CoC) reasoning traces, and outputs future trajectories (6.4s horizon at 10Hz). Key components include a unicycle kinematic model for action space conversion, CUDA graph acceleration for efficient repeated inference, and robust geometric transformations. While the repository is noted to receive only limited maintenance as newer versions exist, the current implementation demonstrates strong engineering practices with several reusable components.
A ROS 2 node that performs real-time metric depth estimation and point cloud generation using Depth Anything V3 accelerated with TensorRT. The system subscribes to camera image and camera info topics, synchronizes them via approximate time, runs GPU-accelerated preprocessing and inference, then publishes a 32-bit float depth image and a colorized or monochrome point cloud. The pipeline includes GPU-side bicubic upscaling, focal-length-based metric scaling, sky detection with percentile-based fill, and optional debug visualization with FPS overlay. The repository provides a complete build system (ament_cmake, CUDA, TensorRT), a standalone engine generation tool, a Docker image, and an ONNX export script for the underlying PyTorch model. It is designed for autonomous driving and robotics perception applications requiring high frame rates (claimed 50 FPS on Quadro RTX 6000). The architecture is a monolithic ROS 2 component with a clean separation between the node, the TensorRT wrapper, and the GPU kernels.
This repository provides a library and tools for training and deploying CNN models (RotNet, RotNetR) to predict the rotation angle of images, primarily designed for cracking rotate captchas. The system includes a training pipeline with customizable dataset preprocessing (random rotations, cropping, normalization), model definitions using ResNet50 and RegNet_Y backbones, a loss function optimized for angular classification (Circular Smooth Label), and an HTTP server for inference. The codebase is well-structured as a Python package with clean separation of concerns, showcasing advanced patterns like generic pipe operators for data transformation composition and context-managed training loops. It is actively maintained and demonstrates solid software engineering practices.
This repository implements a complete embedded IoT system for automated meter reading (water, gas, electricity) using an ESP32-CAM with on-device TensorFlow Lite inference. The firmware captures images, performs alignment and ROI extraction, runs digit and analog pointer recognition via quantized TFLite models, applies post-processing (consistency checks, rate limiting, decimal shift), and publishes readings via MQTT, InfluxDB (v1/v2), Webhook, or a built-in REST API. The architecture follows a modular flow-control pattern with separate components for camera control, image processing, neural network inference, configuration, logging, and output protocols. A full-featured web interface provides setup wizards, live data graphs, OTA updates, and file management. The system is designed for low-power edge deployment on ESP32 with PSRAM and SD card storage.
rclip is a command-line semantic photo search tool that indexes local image collections using a CLIP model (OpenCLIP ViT-B/32-256) and supports natural-language, image-to-image, and combined queries with boolean operations. The core architecture is monolithic: a Python package with modules for model inference (ONNX/CoreML), SQLite-based feature caching, image preprocessing, and a Textual terminal user interface for interactive browsing. It is fully offline and privacy-preserving, supporting a wide range of image formats including HEIC, raw (CR2, DNG, ARW), and standard web formats. The tool is distributed via PyPI, Snap, AppImage, Homebrew, and Windows MSI, with careful compliance management for third-party licenses, codecs, and model artifacts. It includes an extensive test suite (unit and end-to-end), CI/CD via GitHub Actions, and a compliance toolkit that enforces license policies during builds. The codebase is well-structured and demonstrates good engineering practices, though it relies on a pinned version of textual-image that uses a private API, introducing some technical drift risk.
Koharu is a desktop application for manga and comic translation, built with a Rust backend (Tauri) and a React/TypeScript frontend. It orchestrates a multi-stage ML pipeline: page import, layout detection (YOLO, RT-DETR), speech bubble segmentation, OCR (PP-OCR, Manga OCR), translation (local LLMs via llama.cpp or cloud APIs), and inpainting (LaMa, FLUX.2, AOT-GAN). The system includes a custom deep learning framework (`koharu-torch`) with inference-only ports of common vision models, a scene graph for versioned project state, and a WebGPU/WASM canvas for interactive editing. The application supports multiple hardware backends (CUDA, ROCm, Vulkan, Metal) and can run entirely offline. Architecturally, the project is a monorepo with over 30 Rust crates and two JavaScript packages. The backend is organized around clearly separated concerns: model inference (`koharu-ml`), pipeline orchestration (`koharu-pipeline`), project state (`koharu-scene`), persistent storage (`koharu-storage`), and rendering (`koharu-renderer`/`koharu-rasterizer`). The frontend provides an editor with panels for page management, canvas, inspection, and an AI agent panel that uses OpenAI's Codex protocol for tool-driven project editing. The translation subsystem abstracts over local and remote providers with a common prompt and schema interface. While the primary purpose is an application, the ML model implementations are notable for their fidelity to upstream Python references, including exact preprocessing (LetterBox padding, pixel normalization) and postprocessing (NMS, mask decoding). This makes the repository valuable as a reference for Rust ports of computer vision models. However, the codebase is tightly coupled to specific model architectures and pinned revisions, limiting direct reuse without significant adaptation. The UI component library (`packages/ui`) and several backend abstractions (e.g., configuration, storage format, runtime dependency graph) are designed for reusability and could be extracted with minimal effort.
BallonsTranslator is a desktop application for translating manga and comics, built with PyQt6. It orchestrates a full pipeline from image loading through text detection, OCR, translation, inpainting, and typesetting. The architecture is modular with a lazy plugin system for detectors, OCR engines, translators, and inpainters, supporting both local ML models and cloud LLM APIs (OpenAI, Codex, etc.). The application features a rich interactive canvas with advanced text editing (rich formatting, effects, transforms like bend and grid warp), project management with undo/redo, a Photoshop bridge, and internationalization. Code quality is good with extensive test coverage, but there are signs of technical drift such as hardcoded API keys, platform-specific fragility, and dependency version locks. Overall, it's a well-crafted tool with several genuinely reusable components, particularly in module registration, secret storage, filter plugins, and download utilities.
PlumeLens (鉴翎) is a local bird photo analysis and culling workstation for bird photographers. It uses on-device ML models—YOLOv26l for detection, a custom 11-keypoint pose estimator, CLIPIQA+/HyperIQA for quality assessment, and DINOv3 with LoRA adapters for species classification—to process photos without any cloud upload. The system scans user photo directories (read-only), performs detection, pose estimation, quality scoring, and species identification, then presents a grading interface (reject/record/usable/select) with manual review and species override capabilities. Export supports JPG/RAW with XMP sidecars, and a geographic archive module visualizes species sightings on an interactive map with conservation status. The architecture is a desktop application split into an Electron+React frontend and a Python FastAPI backend. The backend runs as a subprocess managed by Electron, communicating via REST APIs and Server-Sent Events for progress. The ML pipeline is orchestrated in `engine/pipeline/manager.py` with ONNX Runtime and PyTorch inferences. The frontend uses React 19, TanStack Query, Zustand, and a virtualized grid for handling large photo sets. The application is packaged for macOS (arm64) via electron-builder and PyInstaller. While the primary delivery is a desktop application, the repository also contains extensive model training scripts, evaluation frameworks (`evals/`), and dataset preparation utilities, making it a hybrid project with significant research and data engineering components. Model integrity is enforced via SHA-256 manifest verification at startup, and all inference is deterministic with versioned pipeline hashes to invalidate caches on updates.
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.
InsightFace is a comprehensive, production-grade face analysis ecosystem. It provides a Python package (`insightface`) with high-level APIs for face detection, recognition, attribute estimation, and face swapping, backed by ONNX Runtime. A C++ SDK (`inspireface`) enables on-device inference across Linux, Android, iOS, and embedded platforms with support for CUDA, TensorRT, CoreML, and Rockchip NPUs. A FastAPI server offers REST endpoints for face search and verification with SQLite persistence and license management. A PySide6 desktop GUI (Evaluation Studio) provides interactive workflows for verification, album management, and enterprise evaluation. The repository also contains extensive research code for training face recognition models (ArcFace, Partial FC, VPL) across PyTorch, MXNet, OneFlow, and PaddlePaddle, as well as detection (SCRFD, RetinaFace), 3D reconstruction, and face parsing. While the core application components are well-engineered and actively maintained, the research subprojects vary in maturity and may rely on outdated frameworks.
Open-OmniVCus is a research monorepo reproducing the NeurIPS 2025 OmniVCus method for subject-driven video customization under multimodal control conditions (reference image, depth, mask, motion/camera). It is hybrid by nature: the dominant character is an application/framework layer provided by a large vendored/forked copy of DiffSynth-Studio, wrapped around research-oriented data-construction and training code (VideoCus-Factory, Video-Depth-Anything). The repo does not expose a hosted service or API; it is a Python library plus executable training/inference scripts for diffusion-based image and video generation.
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.
This repository is a research fork of Meta's Habitat-Sim, extended with 3D Gaussian Splatting (3DGS) for photo-realistic rendering in embodied AI navigation tasks. It provides a full simulation platform with physics (Bullet), sensors (RGB, depth, semantic, fisheye), navigation meshes, and a CUDA-accelerated Gaussian splatting rasterizer supporting dynamic avatars. The codebase includes training and evaluation pipelines for PointNav, ImageNav, ObjectNav, Vision-Language Navigation (StreamVLN, Uni-NaVid), and dynamic avatar avoidance. It also contains an LLM-driven agent system (HabitatAgent) with a bridge API, MCP server, and TUI for interactive navigation. The repository is hybrid: primarily a research platform for embodied AI experiments, but also includes application-like components such as web tools (navmesh editor, object annotation helper), a real-time Rerun viewer, and a conda packaging system. The core C++ simulator is well-architected with managed object patterns, replay recording, and PBR rendering, while the Python layer provides episode generation, prompt-based agent control, and analytics dashboards. Data assets (GS scenes, avatars, checkpoints) are hosted externally on Hugging Face, and the setup requires multiple conda environments for different tasks.
This repository is a massive, multi-disciplinary research codebase from Google Research, primarily focused on machine learning, optimization, and computer science experiments. While it contains a few application-like components (e.g., a Next.js frontend for model exploration, a Rust-based 3D splatting renderer), the dominant character is data_research, hosting thousands of independent experimental projects. The codebase serves as a central hub for publishing reproducible research in domains including Reinforcement Learning, Computer Vision (NeRF, 3D), NLP (Transformers, LLMs), and Privacy. It relies heavily on shell scripts for environment setup and experiment orchestration, with a mix of Python, C++, Rust, and Java implementations. The infrastructure is robust for research (e.g., `scann` for search, `lila` for experiment management) but exhibits significant fragmentation and technical debt due to the rapid pace of research and mixed framework usage.
WorldGen is a Python library and demo application for generating 3D scenes from text prompts or single images in seconds. It orchestrates a pipeline of state-of-the-art models: a fine-tuned FLUX diffusion model to generate 360° panoramic images, DA-2 for monocular depth estimation on equirectangular images, and optionally OneFormer for semantic segmentation and LaMa for inpainting to handle background occlusions. The 3D scene is produced as a Gaussian splatting point cloud (via a custom RGBD-to-Gaussian conversion) or as a textured mesh. An experimental mode uses Apple's Sharp model for higher-quality Gaussian splats by processing cubemap faces. The codebase demonstrates strong engineering practices for a research project: modular pipeline design, use of submodules for dependencies, custom diffusers pipelines with VAE tiling modifications for seamless panorama generation, and a Viser-based interactive viewer. While the core value is the integrated pipeline, several utility modules (equirectangular projection utilities, splat file handling) are cleanly isolated and reusable in other 360° or 3D vision projects.
This repository is a research evaluation harness for Visual Place Recognition (VPR) models. It wraps a wide range of state-of-the-art VPR methods behind a common CLI, allowing users to run any supported model on standard VPR datasets (e.g., St Lucia) or a bundled toy dataset. The main entry point is test_dataset.py, which loads database/query image folders, extracts descriptors using the selected model, computes recall@N metrics, and saves logs and optional visualizations. The repo is designed to work with the companion VPR-datasets-downloader to standardize dataset format. Although it is a CLI tool, its primary purpose is research evaluation, so it is classified as data_research.
KWIVER is a large C++/Python computer vision and video analytics toolkit. Its architecture is a plugin-driven algorithm library (vital/algo), a dataflow pipeline framework (sprokit), and many backend implementations (arrows) that wrap OpenCV, VXL, Ceres, FFmpeg, GDAL, VTK, and other dependencies. In production it performs video/image I/O, feature detection and matching, structure-from-motion, object detection/tracking, geospatial metadata parsing, and serialization. It exposes command-line applets, an embedded pipeline API, Qt-based viewers, and pybind11 Python bindings. The system is configuration-driven: algorithms and processes are registered through macros, configured via vital::config_block, and instantiated dynamically through a plugin registry. The sprokit subsystem provides a pipeline DSL, schedulers, process clusters, and adapter ports for external data injection, making the project both a reusable library and a runtime pipeline environment. Although dominated by application/library code, the repository also serves research and defense-oriented use cases. It contains extensive MISB/KLV metadata parsers for multiple standards, multi-view geometry algorithms, track-file format readers/writers (kw18, KPF, XGTF, etc.), and PyTorch-based feature extractors. The hybrid nature is visible in the tension between production-grade pipeline infrastructure and research-oriented algorithms that remain experimental or under-documented. The codebase is actively maintained with recent commits and substantial CI infrastructure, but technical drift is medium due to the enormous optional dependency footprint, vendored copies of cereal/rapidjson/DBoW2, legacy modules such as track_oracle, and some deprecated APIs.
imghash is a Node.js library for computing perceptual image hashes (pHash) using the block mean value based hashing method. It supports PNG, JPEG, BMP, and WebP image formats, and can accept file paths or Buffers as input. The library provides a simple async API to generate hashes in hex or binary format, with configurable bit lengths. It includes utility functions for converting between hex and binary representations. The codebase is written in TypeScript, well-tested with unit and e2e tests, and follows modern JavaScript practices. It handles edge cases such as palette-based PNGs and problematic JPEG images that cause longjmp errors in WebAssembly decoders by falling back to an alternative JPEG library.
AzurLaneAutoScript (ALAS) is a Python-based game automation bot for the mobile game Azur Lane. It uses computer vision (OpenCV, template matching, OCR via cnocr/mxnet) and Android Debug Bridge (ADB) to control an emulator, automating nearly all gameplay loops: campaign sorties, daily missions, research, dormitory, guild operations, Operation Siren, and event-specific maps. The architecture is modular, with a core framework providing device abstraction (module/device), image recognition (module/ocr, module/map_detection), configuration management (module/config), and a web UI (module/webui) built on PyWebIO with an Electron wrapper. Campaign logic is organized into hundreds of per-event map scripts under campaign/, each defining map grids, enemy spawns, and battle strategies via a consistent CampaignBase subclass pattern. The system runs as a daemon, continuously executing scheduled tasks with configurable priorities and notifications (onepush, Discord). External dependencies include uiautomator2, adbutils, OpenCV, cnocr, mxnet, pywebio, and zerorpc, with pinned versions targeting Python 3.7. The codebase is actively maintained with frequent updates for new game events, but suffers from significant duplication across campaign files and reliance on outdated library versions.
Depth Anything V2 is a research codebase for monocular depth estimation, providing both relative and metric depth models. It builds on a DINOv2 encoder with a DPT decoder, offering four model scales (Small, Base, Large, Giant). The repository includes inference scripts for images and videos, a Gradio demo, and a subdirectory for fine-tuning on metric depth estimation using Hypersim (indoor) and Virtual KITTI 2 (outdoor) datasets. It also defines the DA-2K evaluation benchmark for relative depth. The code is well-structured with reusable transform utilities and evaluation metrics, but reproducibility is limited due to hardcoded dataset paths and unpinned dependencies. This is primarily a research project with a hybrid nature due to the included demo application.