thehardwarestore.ai

This is a large polyglot monorepo for WiFi-based human sensing (WiFi-DensePose) that turns commodity WiFi routers into spatial intelligence systems. It captures Channel State Information (CSI) from ESP32 nodes to detect presence, estimate 17-keypoint body pose, measure breathing and heart rate, and track movement through walls without cameras or wearables. The system integrates deeply with Home Assistant via MQTT and Matter, provides a HomeKit bridge, and exposes multiple surfaces: a Rust backend workspace (v2/crates) with 50+ crates for signal processing, privacy shielding (VEIL/BFLD), pose physics, and home automation; Python bindings (PyO3) for ML training and inference; TypeScript CLI and MCP tools for AI agent integration; ESP32-C6/S3 firmware with adaptive sensing; React Native mobile app; Lit-based dashboard; and Tauri desktop app. The architecture is event-driven with a streaming engine, coherence-gated privacy layers, and deterministic verification via SHA-256 golden files. The codebase is heavily ADR-driven with extensive test coverage including cross-language parity gates. While primarily an application, it also contains substantial research code (benchmarks, physics simulations, SOTA surveys) and is best described as a research-informed production platform.

This repository implements a C-based SQLite loadable extension that adds vector search capabilities directly within SQLite databases. It enables similarity search using distance metrics (L2, Cosine, Dot, L1, Hamming) on various vector types (F32, F16, BF16, I8, U8, BIT) without requiring virtual tables. The core architecture is a modular C extension with runtime SIMD dispatch for hardware-accelerated distance calculations, supporting platforms including Linux, macOS, Windows, Android, iOS, and RISC-V. The project provides official language bindings for Python, Node.js, Swift, Flutter, and Android, facilitating integration into diverse application stacks. It includes a TurboQuant implementation for compact 2/3/4-bit quantization, allowing for reduced memory footprint and approximate search with high recall. The codebase demonstrates high craftsmanship in low-level optimization, particularly in its SIMD intrinsics handling and cross-platform binary distribution strategy. While the repository contains benchmarking scripts and quantization research documentation, its primary function is as a production-ready library for edge AI and mobile workloads. It is designed for offline, on-device AI with a low memory footprint (~30MB default). The zero open issues and recent commit activity indicate a stable and actively maintained codebase with low technical drift.

Silero VAD is a pre-trained enterprise-grade Voice Activity Detector library that provides speech detection capabilities for audio signals. The system consists of a core PyTorch model (also available in ONNX format) with Python utilities for audio processing, speech timestamp extraction, and streaming applications. It supports 8kHz and 16kHz sampling rates and includes a VADIterator class for real-time processing. The repository offers multi-language examples (C++, C#, Go, Haskell, Java, Rust) demonstrating integration, along with tools for model tuning and sequence-based ONNX optimization for improved performance on long audio files.

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.

This repository is the official release hub for the MiniCPM family of compact large language models (1B to 8B parameters) from OpenBMB. It provides model weights, deployment scripts for 10+ inference backends (vLLM, SGLang, llama.cpp, Ollama, etc.), fine-tuning recipes for 5 frameworks (TRL, LLaMA-Factory, unsloth, etc.), quantization tools (AWQ, GPTQ, BNB), and application demos (survey generation, MCP tool calling, code interpreter). The repo is primarily a model card and cookbook collection rather than a single integrated application; it serves as a developer toolkit for deploying and customizing MiniCPM models in production and edge scenarios. The repository also includes research artifacts such as training datasets (UltraData suite) and technical reports, but the dominant character is applied machine learning engineering.

This repository is a container build system and runtime for NVIDIA Jetson edge AI devices. It provides a modular, composable framework for building Docker images pre-configured with AI/ML libraries (LLMs, VLMs, robotics, speech, computer vision) optimized for Jetson's ARM64 + CUDA architecture. The system includes a CLI (`jetson-containers`), dependency resolution, multi-stage Docker builds, automated testing, and CI/CD workflow generation. While primarily a build tool, it also ships hundreds of ready-to-use container definitions for popular frameworks like PyTorch, TensorFlow, vLLM, ComfyUI, ROS 2, and Home Assistant. The repository has a hybrid character: the core is an application build system, but many package definitions are research-oriented (e.g., attention kernels, diffusion models, physical AI), reflecting its dual role as both a production deployment tool and an experimentation platform for edge AI.

HailoRT is a production runtime SDK for Hailo AI accelerators. It provides a C/C++ library (libhailort) for loading compiled HEF models, configuring network groups, managing virtual streams (vstreams), and executing synchronous/asynchronous inference on Hailo-8/10/15 devices over PCIe, USB, or Ethernet. The repository also contains a command-line tool (hailortcli) for scanning, benchmarking, power measurement, logging, and firmware control; Python bindings (pyHailoRT); a GStreamer plugin suite (hailonet, hailosend/hailorecv, hailodevicestats); and an RPC-based client/server layer (HRPC) that allows a remote hailo service to own devices and GenAI sessions. It is a hybrid repo in the sense that it includes tutorial notebooks and algorithm modules (NMS, tracking, quantization) that resemble research code, but the dominant character is a software application/SDK. The architecture is layered: a common OS abstraction layer (files, sockets, mmap, events, threads), a VDMA/driver layer for hardware DMA and streams, a core-op/resource-manager layer for memory planning and context switching, a net-flow pipeline layer for pre/post-processing (NMS, YOLO, softmax, quantization), and high-level APIs for infer models and GenAI (LLM/VLM/speech2text). The code uses an Expected monad instead of exceptions, pimpl idioms for ABI stability, buffer pools for high-throughput transfers, and protobuf serialization for HRPC. The codebase is large and professional, with strong modularization, but also carries noticeable internal debt: many HRT-TODO markers, duplicated pipeline construction, hardcoded sysfs/tmp paths, deprecated API overloads, and partial Windows/QNX platform stubs. Maintenance is active; the repo is versioned (v5.4.0) and recently committed. Technical drift is medium because core dependencies are current and the project is clearly under active commercial development, yet some legacy/deprecated surfaces and platform-specific ifdefs remain. As a library, meaningful inference requires Hailo hardware; the build is CMake-driven with external dependencies managed via CMake scripts.

This repository is a comprehensive collection of TensorFlow Lite example applications for on-device machine learning, covering tasks such as image classification, object detection, pose estimation, audio classification, BERT question answering, gesture recognition, and more. It provides complete Android (Kotlin/Java), iOS (Swift), Raspberry Pi, and web implementations, each demonstrating best practices for camera integration, hardware delegate selection, and real-time inference. Additionally, the repository includes the TensorFlow Lite Model Maker library, which offers high-level APIs for training and exporting custom TFLite models from user data, along with research/educational models (DenseNet, pix2pix, NMT). While the codebase shows some duplication across platforms and occasional legacy API usage, it remains a valuable reference for developers building edge ML applications.

This repository is a collection of C++ sample programs for deploying deep learning models on AXERA AI SoCs (NPU chips). It provides ready-to-run inference examples for a wide range of computer vision tasks including object detection (YOLOv5/6/7/8/9/10/11/26, YOLOX, YOLO-World, PPYOLOE+, RT-DETR, SCRFD), instance segmentation, oriented object detection (OBB), pose estimation, depth estimation, semantic segmentation, stereo matching, and more. Each example is a standalone command-line executable that loads a pre-compiled .axmodel, runs inference via the AX_ENGINE API, post-processes the outputs, and saves a result image. The code is organized per target chip (ax650, ax637, ax620e, ax615) with near-identical copies of examples across platforms, differing only in system initialization and minor chip-specific logic. The architecture is not a library or framework but a set of reference implementations demonstrating the integration of AXERA's NPU SDK. The primary data flow is: load image → preprocess (letterbox resize, color conversion) → push to engine → run synchronous inference → decode model outputs (e.g., anchor-based proposals, DFL, NMS) → draw bounding boxes/keypoints/masks → save output. External dependencies include the AX_ENGINE runtime, OpenCV for image processing, and standard C++ libraries. The build system uses CMake with per-chip toolchain files and GitHub Actions CI for cross-compilation verification. While the code is functional and covers a broad model zoo, it exhibits significant duplication across chip directories and hardcoded configuration (thresholds, image sizes, class names). The monolithic detection.hpp (~3500 lines) bundles many model-specific post-processing functions, increasing maintenance burden. There are no automated tests, and manual memory management is prevalent. Despite these quality issues, the repository serves its purpose as a practical reference for developers integrating AXERA hardware, and it stays current with recent model releases (YOLOv13, YOLO26, Depth Anything V2).

This repository is a comprehensive collection of AI model demos and sample applications for Sophgo's Sophon TPU hardware (BM1684X, BM1688, CV186X). It provides both Python and C++ implementations for running inference on a wide range of models including object detection (YOLO variants, CenterNet), segmentation (SAM, YOLACT), OCR (PP-OCR, LPRNet), large language models (Qwen, ChatGLM, MiniCPM), speech recognition (Whisper, WeNet), text-to-speech (ChatTTS, VITS), and multi-modal models (CLIP, BLIP, GroundingDINO). The repository also includes full application demos such as a document QA chatbot (ChatDoc), an audio assistant pipeline (ASR+LLM+TTS), multi-channel video processing with Qt GUIs, and OpenAI-compatible API servers. The primary architecture is a set of independent, self-contained demos, each with its own model compilation scripts (using TPU-MLIR), inference code, and evaluation tools. While the codebase is functional and covers a broad spectrum of AI models, it suffers from significant code duplication across samples, hardcoded paths, and some outdated dependency versions, making it more of a demo showcase than a production-ready library.