thehardwarestore.ai

RunCPM is a Z80 CPU and CP/M emulator that executes unmodified 8-bit CP/M application binaries on desktop operating systems and embedded microcontrollers. The code provides a complete Z80 instruction-set emulation (selectable among four CPU models), a CP/M 2.2/3 BDOS and BIOS dispatcher, a built-in CCP console command processor, and a host-directory-to-CP/M-drive mapping. Desktop entry points are RunCPM/main.c; embedded entry points are in RunCPM/RunCPM.ino, with board-specific hardware definitions for Arduino, Teensy, ESP32, STM32, and RP2040. CP/M disk drives are folders on the host filesystem, and user areas are numbered subdirectories. External dependencies are limited to platform C libraries, optional SDL/RunVT terminal integration, and SD-card filesystem support on embedded targets. Custom BDOS calls allow CP/M programs to control physical GPIO pins on supported boards.

Apache RocketMQ client SDK monorepo providing production-grade gRPC-based client libraries for Java, C++, C#, Go, Node.js, Python, Rust, and PHP. The repository implements the full RocketMQ v2 proxy protocol, supporting multiple messaging patterns: standard, FIFO, delay, priority, transactional, and lite-topics. Each language client follows a consistent builder pattern for producers, push consumers, simple consumers, and lite variants. The codebase includes robust retry policies (exponential backoff, custom backoff), authentication via HMAC-SHA1 signing, metrics/tracing integration (OpenTelemetry in Java/Python/Node.js/C#, OpenCensus in C++), and comprehensive error handling. While Java is the reference implementation, the architecture is uniformly designed across languages with shared protobuf definitions. The repository is actively maintained with CI pipelines for all languages, but some languages (Rust, PHP) trail in feature parity and test coverage. Technical drift is moderate due to C++ depending on OpenCensus (superseded by OpenTelemetry) and some generated proto code requiring regeneration.

This is an Arduino library that provides a driver for ILI9341 TFT LCD displays, communicating over SPI. It handles display initialization, rotation, color inversion, scrolling, and pixel-level drawing operations. The library is built on top of Adafruit_SPITFT and Adafruit_GFX, and supports multiple hardware configurations including software SPI, hardware SPI, and parallel interfaces. The code is well-documented with inline comments and includes a comprehensive set of example sketches demonstrating graphics benchmarks, touch painting, and animation. The library is mature, stable, and widely used in the Adafruit ecosystem.

pybliometrics is a Python library that provides a programmatic interface to Elsevier's Scopus, ScienceDirect, and SciVal APIs, enabling large-scale retrieval of bibliometric data such as publication metadata, citation counts, author profiles, journal metrics, and research analytics. The library is designed for researchers and developers in scientometrics, offering structured access to API responses via named tuples and properties, with built-in caching, automatic pagination, rate limiting, and API key rotation to handle quotas and server errors gracefully. The architecture follows a layered design: a set of superclasses (Base, Retrieval, Search) in pybliometrics/superclasses handle common concerns like configuration loading, file-based caching, HTTP request management, and pagination. Domain-specific modules under pybliometrics/scopus, pybliometrics/sciencedirect, and pybliometrics/scival implement concrete API endpoints by subclassing these superclasses and defining endpoint-specific parameters, views, and parsing logic. Utility modules in pybliometrics/utils provide configuration creation, content retrieval, JSON parsing helpers, and validation functions used across the library. Key entry points include the init() function for first-time setup and the numerous API wrapper classes (e.g., AbstractRetrieval, AuthorSearch, ScopusSearch, ArticleRetrieval, AuthorMetrics). Data flows from user-provided identifiers or query parameters through the superclass request pipeline, which checks the local cache, makes HTTP requests to Elsevier APIs if needed, parses the JSON responses into named tuples, and returns structured data. External dependencies are limited to requests, tqdm (for progress bars), and Python standard library modules; the library is fully dependent on Elsevier's API availability and schema. The codebase demonstrates solid engineering practices with clear separation of concerns, consistent error handling via custom exceptions, and a property-based access pattern that gracefully handles missing data. However, it is tightly coupled to the exact JSON structure of Elsevier's APIs, making it vulnerable to upstream changes, and the test suite relies on live API calls, which limits automated testing without credentials. Overall, it is a well-crafted, domain-specific library that effectively solves the problem of programmatic bibliometric data access.

This is a comprehensive Terraform module library for provisioning Google Cloud networking infrastructure. It provides building blocks for VPCs, subnets, routes, firewall rules (classic and policy-based), network peering, Private Service Connect (consumer, producer, endpoints), Network Connectivity Center hubs/spokes, and higher-level foundation patterns (shared VPC, hub-and-spoke). The architecture is modular: the root module orchestrates core resources while 30+ submodules handle specific concerns (e.g., firewall-rules, subnets-beta, network-firewall-policy). Each submodule has its own variables, outputs, and version constraints, making them independently consumable. Extensive integration tests in Go (using cloud-foundation-toolkit) validate correct behavior against real GCP projects. The module is actively maintained with frequent releases (v18.3.0) and follows Google Cloud Foundation Toolkit conventions, but exhibits some technical drift: deprecated variables remain, beta submodules may lag behind GA, and many examples pin older Terraform/provider versions.

vlc-bittorrent is a VLC media player plugin that enables direct streaming of .torrent files and magnet links. It integrates libtorrent-rasterbar to handle the BitTorrent protocol, providing three VLC submodules: a stream_directory module to list torrent contents as a virtual directory, a stream_extractor module to stream individual files with on-demand piece downloading and priority-based piece selection, and an access module to resolve magnet URIs by downloading metadata from peers. The plugin manages a single libtorrent session shared across multiple torrents, handles asynchronous alerts via a dedicated thread, and supports interruptible I/O compatible with VLC's blocking read model. It includes a comprehensive test suite with TAP output and deterministic expected results.

Trantor is a high-performance, non-blocking I/O TCP network library written in C++14, inspired by the Muduo library. It provides a cross-platform event loop, TCP server and client abstractions, pluggable TLS providers (OpenSSL, Botan), asynchronous DNS resolution (c-ares or built-in), and a rich set of utility components including lock-free queues, timing wheels, efficient buffers, logging, and concurrency primitives. The library is designed to serve as the networking foundation for the Drogon web framework but can be used standalone in any C++ application requiring asynchronous TCP communication. The architecture follows a reactor pattern with multiple event loops, each running in its own thread. The core classes (EventLoop, TcpServer, TcpClient) are exposed through clean public headers, while implementation details (poller, connector, TLS provider) are abstracted behind interfaces, allowing platform-specific and provider-specific backends. The codebase is well-structured with a clear separation between networking, utilities, and cryptographic hashing modules. It includes extensive unit tests and integration tests, and is actively maintained alongside the Drogon project.

Pyversity is a Python library for fast diversification of search and retrieval results, providing five algorithms (MMR, MSD, DPP, COVER, SSD) to re-rank items balancing relevance and diversity. Its core API is minimal: `diversify(embeddings, scores, k, strategy, diversity)` returns a `DiversificationResult` with selected indices and scores. The library is dependency-light (only NumPy required) and designed for easy integration into retrieval pipelines. The repository also contains a comprehensive benchmark suite evaluating strategies on real-world recommendation datasets (MovieLens-32M, Last.fm, Amazon Video Games, Goodreads), with metrics for both relevance (nDCG, MRR) and diversity (ILAD, ILMD). Benchmark results show DPP offers the best diversity gains with minimal relevance loss. While primarily a software library, the inclusion of reproducible benchmarks, research citations, and systematic evaluation makes it a hybrid application/research repository.

Upvote RSS is a self-hosted PHP web application that turns popular posts from Reddit, Lemmy, Hacker News, Lobsters, PieFed, Mbin, and GitHub into rich RSS 2.0 feeds. The UI is a vanilla JavaScript custom element that builds feed URLs, previews filtered posts via AJAX, and shows progress through Server-Sent Events. The same URL served with view=rss triggers a server-side RSS generator that produces XML directly from each platform's public or authenticated APIs. Architecturally it is a monolithic, front-controller PHP application with class-based domain abstractions: one Community adapter per platform, one Post adapter per platform, a multi-backend Cache abstraction (file/Redis/APCu), a Monolog-based logger, a parser abstraction supporting Mercury, Readability.js, and Readability.php with optional Browserless rendering, and a SummarizerFactory that falls back across Ollama, OpenAI, Gemini, Anthropic, Mistral, DeepSeek, and OpenAI-compatible providers. All external API responses, parsed webpages, feed output, and resized images are cached; feed generation uses DOMDocument to construct valid RSS XML. The core data flow is: the frontend POSTs filter parameters to ajax.php, which constructs the correct Community adapter, fetches hot/top posts from the source platform, applies score/threshold/posts-per-day filtering, and returns JSON for preview. RSS generation reuses the same filtering path, then enriches each post with embedded media, fetched article content, optional LLM summaries, and top comments. The code is cleanly organized, uses modern PHP 8.2+ features, and has no test suite but compensates with defensive caching, logging, and provider fallback logic.

Globstar is a static analysis toolkit that enables developers to write custom checkers in YAML or Go and run them via a single portable binary. It uses tree-sitter for AST-based analysis, supporting multiple languages (Go, Java, JavaScript, Python, Ruby, etc.). The tool is designed to be fast, dependency-free, and CI-friendly, with a focus on enforcing learned patterns such as security vulnerabilities and code quality issues. The architecture consists of a CLI layer, an analysis engine for parsing and scope resolution, and a checker system with built-in and custom checker support.

This repository is an Obsidian plugin that integrates GitHub Copilot's AI-powered coding assistance directly into the Obsidian note-taking application. It provides two main features: inline code suggestions as you type (similar to Copilot in IDEs) and a chat interface for interacting with Copilot in a sidebar. The plugin handles authentication with GitHub Copilot, manages conversation history, renders Mermaid diagrams from AI responses, and allows linking to Obsidian notes using [[double bracket]] syntax in chat conversations. The architecture separates concerns into distinct modules for inline suggestions (using LSP protocol) and chat functionality (using direct API calls), with React powering the chat UI and Zustand managing state.

Kaleido is a Python library for static image export of Plotly figures (PNG, SVG, PDF, etc.) by rendering them in a headless Chrome browser via the DevTools protocol. The library provides both async and sync APIs, with an optional singleton server mode for reuse across calls. It manages a pool of browser tabs for parallel rendering, supports chunked JSON transfer for large figures (>10MB), and includes profiling capabilities. The architecture is centered around the `Kaleido` class, which orchestrates browser lifecycle, tab allocation, and rendering through `_KaleidoTab` instances. The library is consumed by Plotly.py and can be used standalone or via CLI tools (`kaleido_mocker`, `kaleido_get_chrome`). Dependencies include `choreographer` (Python-DevTools bridge), `orjson`, and `logistro`. The test suite includes extensive integration tests with hundreds of Plotly figure mocks covering a vast range of trace types and layout features.

This repository is a collection of iOS application projects that recreate various UI designs from sources like Instagram, Dribbble, and Facebook. Each project is a self-contained iOS app implemented in either Swift (UIKit) or SwiftUI, demonstrating how to translate specific designs into functional code. The repository serves as an educational resource for iOS developers looking to learn practical UI implementation techniques. The project follows a clear organizational structure where each episode resides in its own folder containing a downloadable ZIP file with the complete source code. Projects cover a wide range of UI concepts including onboarding flows, social media interfaces, messaging apps, music players, and more. Both UIKit and SwiftUI implementations are showcased, reflecting the evolution of iOS development practices. While the actual implementation details are contained within the ZIP archives and cannot be directly inspected in this repository view, the consistent naming convention, clear documentation in README.md, and regular maintenance indicate a well-organized educational resource. The repository appears to be actively maintained with recent commits and covers contemporary iOS development topics.

This repository is the official Twilio SendGrid Java SDK for the SendGrid v3 Web API. It provides a low-level HTTP client that wraps all documented REST endpoints (email sending, contact management, suppression, templates, IP pools, statistics, etc.) and a high-level mail builder helper for constructing complex email payloads. The library supports both SendGrid API key and Twilio Email authentication, rate-limit retry, asynchronous execution via a thread pool, data residency (EU/global), and event webhook verification using ECDSA signatures. It is published on Maven Central and designed to be imported as a dependency in Java applications. The architecture follows a thin-client pattern: users instantiate a `SendGrid` or `TwilioEmail` object, build a `Request` with method, endpoint, headers, and body, then call `api(request)` to get a `Response`. The mail helper (`com.sendgrid.helpers.mail`) uses a builder pattern for attachments and Jackson-annotated POJOs for clean JSON serialization. The codebase is well-structured with clear separation between the core API client, helper modules, and examples. It is actively maintained with regular dependency updates via Dependabot and CI/CD through GitHub Actions. While the library is comprehensive and production-ready, some areas show signs of age: the example code is repetitive and auto-generated, the mock server uses an outdated Prism version, and the mail helper has a pending refactor proposal. Overall, it is a solid, professional-grade SDK that reliably fulfills its purpose of integrating Java applications with the Twilio SendGrid platform.

QMarkdownTextEdit is a mature C++ Qt library providing a feature-rich markdown text editor widget, QMarkdownTextEdit, which extends QPlainTextEdit with live markdown syntax highlighting, code block syntax highlighting (for dozens of languages via a large hand-curated keyword dataset), line numbers with bookmark indicators, block (rectangular) selection, clickable links, and an integrated search/replace widget. The library is designed to be embedded into larger Qt applications such as QOwnNotes, Notes, and CuteMarkEd-NG. It supports both widget-based (QWidget) and Qt Quick (QML) integration through a registered QML type. The architecture is a single-library module with optional demo and QML example applications. The core components include the main editor widget, the markdown highlighter (which can be used independently on any QTextDocument), a separate search/replace widget (QPlainTextEditSearchWidget), and a line number area (LineNumberArea). The language-specific syntax highlighting data is generated in a single massive C++ file (qownlanguagedata.cpp) using a consistent pattern of init/load functions grouped by language. The library is built and installed via qmake (.pro/.pri) and CMake, with continuous integration across multiple Qt versions (5.9 to 6.10) on Linux, macOS, and Windows. The codebase is well-organized and demonstrates solid engineering practices: clear separation of concerns (highlighter, search widget, editor), support for internationalization (translation files for German, Spanish, Urdu, Chinese), and compatibility with both widget and QML interfaces. While the library is primarily a UI component, it also includes utility patterns like debounced search and regex support. The main risk is the maintenance burden of the enormous hand-curated syntax data file, which contains some minor errors and duplicates, and the lack of automated tests for the highlighting logic. Overall, this is a practical, production-grade text editor component with broad applicability in Qt projects requiring markdown or code editing capabilities.

Vaul Vue is a Vue 3 component library that provides a drawer (slide-in panel) component built on top of Reka UI's Dialog primitive. It is a port of the React Vaul library to Vue, offering features such as drag-to-dismiss, snap points, directional control, and background scaling effects. The library is structured with a clear separation of concerns, utilizing Vue's Composition API for logic and providing a set of reusable utility functions for DOM manipulation and browser detection. Although the project is marked as no longer maintained in the README, the codebase demonstrates strong engineering practices and contains several genuinely reusable components.

Razix is a multi-platform 3D game engine built in C++ with a focus on modern graphics APIs (Vulkan, DirectX 12, OpenGL). It features a custom rendering hardware interface (RHI), a frame graph system for efficient render pass scheduling, an entity-component system (ECS) for scene management, and a built-in editor with ImGui integration. The engine includes a Lua scripting system, physics integration via Jolt Physics, and a comprehensive memory management layer with custom allocators. Despite its ambitious scope and active development, the codebase exhibits a mix of well-engineered subsystems and areas of legacy code (e.g., LIMBO_STATE). The project provides testing frameworks for both engine core and graphics pipelines, and maintains a dedicated game project ('Tanu') as a showcase.

Animatelo is a JavaScript library that provides a collection of pre-built animations using the Web Animations API. It ports the popular animate.css library to the JavaScript-based animation model, allowing developers to apply animations like bounce, fade, slide, and more to DOM elements via a simple API (e.g., animatelo.bounce('#element')). The library consists of a core animation engine (src/animatelo.js) that handles element selection, option validation, and animation creation, with individual animation files defining keyframe sequences for specific effects. The architecture is modular, with each animation encapsulated in its own file that extends the main animatelo object, and a build process (via Gulp) concatenates and minifies the source for distribution. The library relies on the Web Animations API (with polyfill support for older browsers) and has no runtime dependencies, making it lightweight and easy to integrate into web projects.

SuperSuit is a Python library that provides a collection of lightweight, composable 'microwrappers' for preprocessing reinforcement learning environments. It supports both single-agent Gymnasium environments and multi-agent PettingZoo environments (AEC and Parallel APIs). The wrappers cover common transformations such as color reduction, frame stacking, resizing, dtype conversion, reward clipping, action scaling, and NaN handling. Additionally, it offers vectorization utilities to run multiple environment instances in parallel, including synchronous, asynchronous, and multiprocessing-based vector environments. The library is designed to be used as a preprocessing pipeline before feeding environments into RL algorithms. It is maintained primarily for compatibility with newer versions of PettingZoo and Gymnasium, with the stated intention of eventually merging relevant functionality into PettingZoo's own wrappers.