thehardwarestore.ai

This repository provides a comprehensive, opinionated Docker Compose configuration for building a self-hosted NAS (Network Attached Storage) system on a vanilla Linux box. It orchestrates a suite of containerized services for media management (Sonarr, Radarr, Lidarr, Bazarr, Prowlarr, Jellyfin, Jellyseer), download automation (qBittorrent, SABnzbd, Unpackerr, Cross-Seed, Autobrr), and home utilities (Homepage, Traefik, AdGuard Home, Home Assistant, Immich, Vaultwarden, Paperless-ngx, Tandoor, Joplin). The architecture relies on Docker Compose profiles to enable optional services, Traefik as a reverse proxy with Let's Encrypt SSL, and a WireGuard VPN (via PIA) to isolate torrent traffic with port forwarding. The configuration is designed for hardlink support between the download client and media managers to avoid storage duplication.

This repository is a work-in-progress decompilation of The Legend of Zelda: Twilight Princess for GameCube and Wii. It reconstructs the original game's source code from its compiled binary, aiming for byte-perfect reproducibility. The codebase is a hybrid of reversed-engineered game logic, reimplemented Nintendo SDK libraries (JSystem, Dolphin, Revolution), and a massive collection of asset resource headers that define model, animation, and collision IDs for every in-game object. The architecture follows the original game's custom actor framework (f_op/f_pc) combined with middleware from JSystem and the Nintendo SDK. The project supports multiple region and platform variants (GameCube, Wii, Nvidia Shield), with resource headers duplicated across version-specific directories. The decompilation is incomplete; many source files are stubs or placeholders (marked NONMATCHING), and the asset headers are auto-generated or manually copied from the original game's data. The code is written in C++ with Metrowerks compiler conventions, and the build system uses Python and Ninja. While not a runnable application on its own (requires a copy of the game), it represents a comprehensive reverse-engineering effort with active development and community engagement.

ChatWiki is an open-source, multi-service AI chatbot and workflow automation platform primarily targeting the WeChat ecosystem. In production, it operates as a suite of Go microservices (chatwiki, message_service, code_run, websocket, plugin, llm_runner) behind a Gin web server, with a Vue 3 admin panel, separate mobile/PC/Electron frontends, and an embeddable SDK. The core functionality includes knowledge base management (document ingestion, chunking, vector storage with pgvector), a LogicFlow-based visual workflow builder, multi-channel messaging (WeChat Official Account, Mini Program, Feishu, DingTalk, Telegram, WhatsApp, LINE), and an AI agent framework called Clawbot with skill reuse. External dependencies include PostgreSQL (with pgvector and AGE graph extension), Redis, NSQ message queue, and optional Neo4j and E2B sandbox. While the system is primarily an application, it incorporates data-intensive components such as RAG pipelines, LLM request logging, and daily statistics, giving it a hybrid character.

SmallCode is an open-source AI coding assistant CLI designed to run locally on consumer hardware with small language models (8B–35B parameters). It provides a full-screen terminal UI with streaming output, tool execution, and multi-turn agent loops. The system compensates for small-model limitations through a context budget engine, forgiving JSON parser, patch-first editing, early-stop detection, and TODO-driven planning. It supports multiple LLM providers (Ollama, LM Studio, llama.cpp, OpenAI, Anthropic, DeepSeek) with automatic escalation to stronger models on hard failure. The architecture is a monolith agent loop with modular subsystems: a plugin system for tools, commands, and hooks; a skill system for reusable prompt templates; a knowledge injection system for contextual notes; a memory store with SQLite/FTS5; a RAG index for code snippet retrieval; and an MCP client/server for tool interoperability. The codebase includes a compiled MarrowScript cognition layer with typed prompts, output validation, and budget tracking, though the dual implementation (hand-ported JS alongside MarrowScript sources) introduces drift risk. Key entry points include bin/smallcode.js (main CLI), src/tui/fullscreen.js (zero-dependency TUI), and src/compiled/cognition/ (prompts, routers, validation). The agent loop orchestrates user input, model calls, tool dispatch, and improvement loops. The repository also includes benchmark harnesses, trace recording, evaluation runners, and a provider wizard for configuration. Despite being marked as 'dead' in the README, the codebase exhibits high craftsmanship in several reusable components, though the large feature surface and experimental nature suggest maintenance challenges.

fridaUiTools is a PyQt5 desktop application that serves as a comprehensive workbench for Android reverse engineering using Frida. It integrates dozens of Frida scripts for common tasks such as SSL unpinning, DEX dumping, JNI tracing, memory scanning, native hooking, and anti-debug bypass. The tool provides a unified GUI with attach/spawn modes, USB/WiFi connectivity, Frida server management, and AI-assisted script generation and log analysis. The architecture is a monolithic PyQt5 application with a main window (kmainForm.py) that orchestrates multiple dialog forms (e.g., SearchMemory, Wallbreaker, ZenTracer) and a background thread (TraceThread) for Frida script execution. While the codebase is functional and feature-rich, it suffers from tight coupling, duplicate scripts, hardcoded paths, and some dead code, making it more of a practical tool than a reference-quality codebase.

nfqws-keenetic is a distribution and packaging repository that delivers the `nfqws` DPI-bypass utility (from the zapret project) as installable packages for embedded routers — primarily Zyxel Keenetic/Netcraze devices running Entware, plus OpenWRT. In production it functions as a service installer: post-install scripts detect the WAN interface and IPv6 availability, write a tuned nfqws.conf, install the correct architecture-specific nfqws binary, and register an init script that programs iptables/ip6tables POSTROUTING NFQUEUE rules for TCP/QUIC/UDP ports and manages the daemon lifecycle. The traffic-modifying logic itself lives in the upstream nfqws binary; this repo is the glue: packaging, configuration, firewall orchestration, and domain/IP lists (user.list, auto.list, exclude.list, ipset lists) for targeted DPI evasion. Architecturally it is a Makefile-driven build system (packages.mk, repository.mk) that downloads the latest zapret release binaries from GitHub at build time, cross-packages them into per-arch .ipk files (mipsel, mips, aarch64, and a multi-arch 'all' variant), and assembles an opkg/apk repository published to GitHub Pages via a GitHub Actions pipeline. The service layer is split into reusable POSIX-shell fragments: etc/init.d/common holds idempotent firewall rule management, kernel-module autoloading, runtime config generation, and validation; thin platform wrappers adapt it to Entware (S51nfqws) and OpenWRT (procd). A Keenetic netfilter hook (etc/ndm/netfilter.d/100-nfqws.sh) re-applies firewall rules whenever NDM regenerates them. Important maintenance truth: the README explicitly states the project no longer receives updates and all new features will appear in nfqws2-keenetic; this repo is the legacy v1 line (tag v2.11.4). An agent searching for an actively developed solution should evaluate the successor first, but the code that exists is well-crafted for its niche — config-versioned package migrations, layered architecture auto-detection in a single multi-arch package, and careful iptables rule idempotency. Technical drift is moderate: the release workflow relies on deprecated GitHub Actions (create-release v1, upload-release-asset v1), while the shell and packaging code targets stable router interfaces.

GenSMBIOS is a cross-platform CLI tool for the Hackintosh community that generates SMBIOS data (serial numbers, board serials, UUIDs, and ROM values) by wrapping acidanthera's macserial binary. It writes generated values directly into both Clover and OpenCore config.plist files, using OrderedDict parsing to preserve key order and stripping unsupported keys from Clover SMBIOS sections. The tool is distributed as a plain Python script plus Windows (.bat) and macOS/Linux (.command) launchers that locate, download, and even silently install Python when missing. Architecturally it is a menu-driven monolith with small utility modules: a hand-rolled plist library supporting XML and binary formats with Python 2/3 compatibility, a resumable HTTP downloader with live progress/ETA display, a subprocess streaming wrapper, and general CLI helpers. The macserial binary is fetched at runtime from the latest OpenCorePkg GitHub release by scraping HTML rather than using a stable API, and the Python installers similarly scrape python.org pages - functional but brittle. Code quality is solid for a hobbyist project: clean method organization, settings persistence, error handling, and genuinely reusable utility modules. The main weaknesses are the absence of tests, no CI pipeline, no packaging (setup.py/pyproject.toml), lingering Python 2 compatibility shims, and monkey-patching of plistlib internals that has required version-specific workarounds (e.g., Python 3.9's removal of use_builtin_types). Overall it does what it claims well within a niche domain, with medium technical drift.

NootedRed is a Lilu kernel extension (kext) for macOS that enables AMD integrated GPUs (Raven/Picasso/Renoir/Green Sardine) on Hackintosh systems. It works by patching Apple's closed-source AMD graphics kexts (AMDRadeonX5000, AMDRadeonX6000Framebuffer, AMDRadeonX5000HWLibs) via binary pattern matching, runtime vtable/meta-class injection, and direct register manipulation. The codebase is derived from decompilation and reverse-engineering of Apple's drivers, containing extensive embedded firmware blobs (DMCU, GC, SDMA, PSP), register definitions, and version-specific workarounds for macOS Catalina through Sequoia. While the project is functionally successful and actively maintained, its engineering quality is constrained by the inherent fragility of binary patching and tight coupling to specific kext versions, resulting in technical debt such as hardcoded offsets, many TODOs, and complex version-conditional logic.

MaterialSearch is a local media search engine that enables natural language search over personal photos and videos using the CLIP multimodal model (Chinese-CLIP-vit-base-patch16). The system supports text-to-image, image-to-image, text-to-video, and image-to-video search, as well as similarity scoring. The repository contains the frontend code (Vue.js 3 with Element Plus UI), authentication pages, internationalization files, a Tkinter-based configuration GUI for Windows, and Docker deployment configuration. The core backend logic (Flask API, CLIP model inference, media indexing) resides in a separate closed-source package (`materialsearch-core`). The application is designed for local deployment, with optional GPU acceleration, and is packaged as Docker images or Windows bundles. It is primarily maintained by the original author with limited community contribution due to obfuscated source code and an auto-closing issue policy.

This repository is not a software application, service, or data pipeline. It is an "awesome list": a manually curated Markdown directory of WebGPU resources. The only substantive content is readme.md, which organizes links into roughly a dozen categories: official specifications, browser support details, articles, tutorials, books, libraries, debuggers/profilers, gists, demos, videos, presentations, community channels, and bug-reporting trackers. It includes enablement instructions for Chrome, Firefox, Safari, and iOS/iPadOS, and points to both the W3C WebGPU/WGSL specifications and the MDN API reference. The repository is maintained as a community resource: it is CC0-licensed, has contribution guidelines and a code of conduct, and receives regular commits. Its value is informational rather than executable—there are no build scripts, package manifests, tests, entry points, or runtime dependencies. It is best used as a discovery reference for engineers evaluating WebGPU libraries, WGSL tooling, rendering engines, or GPU compute examples. The list also internally flags stale debugger projects, demonstrating careful curation. Because this repo contains no source code, there are no reusable software components, libraries, or data assets to extract. Its quality should be evaluated as documentation and curation, not as software engineering.

This repository is an automated IPTV playlist aggregation and publishing pipeline for Chinese-language live television. It continuously fetches dozens of external IPTV source lists, normalizes channel names against a large alias dictionary, filters dead or unwanted streams using manual and auto-generated blacklists, categorizes channels into genres (CCTV, satellite, regional, Hong Kong/Taiwan, VOD, sports), and outputs multiple playlist formats including TXT and M3U variants. The pipeline is driven primarily by main.py and GitHub Actions workflows that run daily, producing files like bbxx365.txt, live.m3u, and a sports page tiyu.html.

FreeStuffDev is a static website built with Astro that curates a categorized list of free tools and services for developers. It consists of a collection of Markdown files (over 900 entries) with frontmatter metadata (title, link, thumbnail, tags, etc.), which are rendered at build time into pages like the home page, tag filters, and alternative suggestions. The site is fully client-side for search, sorting, and favorites (via localStorage). It has no backend or API, and relies on GitHub for contribution. The codebase is straightforward and well-organized, demonstrating a clean content-driven static site pattern. It is not a software application in the traditional sense but a content directory, though its architecture is a standard Astro application.

Unimatrix is a single-file Python CLI application that simulates the 'Matrix' digital rain effect in the terminal using the curses library. It provides a rich set of customizable options including speed, color, bold, character sets (katakana, emoji, Klingon, custom strings), asynchronous scrolling, flashers, and interactive keyboard controls. The architecture is a monolith with a main loop that manages a canvas of columns and nodes to draw and erase characters. It requires no external dependencies beyond Python's standard library. The code is well-structured for a single-script application, with clear class separation (Canvas, Column, Node, Writer, KeyHandler, Status), but it is not designed for reuse as a library or for integration into larger projects. The bundled Klingon fonts are provided as assets for character rendering.

BooruDatasetTagManager is a Windows Forms desktop application (C# .NET) for editing tags in image datasets used to train Stable Diffusion hypernetworks, embeddings, and LoRAs. It loads a folder of images with associated .txt tag files, provides a rich UI for tag editing (add, delete, reorder, weight, undo/redo), batch operations, filtering, translation, and auto-tagging via a companion Python AI server (Flask/FastAPI). The Python server supports multiple vision-language models (BLIP, Florence2, JoyCaption, Qwen, etc.) for captioning and tagging, plus background removal and translation. The architecture is a monolithic WinForms client with a separate AI inference server, communicating over HTTP. The codebase is functional and feature-rich but shows signs of monolithic design (large forms, static global state) and some deprecated practices (BinaryFormatter). Several components, such as the universal diffusion metadata parser (Metadata.cs) and the WebP codec wrapper, are well-isolated and potentially reusable in other projects.

This is an Android utility application for Google Pixel devices that provides privileged management of IMS (IP Multimedia Subsystem) and carrier network settings. It allows users to toggle VoLTE/VoNR/ViLTE/VoWiFi, adjust 5G display behavior, fix captive portal and TikTok network issues, modify APN settings, and perform diagnostics. The app is a fork of TurboIMS with enhancements for Chinese mainland carrier compatibility and includes monetization features such as ads, donations, and ad-free purchases. The architecture is layered: a Kotlin/Compose UI frontend (Material 3 theme) communicates with a Shizuku-based privilege escalation layer that executes isolated operations via Instrumentation subclasses (e.g., ImsModifier, ConfigReader, SimReader). Key entry points include MainActivity (five-tab UI), LogcatActivity, DumpActivity, and four Quick Settings tile services. Data flows involve reading/writing CarrierConfigManager overrides, querying SIM information via internal ISub interface, and performing network diagnostics. External dependencies include Shizuku for root access, Android internal telephony APIs (accessed via AIDL stubs), GitHub Releases for update checks, DoDoPay for payment processing, and Muggle Leads for advertisements. The app is heavily reliant on Shizuku and internal Android APIs, making it fragile across Android versions, though the code includes multiple fallback paths and version checks to mitigate drift. The codebase demonstrates reusable patterns such as ring-buffer log capture, reflection-based API compatibility, and feature-to-config mapping. However, the main activity is monolithic and the reliance on hidden APIs poses long-term maintenance risks.

This repository defines the Transit data interchange format (v0.8), a cross-language serialization specification for conveying values between applications. It does not contain any implementation code for reading or writing Transit; instead, it provides the authoritative specification (README.md), a comprehensive suite of example data files in multiple representations (EDN, JSON, verbose JSON, MessagePack), and a Clojure-based testing infrastructure to verify that third-party Transit implementations correctly encode/decode according to the spec. The test harness in `src/transit/verify.clj` orchestrates roundtrip tests by invoking external implementation processes (via `bin/verify`), using both hand-crafted corner cases and generative random data to ensure correctness. The repo acts as the central reference for all Transit implementations across languages including Clojure, Java, JavaScript, Python, Ruby, and others.

OsEngine is a full-featured algorithmic trading terminal for the Windows desktop, written in C# with a WPF/WinForms hybrid UI. It provides a plugin-based exchange connectivity layer supporting over 40 crypto, stock, and derivatives exchanges (Binance, MOEX, Interactive Brokers, etc.) through a unified `IServerRealization` interface. The platform includes a live trading robot framework with over 300 built-in strategies, a backtesting engine (`TesterServer`), a walk-forward optimizer (`OptimizerMaster`), historical data management (`OsData`), and a technical indicator library with 100+ indicators. A Model Context Protocol (MCP) JSON-RPC API exposes terminal control to external AI agents, allowing them to create and manage robots, run tests, and configure exchanges via chat-based interfaces. The architecture is monolithic but modular, with separate executables for data, tester, optimizer, and live trading, all sharing the same codebase via project references.

Agregarr is a full-stack Plex collection management application built with Next.js and Express, written in TypeScript. It automates the creation, synchronization, and visual customization of Plex collections by integrating with numerous external media sources and APIs including Trakt, TMDB, IMDb, Letterboxd, MDBList, AniList, MyAnimeList, Tautulli, Overseerr, Radarr, and Sonarr. The core architecture follows a monolithic pattern: a single server process running both the React frontend and Express backend, with SQLite persistence via TypeORM and a robust migration system. In production, Agregarr performs scheduled full syncs and incremental quick syncs of collection definitions to Plex, applies poster overlays based on configurable conditions (ratings, resolution, audio codecs, HDR formats), manages placeholder items for upcoming content, and can auto-request missing media through Radarr/Sonarr or Overseerr. The UI provides per-library collection views with drag-and-drop reordering, a visual poster editor with snap-to-guides and layering, an overlay editor with condition evaluation, and dashboard statistics from Tautulli. The codebase demonstrates solid engineering with clear separation of concerns, a template method pattern for collection sources (`BaseCollectionSync`), consistent API client wrappers, and modular UI form sections. However, it carries significant maintenance overhead from fragile web scraping (IMDb WAF, Cloudflare bypass), a large dependency surface including Chromium and Playwright, commented-out legacy code from its Overseerr fork, and reliance on external APIs that may change unexpectedly. The project is actively maintained with frequent migrations and feature additions.