thehardwarestore.ai

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.

Dolphin is a document image parsing tool that uses a two-stage analyze-then-parse approach with a VLM (Qwen2.5-VL). It takes images or PDFs, performs layout analysis to detect elements (text, tables, formulas, code, figures) with reading order, then parses each element in parallel batches. Outputs structured JSON and Markdown with visualized layout. The codebase is well-structured, offering CLI entry points for page-level, element-level, and layout-only parsing. It demonstrates good engineering practices with batching, coordinate mapping, and post-processing for formula/special characters. The core implementation wraps the Hugging Face Qwen2.5-VL model and includes utility modules for layout string parsing, PDF conversion, and markdown generation. The architecture is a CLI application with minimal coupling, making the utility modules potentially reusable across document parsing projects.

This repository implements an AI-agent skill that converts images, PDFs, and image-based PPT/PPTX files into fully editable PowerPoint (.pptx) documents. The system uses a deterministic CLI state machine (`editppt`) with a four-phase workflow: normalize input into per-page jobs, dispatch to subagents for page reconstruction, record page manifests, and finalize by rebuilding the PPTX from manifests. It integrates OCR (PaddleOCR or offline detector) for text bounding boxes, image generation/editing backends (built-in, OpenAI-compatible, or Codex OAuth), and LaTeX rendering for formulas. The output preserves native text boxes, shapes (including custom paths and polygons), tables, images, and speaker notes, with strict provenance tracking for all assets. The codebase is well-structured with clear separation of concerns, a manifest-driven assembly pattern, and comprehensive tests. However, the last commit date is anomalously in the future (2026-09-16), suggesting the repository may be abandoned or the timestamp is erroneous; combined with only 1 open issue and no recent activity, it is classified as stale. The technical drift is low as the code uses modern Python and standard libraries, but external dependencies (OCR, image APIs, LaTeX) may become incompatible over time.

pymupdf4llm is a library and CLI tool that converts PDFs (and other documents) into clean Markdown, JSON, plain text, or layout-aware chunks specifically optimized for LLM and RAG workflows. It provides a high-level API (`to_markdown`, `to_json`, `to_text`, `to_chunks`) that internally uses either a legacy heuristic approach or an optional GNN-based layout parser (via `pymupdf-layout`) to extract text, tables, images, and reading order. The repository also includes a deterministic chunking pipeline that uses only PDF-native layout signals (box boundaries, font jumps, vertical gaps) to produce context-preserving chunks without embeddings. OCR support is built-in, with a hybrid decision model (ONNX-based) that selectively applies Tesseract, RapidOCR, or PaddleOCR to pages that need it. Framework integrations for LlamaIndex and LangChain are provided. The architecture is primarily a monolithic library with two parallel conversion paths (legacy and layout-based), a chunking subpackage, an OCR subsystem with abstract backends, and a batch converter for large-scale processing. While the code is generally well-structured, the presence of two parallel conversion paths and tight coupling to PyMuPDF internals introduce some maintenance risk.

Hawk-Eye is a command-line application designed to scan various data sources for Personally Identifiable Information (PII) and secrets. It supports cloud storage (S3, GCS, Firebase), databases (MySQL, PostgreSQL, MongoDB, Redis), file systems, and collaboration platforms (Slack, Google Drive). The tool uses regex pattern matching and OCR to detect sensitive data in multiple file formats including images, PDFs, Office documents, and videos. The architecture is modular with a central dispatcher in main.py that routes commands to specific implementations in the commands/ directory. Shared functionality like file reading, OCR, and pattern matching is encapsulated in internals/system.py. This design allows easy extension to new data sources by adding new command modules. The tool is intended for security auditing and can be run standalone or integrated into scripts/CI/CD pipelines. Features include alert deduplication, severity-based reporting, and Slack/Jira integrations. Despite its comprehensive feature set, the tool maintains separation of concerns, making it maintainable and extensible. The use of third-party libraries for specific data sources keeps core logic focused on scanning and reporting.

WFInfo is a Windows desktop companion application for the game Warframe, built with WPF (.NET Framework 4.8). It uses OCR (Tesseract) to scan in-game reward screens, inventory items (SnapIt), and profile screens, then looks up real-time platinum and ducat prices from warframe.market. The architecture follows a service-oriented pattern with dependency injection (Microsoft.Extensions.DependencyInjection) for screenshot capture (GDI or Windows Graphics Capture), window information, HDR detection, and process finding. Key features include auto-detection of fissure rewards via Warframe's log file, a configurable overlay for price display, warframe.market listing management, language-specific text normalization (11+ locales), and a theme adjuster for OCR filtering. The application is Windows-only and tightly integrated with game UI, making it highly specialized but well-architected within its domain.

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.

Koodo Reader is a cross-platform ebook reader application supporting a wide range of formats (EPUB, PDF, MOBI, AZW3, TXT, FB2, CBR/CBZ, MD, DOCX, HTML, etc.). It is built as an Electron desktop app with a React/TypeScript frontend and a separate Go HTTP server for OPDS catalog serving and KOReader sync. The application provides a full-featured reading experience including bookmarks, notes, highlights, text-to-speech (with multiple voice engines), translation and dictionary lookup (via built-in and custom plugins), OCR for scanned PDFs, and cloud sync/backup across many providers (WebDAV, S3, OneDrive, Google Drive, Dropbox, etc.). It also includes a library management system with shelves, tags, search, and import from local files, folders, URLs, and OPDS catalogs. The architecture is a monolith with a clear separation between the Electron main process (Node.js) and the renderer (React), plus an optional Go server for network-facing features. The codebase is large and feature-rich but shows signs of technical debt: widespread use of deprecated React lifecycle methods, heavy reliance on opaque minified libraries (kookit-extra), frequent `as any` type casts, and mixed Chinese/English comments. Despite these issues, the application is actively maintained and offers a robust set of features for ebook enthusiasts.

gImageReader is a mature, feature-rich desktop application that serves as a graphical frontend to the Tesseract OCR engine. It allows users to import images, PDFs, and DjVu documents, perform optical character recognition (OCR) with automatic or manual layout detection, and export the recognized text as plain text, hOCR (HTML-based OCR), PDF, or ODT. The application also integrates with scanner hardware via SANE (Linux) and TWAIN (Windows) backends, supports batch processing, and includes a spell checker, find/replace, and a substitution manager for post-processing. It is written in C++ and provides two parallel user interfaces: one using GTK+3 (gtkmm) and another using Qt5/Qt6, sharing a common core library in the `common/` directory. The architecture is a classic desktop monolith with a clear separation between the UI layer (GTK or Qt) and the backend logic (OCR, file handling, export). The codebase is well-organized with dedicated modules for scanning, image display, recognition, output editing, and export. Notable design patterns include a CRTP-based settings system (`ConfigSettings`), a custom tree model for file lists, and a worker-thread pattern for background scanning and rendering. The project has been actively maintained for over a decade, with recent commits and a large user base, though the dual-frontend approach introduces code duplication and maintenance overhead. While the application is not a research project, it demonstrates solid software engineering practices for a desktop GUI application. The most reusable components are the isolated utility classes in the `common/` directory, such as the CCITT Fax4 encoder, paper size definitions, and language mapping tables. These can be extracted and reused in other document-processing or PDF-generation projects with minimal modification. The overall code quality is good, with some areas showing age (e.g., version compatibility macros, WIP proofreading widget) but still functional and well-tested by the community.

DeepSeek-OCR is an inference repository for a multimodal OCR model that combines vision encoders (SAM and CLIP) with a large language model (DeepSeek-V2/V3) to perform optical character recognition with layout awareness, supporting native and dynamic resolution processing. The system provides two inference paths: a Hugging Face Transformers integration for simple usage and a custom vLLM integration for high-throughput batched inference, including PDF processing and evaluation benchmarks. The architecture is a monolithic model definition with separate modules for vision encoding (deepencoder), image preprocessing (process), and vLLM glue code, all tightly coupled to the specific model architecture. The codebase is functional and demonstrates competent engineering for research-grade inference, but lacks production hardening, documentation, and consistent coding standards.

SnapX is a cross-platform screenshot and screen recording tool, forked from ShareX, with extensive upload capabilities to dozens of services (image hosts, file storage, pastebins, URL shorteners). It features image effects (adjustments, filters, manipulations), OCR via PaddleOCR, QR code generation/scanning, hotkey automation, and clipboard monitoring. The application is built with Avalonia UI and .NET 10, targeting Linux, Windows, macOS, and FreeBSD. It includes a CLI, a native messaging host for browser integration, and a comprehensive settings system. The codebase is in early access with many features ported from ShareX but several stubs and incomplete implementations remain, particularly in screen recording, image annotation, and some uploaders. The architecture follows a core library (SnapX.Core) with separate UI (SnapX.Avalonia) and CLI projects, using MVVM pattern and dependency injection. While functional, the project exhibits significant technical debt and incomplete feature parity with its predecessor.

This repository is a desktop application for extracting subtitles from video files using OCR and subtitle detection. It integrates PaddleOCR inference models for text recognition, uses a separate binary tool (VideoSubFinder) for detecting subtitle regions, and employs the Sushi library for subtitle synchronization. The application is written in Python with a PyQt-based GUI (gui.py) and provides a modular backend with separate modules for OCR, subtitle detection, concurrent task management, and hardware acceleration. The project includes pre-compiled binaries for Windows, Linux, and macOS, as well as CI/CD workflows for building Windows executables. While the overall architecture is functional and suitable for its purpose, the code's internal quality and reusability cannot be fully assessed without inspecting source contents. The repository is actively maintained and has a large user base, but it is primarily a monolithic application rather than a reusable library.

Clipy is a macOS clipboard extension app that lives in the menu bar. It provides clipboard history management, text snippet storage and quick paste, OCR for image-based clipboard content, and customizable global hotkeys to trigger history menu, snippet editor, or paste actions. The app monitors NSPasteboard using a timer, deduplicates entries, and stores them in a local SQLite database (via GRDB wrapper SQLiteData), with a legacy Realm database still present for migration. UI is built with a mix of SwiftUI (settings panes) and AppKit (snippet editor, menu). Dependency injection via swift-dependencies and reactive storage via swift-sharing are used throughout. The architecture is well-modularized with repository and service layers, extensive unit tests, and a migration system for both database schema and user defaults. However, the project shows signs of drift: legacy Realm code and XIB files persist, localization strings may be out of sync, and the last commit date is anomalous (future date) suggesting the project may be unmaintained despite a large user base.

This repository is a comprehensive AI inference and application platform built primarily on Java (Spring Boot) and Vue.js. It provides a suite of SDKs for computer vision (face recognition, OCR, segmentation), NLP (text embedding, translation), and AIGC (Stable Diffusion, ControlNet). The architecture is modular, separating inference logic (SDKs) from application logic (Web Apps, Desktop Apps, API Platform). It utilizes Deep Java Library (DJL) for model inference, integrating PyTorch and ONNX Runtime backends. The system supports multimodal search (Face, Image, Code, Text) using vector databases like Milvus. Hybridity: While it contains AI research components (models, inference), the codebase is structured as a production-ready software platform with web interfaces, APIs, and desktop wrappers, rather than a research notebook collection. It functions as a monorepo containing multiple distinct Spring Boot applications and Vue.js frontends, each serving a specific AI task (e.g., face_search, image_search, aigc_image_gen).

This repository is a personal cookbook and project showcase centered on the MiniCPM family of large language models (MiniCPM, MiniCPM-V, MiniCPM3). It contains over a dozen distinct application projects, including multi-modal OCR + visual grounding (OCR_VG), cross-modal image-text search, ReAct-style agent planning (agent_auto_plan), MBTI personality role-play, low-memory RAG (4G_memory_rag), AWQ quantization, embedding extraction, SFT/DPO fine-tuning pipelines, and Windows agent demos. Each project includes source code, shell scripts, and accompanying Chinese/English tutorials in markdown format. The codebase is primarily a collection of independent, loosely coupled modules rather than a unified application. It demonstrates practical usage of MiniCPM models for fine-tuning, deployment with vLLM/Ollama/llama.cpp, and integration with LangChain. The quality is functional but inconsistent: many modules contain hardcoded paths, duplicated logic, and lack tests, yet several components (ReAct data generation, image slicing utilities, LangChain wrapper) exhibit sufficient isolation and craftsmanship to be reusable across projects. The repo is actively maintained with a recent commit, but dependency on unmerged forks and version-specific model files poses a medium technical drift risk.

This repository implements a desktop application for batch processing EPUB ebooks, including reformatting, encryption/decryption (filename obfuscation), font encryption/decryption with OCR-based recognition, image compression and conversion, cover replacement, and Chinese text conversion. The application is built with Tauri 2 (Rust) as the desktop shell, Vue 3 with TypeScript for the frontend, and a Python sidecar for the heavy processing tasks. Communication between the frontend and Python backend uses a JSON Lines protocol over stdin/stdout, with protobuf schemas defining the message envelopes. The architecture follows a clear separation of concerns: the Rust layer manages the application lifecycle, window effects, and sidecar process; the Vue frontend provides a drag-and-drop interface with task panels, persistent state management, and custom UI components; the Python backend implements a task runner that dispatches work to specialized service modules for EPUB structure manipulation, font obfuscation with ONNX OCR inference, image processing, and text conversion. The system includes a comprehensive test suite covering unit tests, integration tests, and protocol contract tests. Notable design patterns include a reusable EPUB workspace abstraction with security validation, a protocol layer with dataclass-based request/response models, safe JSON serialization handling edge cases like lone surrogates, and Vue composables for persistent state and Tauri IPC bridging. The font encryption/decryption services demonstrate advanced CSS cascade emulation and glyph rendering with OCR, though they contain significant code duplication. The README explicitly states that this repository is historical and that EPUB capabilities have been migrated to a Rust implementation (epub_tool_rust). As such, the project is deprecated and no longer actively developed, but the codebase remains a well-structured example of a cross-platform desktop application with a Python sidecar.