thehardwarestore.ai

This is an ESLint plugin that provides a single rule, `ban-dependencies`, which flags usage of npm packages that have better alternatives or are redundant. It uses presets (e.g., native, microutilities, preferred) from the `module-replacements` package to suggest replacements. The plugin also supports user-defined module bans and allowlists, and can lint `package.json` files to detect banned dependencies. The codebase is written in TypeScript, well-tested, and follows modern ESLint plugin conventions. The repository appears to be superseded by `@e18e/eslint-plugin` as noted in the README, and is likely no longer actively developed.

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.

This repository implements a self-hostable data integration platform for building, deploying, and managing ETL/ELT pipelines. The system features a polyglot microservices architecture: a React frontend (app-ux) for workflow visualization and configuration, two Spring Boot backend services (mgmt-svc for management APIs and ingestion-svc for event intake), and a Node.js processor for executing pipeline transformations. Core functionality includes defining sources, transformations, and destinations; scheduling pipelines via cron; monitoring execution metrics; role-based access control with SSO support; and a plugin architecture for community-contributed apps. Data flows involve ingestion services writing events to PostgreSQL queues, the processor executing transformation steps in sandboxed VMs, and delivering results to destinations. The platform emphasizes secure handling of sensitive data via encryption utilities and provides extensibility through dynamic script execution.

This repository provides `oci-runtime-tool`, a command-line tool for generating and validating OCI (Open Container Initiative) runtime configuration files (`config.json`) according to the OCI Runtime Specification. It also includes `runtimetest`, a compliance testing binary that runs inside containers to verify runtime behavior against the specification. The project is written in Go and serves as both a utility for container runtime users and a conformance testing framework for runtime implementors. The architecture is a Go CLI built with the `urfave/cli` library, with two main commands: `generate` (creates `config.json` from command-line flags) and `validate` (checks a bundle's configuration against the spec). The compliance tests are standalone TAP-producing executables that exercise a real OCI runtime (default `runc`) through its lifecycle (create, start, state, kill, delete). The codebase is organized into packages for generation, validation, spec error handling, cgroup interaction, and file path utilities. Key data flows: The `generate` command collects flags and builds an OCI spec object, then serializes it to JSON. The `validate` command loads a bundle, parses the config, and runs a series of checks against the spec, filtering by compliance level. The `runtimetest` binary is copied into a container and executes checks on the runtime environment (cgroups, mounts, seccomp, capabilities, etc.), outputting TAP results. External dependencies include the OCI runtime (`runc`), cgroup filesystems, and network access for JSON schema downloads.

Cloner is a Laravel package that provides a trait for Eloquent models to duplicate models, their relationships, and file attachments. The core functionality resides in the Cloner service class which handles the cloning process, including relationship traversal and file duplication via an adapter pattern. The package supports cloning to the same or different database connections (with limitations for many-to-many relations across databases) and fires events during the cloning process. It is designed as a reusable library for Laravel applications, with a service provider for easy integration.

This repository hosts a static documentation site built with MkDocs and the Material theme, which serves as a redirect page for the Data Engineer roadmap. The site consists of a single HTML page that informs users the roadmap has moved and provides a button to access the new roadmap via a Telegram bot. The repository includes the MkDocs configuration, a custom CSS theme, and a small JavaScript enhancement for user interface improvements (scroll-to-top button and clickable site title). The site is built and deployed to GitHub Pages via a GitHub Actions workflow.

ChefBoost is a Python library implementing decision tree algorithms (ID3, C4.5, CART, CHAID, regression) and ensemble methods (AdaBoost, Gradient Boosting, Random Forest). It provides a simple API for building models from pandas DataFrames and making predictions. The library handles both categorical and numerical features without requiring preprocessing. Architecture consists of modular components: main interface (Chefboost.py), utilities (commons/), core training algorithms (training/), and ensemble methods (tuning/). Key strengths include proper packaging, unit tests, documentation, and solutions to technical challenges like recursive multiprocessing. The implementation correctly follows standard ML algorithms while providing a usable framework for developers.

git-log-tree is a single-file Bash CLI tool that renders a fancy, colored git log graph in the terminal. It wraps `git log` with `--topo-order`, `--parents`, and a custom pretty format, then parses the output to draw a tree using Unicode box-drawing characters and ANSI colors. The script handles complex branching, merges, and orphan commits, assigning colors to branches with an algorithm that minimizes reuse and ensures contrast. It respects the `NO_COLOR` environment variable and auto-detects color support. The tool pipes output through `less -F -R -S -X` for paging. The repository includes a comprehensive BATS test that creates a synthetic git history via fast-import and verifies the exact rendered output, along with a GitHub Actions workflow for coverage via kcov. The code is well-structured for a Bash script, using associative arrays and bit manipulation for efficient color sorting, but is monolithic with global state, limiting component reusability.

ItemzFlow is a PlayStation 4/5 homebrew application suite consisting of a graphical file manager/installer (itemzflow), a background daemon for extended functionality (itemz-daemon), and a launcher/loader (itemz-loader). The system enables users to backup game data to USB/NFS shares, install PKG packages, apply custom patches via XML files, manage themes, and run homebrew applications. It integrates numerous third-party libraries including TagLib (audio metadata), cURL (network transfers), mbedTLS (cryptography), and libfuse (filesystem in userspace) to provide comprehensive system management capabilities on jailbroken PlayStation consoles. The application uses OpenGL ES 2.0 for its user interface and relies heavily on PS4/Orbis SDK-specific system calls.

This repository is a FastAPI + async SQLAlchemy reference implementation of an idempotent enterprise integration pipeline, explicitly labeled demo-grade rather than a production platform. Operators interact through REST endpoints covering idempotent message ingestion (five-branch deduplication: accept_new, accept_supersede, skip_duplicate, skip_stale, quarantine), simulated downstream delivery with retry classification, per-system circuit breakers, dead-letter queues, ambiguous-timeout handling with query-before-retry, audited operator replay, end-to-end record inspection, a dashboard health overview, and materialization/compaction jobs. Data flows from an ingestion write path through staging and production projections, then into delivery attempt logs, DLQs, ambiguous outcome queues, replay requests, and audit tables, with SQLite as the default database and PostgreSQL supported via a single environment variable change. The architecture is cleanly layered into routes, services, models, and schemas, with explicit bounded contexts for ingestion correctness, delivery resilience, and explainability. Seeded mock downstream systems make all delivery outcomes deterministic, which is appropriate for a demo harness. The codebase demonstrates good engineering practices: pure decision functions separated from DB side effects, flush-but-don't-commit transaction boundaries, append-only audit logs, and a comprehensive pytest suite covering scenario-based integration and unit tests. Notable caveats include placeholder rule-based correlation matching, some dead/duplicated schema definitions, a version mismatch between pyproject.toml (0.1.0) and the FastAPI app (0.7.0), and an unusual pyproject build-backend string that may break pip package builds. The repository appears maintained as of September 2026 with five open issues and modern dependency ranges. Technical drift is low: SQLAlchemy 2.0 async mappings, Pydantic v2, and current FastAPI patterns are used. While the application is not production-ready itself, several of its pure service modules are genuinely reusable building blocks for idempotency, retry, and correlation problems in other integration systems.

This is a reverse-engineered C++ reimplementation of the CDC game engine powering Deus Ex: Human Revolution Director's Cut, built from IDA Pro decompilation and manually cleaned up into template-based source (explicitly not a matching decompilation). It is a real runnable application: on Windows it boots via WinMain in cdcGameShell/win32/MainVM.cpp, on Linux via cdcGameShell/linux/MainVM.cpp (SDL3 + dxvk-native), and it loads the original game's proprietary archives (BIGFILE.000, .drm/.cdrm, .dtp) using CRC32 path hashing and a dependency-driven resolve pipeline. The code requires original game assets and binaries to be useful; without those it is a development harness for studying the engine. Architecturally it is a monolithic single-target engine (CMake target `dxhr`) split into clean subsystem directories: cdcFile (archive filesystem abstraction), cdcResource (DRM/CDRM section loading with dependency graphs and relocations), cdcRender (a full D3D11 renderer with render-pass/sort system, cached state manager, static/dynamic buffer pools, FXAA/MLAA post-processing), cdcScene/cdcWorld (streaming, instances, scene cells), cdcAnim (animation graph with decoder and state machines), cdcScript (bytecode VM with an incremental mark-sweep garbage collector and a decompiler), cdcSound (FMOD-backed audio with a SoundPlex graph), and game/ (DX3-specific gameplay: player, inventory, objectives, augmentations, dozens of Scaleform-style UI movie controllers). ImGui and ImGuizmo are deeply integrated as an inspector/editor layer, including a DRM hex explorer, per-object debug UIs, runtime material patching, and an in-world gizmo. The dominant character is application, but it is also a reverse-engineering research artifact: many structs in eventually_generated/cdc/dtp/*.h are byte-level guesses from binary analysis, with names borrowed from leaked Tomb Raider (2013) debug info and uncertainty markers throughout. The codebase is honest about its incompleteness. There is a very high density of TODO/HACK/stub code paths: the shadow pass and light manager are scaffolding, scene culling is intentionally brute force, audio streaming is actually whole-file demux (HackMultiplexStream), serialization methods are empty, and some reverse-engineered layouts are marked unconfirmed or contain unnamed dword* fields. Several known bugs are documented in comments (e.g., a `shift += 2` blend-state bug fixed in Tomb Raider 2013 to `shift += 8`). Despite this, the overall architecture is strong and genuinely instructive: the resource-dependency graph, allocator design, render-pass registration pattern, script GC, and format parsers are all well-isolated, non-trivial components that an engineer could lift into other engine or tooling projects. The project is best suited for developers studying the CDC engine, building tooling for DXHR modding, or looking for reference implementations of game-engine resource pipelines.

CherryDAP is an embedded firmware project implementing the ARM CMSIS-DAP v2.1 debug probe protocol on top of CherryUSB, derived from ARMmbed DAPLink. The codebase is structured as a portable DAP core (DAP/Source/DAP.c, SW_DP.c, JTAG_DP.c, SWO.c) shared across four distinct MCU board ports: the HPMicro-based HSLink-Lite and HSLink-Pro, the Bouffalo BL616, and the ESP32-S3. Each port provides its own main loop calling the common chry_dap_init/chry_dap_handle/chry_dap_usb2uart_handle API, with per-board USB descriptors, GPIO pin mapping, and reset control isolated behind DAP_config.h and dap_main.h. The HSLink-Pro is the flagship and most feature-complete variant: it adds a custom UF2 bootloader with app-validity checks, persistent device settings stored via FlashDB and serialized with rapidjson, a JSON-over-custom-HID configuration protocol matched to a Windows host tool, NeoPixel LED effects, target power control, level shifting, and an 80 MHz SPI-based SWD/JTAG fast path. The HSLink-Lite instead contributes a full IEEE 1149.7 CJTAG protocol stack (TAP.7 state machine, OScan1 transport, J-Link-compatible connect sequences) that is research-heavy and feature-toggled. A notable non-obvious technique across the board is emulating the single-wire bidirectional SWD and JTAG protocols at bit level using SPI peripherals rather than only GPIO bit-banging, which yields far higher clock rates. The repository is genuinely useful as a reference for building CMSIS-DAP-compatible debug probes on new MCUs: the DAP core is cleanly separated from platform USB and I/O layers, and the UF2 bootloader, HID configuration layer, and SPI-based protocol emulation are all extractable patterns. Weaknesses include heavy duplication of board and swd_host files across projects, hundreds of lines of commented-out DAPLink code retained in swd_host.c, experimental compile-time toggles in the CJTAG code, an ESP32-S3 sdkconfig that shows ESP-IDF version drift (5.4.0 header vs 5.2.5 init version), and a submodule-heavy dependency set that affects long-term build reproducibility. Overall it is a solid, product-grade embedded codebase with real craftsmanship in the protocol layers, but it carries meaningful maintenance debt from vendored components and project-level copy-paste.

This repository contains solutions to Harvard's CS50P (Introduction to Programming with Python) course problem sets, organized by week from Week0 to Week9. Each week features multiple standalone Python scripts that solve specific programming exercises, such as calculating tips, validating license plates, converting time formats, processing CSV files, and generating images or PDFs. The scripts are designed to be run from the command line, typically taking user input via `input()` and producing output via `print()`, with some utilizing external libraries for specialized tasks like emoji conversion, figure generation, or image manipulation. While many scripts are simple and focused on teaching basic programming concepts, several components demonstrate reusable, well-crafted patterns worthy of highlighting. Notable examples include the time-parsing function in Week1/meal.py (converting strings like '7:30 AM' to float hours), the license plate validation logic in Week2/plates.py (enforcing rules on length, character types, and number placement), the CSV transformation script in Week6/scourgify/scourgify.py (splitting 'Last, First' names into separate columns), the Jar class in Week8/jar/jar.py (modeling a container with deposit/withdraw operations), and the time-range conversion function in Week7/working/working.py (converting '9:00 AM to 5:00 PM' to 24-hour format). These components are isolated, self-contained, and could be extracted for reuse in other projects with minimal modification. The repository is actively maintained, with the most recent commit dated 2026-06-04. It relies on a few external libraries (such as `inflect`, `emoji`, `pyfiglet`, `tabulate`, `Pillow`, `validators`, and `fpdf`) for specific functionalities, but the core logic of the highlighted components uses only the standard library. There is no evidence of significant technical debt or outdated dependencies, indicating a low level of technical drift. The codebase serves as an excellent educational resource for beginner to intermediate Python programmers, showcasing practical problem-solving techniques.

寿星天文历 (sxwnl) is a comprehensive client-side Chinese astronomical calendar web application. It provides accurate lunar/solar calendar conversion, solar terms (jieqi), planetary and stellar ephemeris, solar/lunar eclipse prediction with interactive maps, rise/set times, and specialized tools (Julian day conversion, Chinese zodiac calculation). The entire application runs in the browser with no server backend, relying on hardcoded astronomical algorithms (VSOP87/ELP-based) and embedded data (city coordinates, historical calendar corrections, star catalogs). The architecture is monolithic: a single HTML page loads multiple JavaScript modules (eph0.js, eph.js, lunar.js, etc.) that manipulate the DOM directly. While the code is functional and accurate for its domain, it suffers from global namespace pollution, outdated browser API usage (VML, deprecated event handling), and a manual Windows-only build process. Despite these issues, individual modules like the ephemeris engine, lunar calendar class, and coordinate transformation utilities are self-contained and could be extracted for reuse in other astronomy or calendar projects.

This is a cross-platform Flutter application that serves as an unofficial client for the Pixiv illustration and novel platform. It provides a full-featured browsing experience including OAuth login, search, ranking, bookmarks, following, recommendations, comments, and a download manager with offline viewing. The architecture follows a standard Flutter app structure with custom state management (StateController), a centralized network layer using Dio to interact with Pixiv's private API, and local SQLite storage for caching images, download history, and settings. The UI is built with Fluent UI for a desktop-native look on Windows, macOS, and Linux, with platform-specific adaptations for Android and iOS. The codebase demonstrates moderate craftsmanship with reusable components like a generic cache manager, custom image provider with retry logic, and utility classes for debouncing and periodic tasks. However, it has some maintenance risks including hardcoded API credentials, reliance on undocumented Pixiv API endpoints, and a few code quality issues such as fall-through bugs in keyboard handling and non-localized strings.

Pogly Standalone is a real-time collaborative overlay editor designed for streamers. It allows multiple users to jointly create and manage stream overlays (text, images, widgets) that can be displayed in streaming software like OBS. The application features a React frontend with TypeScript, utilizing Material-UI and styled-components for the UI, and a C# backend powered by SpacetimeDB for real-time state synchronization. Key functionalities include drag-and-drop interface, layout management, role-based permissions (owner/moderator/guest), integration with streaming platforms (Twitch, YouTube, Kick) and emote services (7TV, BetterTTV, Tenor), and persistent storage via Docker volumes. The architecture follows a modular structure with clear separation of concerns: the frontend handles user interactions and rendering, while the SpacetimeDB backend serves as the authoritative state store, pushing updates to all connected clients via WebSocket. Deployment is containerized using Docker with Caddy serving the frontend and proxying to SpacetimeDB.

MTG Familiar is a mature, open-source Android companion app for Magic: The Gathering. It provides a comprehensive suite of offline-capable tools including card search with advanced filtering, life counter with commander damage and poison tracking, mana pool, dice roller, trade and wishlist management, round timer, comprehensive rules browser, judge documents (MTR, IPG, JAR), deck builder with import/export and statistics, and the MoJhoSto random card generator. The app is built as a single-module Android project using AndroidX, with a local SQLite database for card data (updated via JSON patches from a GitHub repository), TCGPlayer API integration for market prices, and Glide for card image loading. The architecture follows standard Android patterns: a main Activity (FamiliarActivity) manages a navigation drawer and fragment transactions, with each tool implemented as a Fragment. Data access is centralized through CardDbAdapter and DatabaseManager, with custom Views for mana symbols, color pie, and token-based input. The codebase is well-organized but shows signs of age with deprecated API usage (AsyncTask, PreferenceFragment) and some large, tightly-coupled fragments. It is actively maintained (last commit 2026-06-04) with regular database updates and community contributions.