thehardwarestore.ai

OpenPIV is a Python library for Particle Image Velocimetry (PIV) analysis, used to extract velocity fields from image pairs of seeded fluid flows. It provides a complete pipeline including image preprocessing, cross-correlation with subpixel interpolation, outlier validation, filtering, and scaling. The library supports both 2D and 3D PIV, multi-pass window deformation, and batch processing of image sequences. The architecture is modular with a dual-backend design: a pure Python/SciPy reference implementation and an optional Rust backend (openpiv_rust) for accelerated computation. Core algorithms are implemented in pyprocess.py (FFT correlation, peak detection) and windef.py (multi-grid window deformation). The library includes a comprehensive validation module (global, local median, signal-to-noise ratio) and a smoothing module ported from a MATLAB robust spline algorithm. OpenPIV is designed for researchers and engineers in experimental fluid dynamics. It includes synthetic image generation tools for testing, benchmarking scripts for performance evaluation, and Jupyter notebooks for tutorials and algorithm exploration. The library is in beta (v0.26.1) with an API subject to change, and conda packages are no longer maintained.

Nova Proximity is a modular Python security scanner designed specifically for MCP (Model Context Protocol) servers and Agent Skills. The application provides comprehensive discovery and analysis capabilities, including tool/prompt/resource enumeration for MCP servers and structural/permission analysis for Agent Skills. Its architecture separates concerns into distinct libraries: mcp_scanner_lib for MCP protocol handling, skill_scanner_lib for Agent Skills analysis, and nova_evaluator_lib for NOVA-powered security evaluation. The tool supports multiple transport mechanisms (stdio, SSE, Streamable HTTP) with automatic fallback, provides detailed function signature analysis, and generates actionable security reports with pattern-specific remediation guidance.

CrystalEngine is a full-featured, cross-platform game engine with an integrated editor, built from scratch in C++. It features a custom Vulkan/Metal rendering backend with a directed acyclic frame graph for render pass scheduling, a physically-based rendering pipeline with IBL and shadow mapping, and a modular architecture with dynamic module loading. The engine includes a comprehensive asset pipeline (import, compression, serialization), a job system for parallelism, and a physics integration via Jolt. A notable aspect is the dual UI framework: the older CrystalWidgets (CSS-styled) and the newer Fusion framework (declarative, property-based), both used in the editor. The editor provides dockable windows, property editors, material editing, scene outliner, and asset browser. The codebase demonstrates strong engineering with clean abstractions (RHI, RPI, frame graph, job system) but shows signs of ongoing migration (two UI frameworks) and some incomplete features. It is actively maintained and suitable for learning or extending a modern game engine architecture.

This repository provides a header-only C++ library with Python bindings for solving partial differential equations (PDEs) using Monte Carlo methods, specifically Walk on Spheres (WoS) and Walk on Stars (WoS★) algorithms. It supports Laplace, Poisson, and screened Poisson equations with Dirichlet, Neumann, and Robin boundary conditions in 2D and 3D. The library includes variance reduction techniques (Boundary Value Caching, Reverse Walk on Stars) and handles exterior problems via the Kelvin transform. It is designed for grid-free PDE solving, relying on geometric queries (via FCPW BVH or SDF grids) rather than volume meshing. The codebase is research-oriented, with clear reference implementations and citations to foundational papers, but includes many TODO comments and incomplete optimizations. The architecture is modular with template-based dimension and value type abstraction, making it adaptable but also complex. Demo applications in C++ and Python illustrate usage on model problems with JSON configuration and image output.

This repository is an official Arduino C++ library, not a standalone application or service. In production it is compiled into Arduino sketches to drive Hitachi HD44780-compatible alphanumeric LCD modules over parallel GPIO. The code supports 4- or 8-bit data-bus modes, an optional RW pin, multi-row displays via DDRAM row offsets, 5x8/5x10 character fonts, cursor/blink/display control, scrolling, text direction, autoscroll, and up to eight custom CGRAM glyphs. The actual implementation is only src/LiquidCrystal.cpp and src/LiquidCrystal.h; the remaining files are examples, documentation, and CI workflows. Architecture is a single class inheriting from Arduino's Print, exposing constructors for common pin configurations, begin(cols, rows, charsize), and high-level methods. Data flow is layered: public commands call command() or write(), which call send(); send() either writes a full byte or splits it into high/low nibbles, and pulseEnable() generates the timing-critical enable pulses through digitalWrite/delayMicroseconds. There are no external dependencies beyond the Arduino core headers (Arduino.h, Print.h). The repository is actively maintained with GitHub Actions for Arduino lint, example compilation across AVR/SAM/SAMD/Mbed boards, spell checking, and Dependabot. The code is stable and battle-tested but shows its age in minor ways: an unused _initialized member, a redundant begin() call from the constructor, and non-const createChar signatures. Technical drift is low because the HD44780 protocol is fixed hardware and the Arduino APIs used are stable. It serves as a reference implementation for similar bit-banged parallel device drivers and is directly reusable as an Arduino Library Manager dependency.

Dioptra is a NIST-developed open-source platform for designing, managing, and executing reproducible machine learning experiments with a strong emphasis on adversarial robustness evaluation. The system provides a full-stack application including a REST API (Flask-RESTx with dependency injection, SQLAlchemy ORM, and Alembic migrations), a Vue.js frontend (Quasar framework), a Python client library, a plugin-based task execution engine, and a declarative YAML workflow system. It supports experiment tracking via MLflow integration, artifact versioning, user and group management, and job queuing via Redis RQ. The platform is designed to be deployed using Docker and Cookiecutter templates, with support for custom worker containers and GPU acceleration. While primarily an application for experiment lifecycle management, Dioptra also incorporates research-oriented components such as object detection modules (YOLOv1 architecture with TensorFlow backends), adversarial attack and defense plugins (using ART), and a custom type system for plugin parameter validation. The codebase is well-structured with clear separation of concerns (controllers, services, repositories), generic endpoint generators to reduce boilerplate, and a comprehensive test suite. Notable architectural patterns include unit of work, dependency injection, and a custom pyplugs decorator-based plugin registration system. However, the codebase shows signs of technical drift with some deprecated syntax, monkey-patching of third-party libraries, and complex draft/resource locking logic that may be brittle. Overall, Dioptra is a solid, professional-grade platform that effectively addresses the challenge of reproducible ML experimentation in adversarial contexts.

Open CAS Linux is a production-grade block-layer cache acceleration solution for Linux. It consists of a kernel module (`cas_cache`) implementing caching logic on top of the OCF (Open Cache Framework), a block device module (`cas_bd`), and a user-space management CLI (`casadm`). The system accelerates block I/O by caching hot data on fast storage (e.g., NVMe/Optane) while using slower backing storage, with support for multiple cache modes, cleaning policies, I/O classes, and statistics reporting. Management is performed via ioctls through `/dev/cas_ctrl` and netlink-based communication, with a comprehensive CLI (`casadm`) for cache/core lifecycle operations and statistics output in text, CSV, and raw CSV formats.

dconf2nix is a CLI tool and Haskell library that converts GNOME dconf configuration files into Nix expressions for use with Home Manager's dconf.settings option. It parses the GVariant text format using Parsec combinators, supporting a wide range of dconf value types (booleans, integers, floats, strings, byte strings, tuples, lists, variants, dictionaries, typed values, and JSON). The parser is comprehensive and handles edge cases such as hexadecimal and octal integers, scientific notation, Unicode escapes, and nested structures. The rendered output uses Home Manager's lib.hm.gvariant constructor functions to produce valid Nix code. The architecture cleanly separates parsing (DConf module), data model (DConf.Data), and Nix rendering (Nix module), with a small CLI entry point. The codebase is well-tested with 20+ test cases covering various dconf input patterns and their expected Nix output.

Comonicon is a Julia CLI generator that transforms function definitions and docstrings into full-featured command-line interfaces with zero duplication, zero overhead, and zero dependencies after code generation. The system follows a classic compiler pipeline: Julia source code is parsed by the frontend (@cast/@main macros) into an AST representation, which is then walked by the codegen module to produce executable Julia Expr, and finally processed by the builder module for installation, system image generation, and distribution. Key features include automatic CLI documentation generation from docstrings, shell completion generation (bash/zsh), and flexible build options via PackageCompiler. The architecture shows clear separation of concerns across frontend, AST, codegen, and builder modules, with thoughtful use of Julia's macro system and type features.

This is a Nuxt module that integrates Swiper.js into Nuxt 3 applications using Web Components. It provides automatic registration of `<swiper-container>` and `<swiper-slide>` custom elements, a Vue composable (`useSwiper`) for reactive Swiper instance control, and support for both bundled and individual Swiper module imports. The module is minimal, well-typed, and leverages Nuxt's module system for configuration. It includes a playground and test fixture but no complex business logic. The codebase is clean and modern, with proper TypeScript types and a structured setup, though the test suite is practically empty. The composable is well-crafted and could be extracted as a standalone utility.

This repository is a comprehensive React training workshop containing three distinct demo applications: a client‑side SPA using React Router, a server‑side rendered app using the React Router framework (with loaders/actions), and a Next.js 14 App Router example. It provides progressive lessons covering core concepts (components, state, routing, forms, hooks, data fetching), advanced patterns (compound components, form abstractions, optimistic UI, imperative React), and testing with Vitest and React Testing Library. The architecture is educational: each app demonstrates different React ecosystem approaches, with mock data served by json‑server, authentication via cookie sessions, and state management through context providers. External dependencies include React 18/19, React Router v7, Next.js 14, Tailwind CSS, bcrypt, and TanStack Query. The codebase is well‑structured for learning, with lecture code, practice exercises, and final solutions organized by lesson.

This is the swagger-codegen-generators repository, a Java library that provides code generation for client and server stubs from OpenAPI (formerly Swagger) specifications. It is not a standalone application but a library consumed by the swagger-codegen v3 tool (or used programmatically). The codebase implements a template-driven architecture where language-specific generators extend abstract base classes (e.g., AbstractJavaCodegen, AbstractTypeScriptClientCodegen) and use Handlebars/Mustache templates to produce output. It supports a wide range of languages including Java, C#, Go, Python, Ruby, Swift, TypeScript, Kotlin, Dart, PHP, Scala, R, and Node.js, with frameworks like Spring, JAX-RS, Micronaut, Vert.x, ASP.NET Core, and more. Key file patterns include feature interfaces for composable generator capabilities (e.g., BeanValidationFeatures, GzipFeatures), Handlebars helper lambdas for template logic, and schema handlers for composed schemas (allOf/oneOf/anyOf). The project has extensive test coverage with unit and integration tests for model and API generation. While the core architecture is solid, the base class DefaultCodegenConfig is monolithic and the hundreds of template files pose maintenance drift risks. The project is actively maintained with CI workflows, issue templates, and recent commits.

This repository serves as the landing page for the Nuxt web framework, providing a minimal but polished interface to kickstart Nuxt projects. The core functionality is a gallery of starter templates—each pointing to a GitHub repository branch—with one-click redirections to CodeSandbox, StackBlitz, or a local `npm create nuxt@latest` command. The application is built with Nuxt 4 and leverages server routes for API lookups (slug-based) and redirects, client-side data fetching via `useFetch`, and a performant static generation pipeline. It also includes a custom `style-inlining` module that purges unused CSS and inlines critical styles during prerendering, and a `purge-comments` Vite plugin that strips HTML comments from Vue templates at build time. The UI is styled with Tailwind CSS and Nuxt UI components, and the entire site is designed to be lightweight (budgeted at 270 KB total). It is a genuinely useful tool for the Nuxt community, acting as both a promotional site and a practical starter launcher.

This repository provides an HTTP API service for interacting with the TON (The Open Network) blockchain. It acts as an intermediary, translating HTTP requests into calls to the TON blockchain via the tonlib library. The service is built with FastAPI and uses a pool of worker processes to communicate with TON nodes, handling load balancing and failover. It supports caching of responses via Redis to reduce load on the blockchain nodes. The service exposes both REST and JSON-RPC endpoints for a wide range of blockchain operations, including querying account information, executing smart contract methods, and sending transactions.

This repository is a Node.js library for interacting with the Windows registry. It provides functions to read, write, list, and manipulate registry keys and values using Windows Script Host (cscript.exe) and VBScript. The architecture separates concerns: Node.js handles argument parsing, process spawning, and result parsing, while VBScript files perform the actual registry operations via WMI. The library supports both callback and promise-based APIs, handles different registry value types, provides 32/64-bit registry access options, and includes streaming interfaces for large operations. It's a focused, well-tested solution for a specific platform-specific problem.

This is a bare-metal x86-64 operating system kernel written in Swift (using Embedded Swift). It boots on real hardware and emulators (QEMU, Bochs, VMWare) via both BIOS and UEFI. The kernel implements core OS primitives: memory management (page tables, slab allocator), interrupt handling (APIC, IOAPIC, PIC), ACPI table parsing and a full AML bytecode interpreter, PCI/PCIe bus enumeration, USB host controllers (UHCI, XHCI, EHCI), PS/2 keyboard/mouse, Intel i915 GPU driver, and a simple cooperative task scheduler. It uses a custom Swift toolchain (swift-kstdlib) and custom Swift macros for printf-style output. The project is a research/learning effort by a single developer, exploring Swift as a systems programming language for kernels. Architecture is modular with device driver tree, ACPI namespace, and separate memory management layer. Many drivers are functional but some remain incomplete or experimental (e.g., VMX virtualization, i915 only supports two GPU IDs).

This VS Code extension provides comprehensive language support for the Crystal programming language. It includes syntax highlighting for Crystal, ECR (Embedded Crystal), and Slang templates, along with auto-indentation, snippets, and code formatting via the Crystal compiler's `tool format`. It integrates deeply with the Crystal toolchain to offer problems detection (compiler errors displayed inline), hover type information, go-to-definition, document symbols, and a macro expansion viewer. A task provider enables running common `crystal` and `shards` commands directly from the editor. A spec test explorer allows running and viewing Crystal spec results using the native VS Code testing UI, parsing JUnit XML output. The extension can optionally delegate to an external LSP server (e.g., Crystalline) for more advanced language intelligence. All language-aware features are implemented by spawning the Crystal compiler tool with appropriate flags and parsing its JSON/flat output, with careful management of compiler processes via mutexes and per-project cache directories. The source code is written in TypeScript and divided into modular providers (completion, definitions, hover, format, problems, symbols, tasks, spec).

Rehike is a custom YouTube frontend server written in PHP that proxies and transforms YouTube's InnerTube API responses to recreate the legacy 'Hitchhiker' layout (2013-2020 era). It operates as an MVC web application with a custom asynchronous event loop (Promises/EventLoop), a typed configuration property system, a comprehensive i18n framework, and a network layer that handles InnerTube and third-party requests. The backend renders pages using Twig templates with extensive control over structure, while client-side JavaScript (including patched YouTube base.js) provides SPF-style navigation and UI interactivity. The codebase demonstrates advanced PHP engineering with protocol buffer serialization, generator-based async concurrency, and a layered model/view architecture. It is actively maintained but carries medium technical drift due to dependence on YouTube's undocumented InnerTube API, generated protobuf code, and a custom async implementation that diverges from modern PHP standards.

Broadcastarr is a media broadcasting service that scrapes broadcast schedules from websites, processes and stores broadcast information, and publishes notifications to platforms like Discord and Gotify. It integrates with media servers (Jellyfin) to make content available as M3U8 streams. The architecture consists of a monolithic application with separate server (API), worker (background tasks), and bootstrap (initialization) components. It uses Agenda for job scheduling, Mongoose for MongoDB ODM, Puppeteer for web scraping, Express for API server, and Discord.js for bot functionality. The system provides a REST API for monitoring and control, along with Discord slash commands for management.