thehardwarestore.ai

This repository is a curated collection of prompt examples for GPT models within the Microsoft Power Platform ecosystem. It contains over 100 prompts organized by product area: AI Builder, Copilot Studio, Power Apps, Power Automate, and Power Pages. Each prompt is stored as a markdown file with accompanying metadata (sample.json) and a README describing its purpose, usage, and authors. The repository does not contain any executable code, libraries, or runtime components; it is purely a reference library of natural language prompts intended to be copied and pasted into Power Platform tools. The prompts range from simple text generation (e.g., anagram creator, blog idea generator) to complex multi-modal analyses (e.g., construction site OSHA compliance, expense processor with receipt images). The repository is well-structured with consistent naming conventions, localization support, and a GitHub Actions workflow to validate sample metadata. While not a software application itself, it serves as a valuable resource for Power Platform developers and citizen integrators looking to leverage GPT capabilities.

This repository builds Docker images containing the Android SDK for use in CI/CD environments. It provides two flavors (standalone and lazydl) across two base OS options (Ubuntu and Alpine). The standalone flavor bakes the SDK into the image during build, while lazydl downloads the SDK into a shared volume at runtime. The core functionality resides in the tools/ directory, particularly android-sdk-update.sh which handles SDK installation and licensing. The project uses GitHub Actions to automate multi-architecture builds and publishes to Docker Hub. While functional, the code shows some coupling to specific directory paths and relies on hardcoded package versions, limiting reuse outside its intended context.

pyUmbral is a Python implementation of the Umbral threshold proxy re-encryption scheme. It enables delegating decryption rights for encrypted data through a process where a data owner (Alice) generates re-encryption key fragments that semi-trusted proxies (Ursulas) use to transform ciphertexts, allowing a delegatee (Bob) to decrypt using his private key when a threshold of proxies participate. The library provides core cryptographic primitives including key generation, encryption, decryption, key fragment generation, re-encryption, and verification mechanisms built on elliptic curve cryptography.

Ottoman is a Node.js Object-Document Mapper (ODM) for Couchbase, heavily inspired by Mongoose. It provides a schema-driven modeling layer with type validation, hooks, indexes, and a programmatic N1QL query builder. The library abstracts CRUD operations on Couchbase documents, supports distributed ACID transactions, full-text search, and automatic index management (N1QL, View, and RefDoc indexes). It is designed for production use with TypeScript, includes extensive test coverage against a real Couchbase instance, and offers a CLI for scaffolding. The codebase is well-structured but shows signs of stagnation: the last release (2.5.8) is unpublished, dependencies are outdated (Node >=8, couchbase SDK v4, lodash 4.18.1), and the CHANGELOG has not been updated since early 2022. Despite this, the core architecture is solid and the library remains functional for existing Couchbase projects.

This repository contains a C++ implementation of a whole-body control (WBC) system for humanoid robots using reinforcement learning and motion tracking. The system features a state machine control with multiple states, including Passive, Loco (locomotion), and WBC. It utilizes ONNX Runtime for fast inference with ONNX models and provides a JSON-based configuration for easy parameter tuning.

This repository is a multi-module Android application that functions as a cheat client for Minecraft Bedrock Edition. It intercepts and modifies network packets between the client and server using a custom relay/proxy (Lunaris) and a comprehensive implementation of the Bedrock protocol (CloudburstMC-derived). The app provides a graphical overlay (Pixie with ImGui) for toggling cheat modules such as flight, speed, killaura, ESP, and more. It also includes Microsoft/Xbox authentication, Discord Rich Presence, and an update check mechanism with native signature verification. Architecture: The project is organized into several Gradle modules: `app` (main Android app with Compose UI and cheat modules), `Protocol/bedrock-codec` (versioned Bedrock packet serializers), `Protocol/bedrock-connection` (Netty-based session management), `Network/transport-raknet` (custom RakNet UDP transport), `Lunaris` (relay/proxy for packet interception), `Pixie` (native C++ overlay with ImGui and Dobby hooking), `minecraft-msftauth` (Microsoft authentication), `lunarisrpc` (Discord RPC), and `animatedux` (Compose UI components). The app uses a packet interception pattern where cheat modules (subclasses of `Element`) override `beforePacketBound` to modify or cancel packets before they are sent to the server. Key entry points: `app` module's `MainActivity` or `LaunchActivity` (Android entry), `Pixie`'s `MuffinService` (overlay service), `Lunaris`'s `LuminaRelaySession` (relay logic), and the protocol codec builders (e.g., `Bedrock_v898`). Data flows: The app connects to a Bedrock server via RakNet, the relay intercepts packets, cheat modules modify them, and the modified packets are forwarded. The protocol library handles serialization/deserialization for dozens of protocol versions. External dependencies: Netty (network), OkHttp (HTTP), Firebase (analytics/crashlytics), Gson (JSON), fastutil (collections), Lombok (Java boilerplate), AndroidX Compose (UI), ImGui (native overlay), Dobby (native hooking), and various Android SDK components.

Vrecord is a bash-based CLI and GUI application for capturing analog and digital video signals to digital files, designed primarily for audiovisual archivists. It wraps ffmpeg-ma (a MediaArea fork of FFmpeg with Blackmagic DeckLink support) to capture from DeckLink devices, DV via FireWire, or audio-only inputs, and provides real-time monitoring through ffplay or mpv with configurable scopes (waveform, vectorscope, histograms, bit planes, etc.). The application generates preservation-oriented sidecar files including frame-level MD5 checksums, SCC closed caption files, QCTools XML reports, timecode logs, and optional access MP4 copies. Post-capture, it runs MediaConch policy checks, generates benchmark graphs with gnuplot, and can embed logs into Matroska containers. The codebase is monolithic, consisting of a single ~5000-line bash script (vrecord) that handles configuration (via gtkdialog), capture pipeline construction, and post-processing. Companion scripts include vtest for test signal output, vplay for playback with QC overlays, and cchex_to_display for real-time closed caption display. Dependencies are managed via Homebrew on macOS and Linux (including the AMIA Open Source tap). The project has been maintained for nearly a decade and is actively developed by a community of archivists and developers.

Fluster is a desktop research note-taking application built with Tauri (Rust backend) and React (Vite + Redux) frontend, organized as a polyglot monorepo. It enables users to write notes in MDX with custom embedded components (plots, flashcards, equations, citations), manage bibliographies via BibTeX, run spaced-repetition flashcards, perform semantic search using local Ollama LLMs with LanceDB vector storage, and interact with AI through a chat interface. The system also includes a Python sidecar API for AI sync and indexing, a Next.js documentation website, a Go CLI for internal workspace tooling, and a shared UI component library (`@fluster.io/dev`). While the core application is feature-rich and demonstrates solid engineering patterns (entity/database abstraction via Arrow, command palette architecture, event-driven UI), the codebase shows signs of technical debt including duplicated code across packages, incomplete features (Jupyter, Kanban placeholders), mixed state management strategies, and a stated plan to rewrite in Swift for macOS, which may lead to drift. The extensive feature set and multi-language stack (Rust, Python, Go, TypeScript) increase maintenance surface but also provide a comprehensive research workflow tool.

This repository is a comprehensive gallery of self-contained demo examples for the VJMap (唯杰地图) SDK, a client-side WebGIS library specialized in rendering CAD drawings (DWG) and custom map formats using WebGL vector tiles. Each example is a standalone HTML page with embedded JavaScript that demonstrates a specific feature: map opening (vector/raster/memory), markers, overlays (circles, polygons, symbols, fill extrusion), animations, drawing tools, 3D integration with Three.js/deck.gl/L7, and interoperation with third-party mapping libraries (Leaflet, OpenLayers, MapTalks, Cesium). All demos connect to a hosted VJMap backend service via a hardcoded access token. The code is heavily duplicated across Chinese and English directories (src/src_en) and follows a repetitive boilerplate pattern. While the repository excels as an educational resource for the SDK, it is not a production application; its structure lacks modularity, contains hardcoded credentials, and relies on deprecated libraries in some examples. The primary value is as a reference for VJMap API usage, not as a reusable codebase.

This repository is a collection of educational tutorials demonstrating various Python web frameworks and data analysis techniques. The majority of content consists of self-contained Streamlit applications showcasing features like QR code generation, form handling, session state, file-based routing, and multipage apps. It also includes examples of other frameworks such as FastAPI (with JWT authentication), Reflex, Marimo, NiceGUI, H2O Wave, Dash, and Fasthtml. A notable data research component is the Jupyter notebook analyzing pandas usage patterns across 1.2 million notebooks from UCSD Library archives. Architecture-wise, each tutorial is independent with no overarching system. Streamlit apps range from single-file scripts to multipage applications using st.navigation or custom file-based routing. Backend services like the FastAPI server in the authentication tutorial are paired with Streamlit frontends. The pandas analysis notebook follows an end-to-end pipeline: extracting notebooks from archives, parsing code via AST, filtering results, and visualizing API usage statistics. Key entry points are streamlit_app.py files in each tutorial directory, framework-specific server files (e.g., fastapi_server.py), and the pandasmostused.ipynb notebook. The repository exhibits moderate craftsmanship with several reusable patterns: a file-based routing system for Streamlit, a JWT authentication mechanism securing Streamlit via FastAPI backend, and parallel AST processing for bulk notebook analysis. However, it shows signs of technical drift including mixed use of deprecated and current Streamlit caching methods, hardcoded secrets in plaintext, and inconsistent dependency management. Maintenance is active based on recent commits, but the tutorial nature means some examples prioritize clarity over production best practices.

This repository is an educational tutorial implementation of a stereo visual SLAM (Simultaneous Localization and Mapping) system, based on the classic feature-point method (ORB/GFTT) with optical flow tracking, PnP pose estimation, and local bundle adjustment using g2o. It is structured as a modular C++ library (libmyslam.so) with components for frontend, backend, map management, camera model, dataset reading, and Pangolin-based 3D visualization. The primary entry point is a CLI application that processes KITTI stereo sequences to estimate camera trajectory and sparse 3D map points. While the code demonstrates solid software engineering practices such as threading, singletons, and factory methods, it is not production-ready: it lacks loop closure, map persistence, and comprehensive testing. The repository serves as a hands-on companion to the 'Visual SLAM: From Theory to Practice' textbook, with documentation and chapter-wise code examples. External dependencies include OpenCV, Eigen, Sophus, g2o, Pangolin, and Glog, with version-specific requirements that may cause compatibility issues on modern systems.

Phuzz is a research-oriented web application fuzzing framework that orchestrates multiple fuzzers (Burp Suite, Wapiti, WFuzz, ZAP) alongside its own custom fuzzer to detect vulnerabilities in web applications. The repository includes a custom Python-based fuzzer with mutation and scoring modules, a crawler for discovering endpoints, a HAR generator for request capture, and Docker-based orchestration for running fuzzers against vulnerable test applications (bWAPP, DVWA, WackoPicko, XVWA, WordPress plugins). It also contains extensive experimental data and analysis scripts from studies on known and zero-day vulnerabilities, particularly targeting WordPress plugins. The architecture is modular, with separate components for crawling, fuzzing, and result analysis, all containerized via Docker Compose. While primarily a research tool, the core fuzzer and instrumentation components are well-structured and could be extracted for reuse in other security testing pipelines.

This is a barebones PHP application designed as a getting-started template for deploying to Heroku. It uses the Slim 4 framework with PHP-DI dependency injection, Twig templating, and Monolog logging. The application has a single route (GET /) that renders a static landing page with links to Heroku documentation. The codebase is minimal and clean, following modern PHP practices, but it is intentionally simple—essentially boilerplate for a 'Hello World' style demo. There is no complex business logic, database interaction, or reusable components beyond the standard Slim application bootstrap pattern. The repository serves as a reference for Heroku's PHP deployment workflow and is not intended for production use.

PutongOJ is a full-stack online judge platform built as a pnpm monorepo with TypeScript across the stack. The backend is a Koa 3 server using MongoDB (Mongoose) and Redis, with a separate judger component that executes submissions in a privileged Docker sandbox via go-judge. The frontend is a Vue 3 application using PrimeVue, Pinia, and Vue Router; it provides problem CRUD, testcase management, contest ranklists/status, course management, discussions, and account settings. A shared package (@putong-oj/shared) contains Zod schemas and enums used by both server and client. Although primarily an application, it includes a data migration subsystem and a documented testcase data format, giving it a minor data-engineering flavor.

SimART is a ROS1-based desktop application for wireless communication and sensing research in 6G ISAC scenarios, with a hybrid research-pipeline character. The dominant component is the SimART_GUI package: a C++/Qt5/VTK desktop application (airsim_gui_UErealtime) that provides a 3D scene view with editable base stations, UAV trajectories, multipath beam paths, and QML live views embedding AirSim/Unreal Engine camera streams. A RosBridge node subscribes to custom RF/system/beam observation topics and converts them into Qt signals for visualization, while Python ROS scripts run Sionna RT ray tracing, Sionna SYS link adaptation, beam codebook export, and ML-based beam prediction. Entry points include SimART_GUI/src/main.cpp (QApplication + ROS init), ROS launch files, and CLI scripts such as sionna_ckm_generator.py and sionna_sim_only_topic2.py. The application coordinates a digital-twin data flow: scene meshes are imported from local files, OpenStreetMap (via Overpass/OSM2World), or AirSim runtime; Sionna computes propagation paths and system metrics over UAV/base-station positions; results are published as custom ROS messages (rf_msgs, sionna_sys_msgs, sionna_beam_msgs) and visualized or recorded to rosbag. Offline reprocessing scripts re-simulate recorded bags with Sionna through a socket-based worker process, and a CKM generator produces dense channel knowledge maps as NPZ/PNG/meta JSON with heatmaps and pick-maps. The research side also includes beam-training dataset export, model checkpoints, and a DeepSense-style beam selector, making the repo a functional blend of application GUI and research data pipeline. Notable strengths include a clean ISceneProvider abstraction separating mesh import sources, a FrameTransformManager with a mutex-guarded dirty-flag buffer over a dedicated tf2 thread, and a length-prefixed JSON socket protocol for out-of-process Sionna workers that is duplicated consistently across scripts. Weaknesses are the monolithic MainWindow and AirSimViewController modules, duplicated frame-transform and message-building logic across C++ and Python, and brittle Linux-only preview embedding via wmctrl plus SIGSTOP/SIGCONT process control. The stack is pinned to ROS1 Noetic/Ubuntu 20.04 with legacy Qt5/QVTKWidget APIs and exact external tool versions (Blender 4.2, UE 4.27, OSM2World 0.4.0), so migration or environmental churn would be costly; ROS1 EOL and Qt5 deprecation place the codebase in medium technical drift.

This repository is the documentation site for Factory, an AI-native software development platform centered on the Droid CLI. It contains bilingual (English and Japanese) documentation covering CLI usage, enterprise deployment, integrations, skills, hooks, and benchmarks. The repository also includes CI/CD workflows, changelog automation scripts, and a translation pipeline. While no application source code is present, the documentation is highly structured and includes reusable patterns for skill definitions, hooks, and plugin packaging. The codebase is actively maintained with frequent updates, but exhibits moderate technical drift due to rapid version churn, model name instability, and bilingual documentation divergence.

This repository is Visual Studio Code Void, a deprecated fork of VS Code focused on AI-enhanced desktop editing. While the project is no longer accepting contributions per its README, it contains the core VS Code architecture with additional AI-oriented features in the `src/vs/workbench/contrib/void/` directory. The application provides a code editor experience with syntax highlighting, IntelliSense, debugging, and extension support, built on Electron for desktop with web fallback capabilities. It features a modular architecture with core editor (Monaco), workbench/UI framework, platform services, and extension system, along with a Rust-based CLI for code and tunnel management.