thehardwarestore.ai

MultiGen is an AI agent platform designed for private, on-premise deployment. It features a planner-react architecture where a planner agent creates task plans and a react agent executes them using various tools (web browsing, shell commands, file operations, multimodal generation). The system maintains persistent session history via PostgreSQL, enabling conversation continuity and agent memory retention. Extensibility is supported through Model Context Protocol (MCP) and Agent-to-Agent (A2A) integrations. The backend is built with FastAPI using a layered architecture (Interface/Application/Domain/Infrastructure), the frontend with Next.js 14 App Router, and execution occurs in a sandboxed Docker container with Ubuntu, Chrome, and VNC. Real-time updates are delivered via Server-Sent Events (SSE) powered by Redis streams.

PostgresGUI is a native macOS PostgreSQL client application built with SwiftUI and SwiftData. It provides a desktop interface for managing PostgreSQL database connections, executing queries, browsing schemas, and manipulating data. The application features SSH tunneling support for secure connections, credential storage via macOS Keychain, query result editing capabilities, and export functionality. Built with a protocol-oriented MVVM-like architecture, it emphasizes separation of concerns through distinct layers for networking, data persistence, UI presentation, and state management. The app handles complex concerns like connection lifecycle management, result set normalization, and concurrent operations using modern Swift concurrency patterns.

Fluorine-Manager is a Linux-native mod manager derived from Mod Organizer 2, designed to manage game modifications without altering the original game files. It employs a virtual file system (VFS) using FUSE to overlay mod files, enabling safe mod installation and conflict resolution. The application features a Qt-based GUI with extensive plugin architecture supporting Bethesda games (Skyrim, Fallout series) and non-Bethesda titles through Python and C++ plugins. Core functionality includes mod organization, load order management, BSA/BA2 archive handling, INI file manipulation, and integration with Nexus Mods and Steam/Proton for Windows game compatibility on Linux. The system follows a modular design with clear separation between core logic, game-specific implementations, and utility libraries.

The academic-skills repository is a collection of prompt engineering assets designed to assist with academic research workflows when used with large language models like ChatGPT. It provides eight distinct skills, each encapsulated in a self-contained directory containing a skill description (SKILL.md), platform-specific metadata (agents/openai.yaml), and optional reference templates or scripts. The skills cover tasks such as reading and noting papers, writing literature surveys, monitoring arXiv for new publications, analyzing reviewer comments, summarizing experiment logs, extracting benchmark information, identifying research gaps, and generating weekly lab updates. The repository emphasizes reliability and reproducibility by constraining LLM outputs to avoid hallucination, providing clear input processing rules, and offering structured templates for consistent results. One skill (paper-feishu-digest) includes a deterministic Python script for fetching and filtering arXiv papers, demonstrating a hybrid approach that combines LLM assistance with traditional data processing. Additional tools for validating the repository structure and packaging skills for distribution are included, all written using only the Python standard library to minimize dependencies. The codebase exhibits strong modularity, with each skill following a uniform structure that facilitates maintenance and extension. The arxiv_digest.py script stands out as a reusable component for arXiv data processing, featuring robust error handling, keyword-based ranking, and conservative inference of paper contributions and limitations from abstracts. Overall, the repository represents a well-crafted toolkit for enhancing academic productivity through LLM augmentation, balancing prompt engineering with selective use of deterministic scripts where appropriate.

GPU-T is a Linux desktop utility for comprehensive GPU information and monitoring, positioned as a GPU-Z alternative for Linux. It provides real-time sensor data (clocks, temperatures, power, fan speeds), static hardware specifications from JSON databases and sysfs, and detection of API capabilities (Vulkan, OpenCL, CUDA, etc.) through a modular probe system. The application follows the MVVM pattern with Avalonia UI and features a sidecar process for NVIDIA-specific NVAPI/NVML interactions to ensure stability and isolate native interop. Hardware detection relies on sysfs paths, external tool execution, and vendor-specific databases, with user override capabilities for hardware specifications. The modular design separates concerns into probes for hardware polling, advanced providers for feature detection, and utilities for common tasks like settings management and shell command execution.

Seatsurfing is a full-stack, self-hostable desk and room booking system. The backend is a Go application using gorilla/mux, PostgreSQL, Valkey/freecache caching, JWT authentication, and gRPC for a plugin system. The frontend is a Next.js/React TypeScript application with two interfaces: a booking UI and an admin UI. The system manages organizations, locations, spaces, bookings, recurring bookings, public bookings, approval workflows, custom booking attributes, user roles, and granular permissions. It supports multiple authentication methods including password, OAuth2/OIDC, TOTP, and WebAuthn passkeys. The code is structured into repository, service, router, and API layers, with schema upgrades embedded in repositories and a separate plugin host API for extending backend and UI behavior.

OneConfig is a modular, Compose-based configuration library for Minecraft mods, providing a unified API for config definitions, UI rendering, HUD management, keybind handling, event system, and notifications. It supports multiple Minecraft versions and mod loaders (Fabric, NeoForge) via a stonecutter-based build system and extensive mixin compatibility layers for third-party mod configs (e.g., YACL, ClothConfig, MoulConfig). The library features a custom Compose runtime (poly-compose) for Skia-accelerated UI, a tree-based config model with annotation-driven properties, and a service-loader-based platform abstraction. It is actively maintained with a large test suite covering config persistence, event validation, keybind codecs, and HUD migration.

This repository provides deployment and configuration artifacts for Mend Renovate Self-Hosted, a commercial offering that wraps the open-source Renovate dependency update tool. It contains Helm charts for both Community and Enterprise editions, Docker Compose examples, environment variable references, TLS configuration templates, and OpenAPI specifications for the management API. The actual application code (server, worker, web UI) is distributed as pre-built Docker images and is not present in this repo. The system operates as a distributed job queue: a server schedules and enqueues dependency update jobs, workers execute Renovate CLI runs, and an optional web UI provides administrative dashboards. Enterprise features include worker queue isolation, Kafka event notifications, RBAC, and enhanced reporting (LibYears, pull request stats). The repository is well-documented with clear setup guides for GitHub, GitLab, and Bitbucket Data Center, and includes CI/CD workflows for linting and releasing Helm charts. While the repo contains no application source code, its deployment artifacts are professionally structured and follow best practices for extensibility (e.g., extra manifests, worker pool templates).

PyLoxone is a Home Assistant integration that enables communication with Loxone Miniserver systems. It allows Home Assistant to discover, monitor, and control Loxone devices (lights, switches, sensors, climate systems, etc.) through both HTTP API and WebSocket connections. The architecture separates Home Assistant-specific logic from the Loxone communication protocol via a dedicated pyloxone_api library. Key features include automatic token-based authentication with refresh capabilities, real-time state updates via WebSocket, entity creation across multiple Home Assistant platforms (sensor, binary_sensor, switch, cover, climate, media_player, etc.), and services for sending direct commands to Loxone devices. The integration handles connection lifecycle management, device discovery, and provides diagnostics and system health information.

ASPECT (Advanced Solver for Problems in Earth's ConvecTion) is a massively parallel, finite-element geodynamics simulation code built on the deal.II library. It solves the Stokes and advection-diffusion equations for mantle convection, lithosphere dynamics, melt migration, and related tectonic processes. The code features a highly modular plugin architecture with registration macros for material models, heating models, boundary conditions, postprocessors, mesh refinement, particle tracking, and more. It includes an extensive benchmark suite for code verification and numerous cookbooks demonstrating real geodynamic applications. The repository also bundles the Geodynamic World Builder (contrib/world_builder), a standalone library for constructing initial temperature, composition, and velocity fields from structured input files. ASPECT is actively developed with continuous integration, Docker support, and coupling to external tools like Landlab and FastScape for surface processes.

This repository is a Dalamud plugin for Final Fantasy XIV that provides real-time boss encounter assistance. It includes a modular system for defining boss mechanics (AOEs, stacks, spreads, knockbacks, etc.) using a component-based architecture with state machines. The plugin covers all expansions from A Realm Reborn through Dawntrail, including dungeons, trials, savage raids, ultimates, alliance raids, hunts, deep dungeons, and quests. It also features an autorotation system for cooldown planning and AI movement hints, as well as replay recording and analysis tools for post-fight review and reverse-engineering of game mechanics. The architecture is centered around `BossModule` subclasses that define encounter logic via `StateMachineBuilder` and reusable `BossComponent` classes. Components observe game events (casts, statuses, icons, tethers) and produce arena overlays, text hints, and AI suggestions. The codebase is large and community-driven, with contributions from many developers. While the core framework is well-structured, there is significant per-encounter code that is tightly coupled to specific game data (action IDs, status IDs, positions), leading to maintenance overhead and occasional incomplete or placeholder implementations. The plugin is actively developed, with support for the latest expansion (Dawntrail) and ongoing updates. However, the reliance on reverse-engineered game data and hardcoded values means that patches can break functionality. The codebase includes many TODO comments and some modules marked as incomplete, indicating areas of ongoing research or unfinished work.

This repository is the official application store catalog for the 1Panel server management panel. It contains hundreds of versioned definitions for self-hosted software (databases, CMS, monitoring, AI tools, messaging, etc.), each packaged with a Docker Compose template, a structured data.yml metadata file defining installation form fields, and lifecycle scripts (init, upgrade, uninstall). The repository itself is not a running service; it is a curated, machine-readable configuration catalog consumed by the 1Panel platform to present one-click deployment options and manage application upgrades. The architecture follows a consistent pattern: apps/<name>/<version>/ with standardized docker-compose.yml files using external networks (1panel-network), PANEL_* environment variables, and labels createdBy: "Apps". The repo relies on external Docker images and the 1Panel runtime, and uses Renovate bots and CI workflows to track upstream version changes and enforce validation rules (e.g., OpenResty module catalog checks). It also bundles complex components like a WAF rule set for OpenResty and AI prompt templates for applications such as TrendRadar, showcasing cross-app reusability of configuration patterns.

BookWith is a next-generation e-reader application that enhances traditional book reading with AI capabilities. The system allows users to upload and read EPUB books, annotate text, interact with an AI chatbot for contextual questions about the content, and generate AI-powered podcasts from book material. The architecture follows a client-server model with a Next.js/React frontend and a FastAPI/Python backend, employing domain-driven design principles. Key features include a multi-layer memory system for maintaining conversation context, semantic search via Weaviate vector database, and integration with external AI services like Gemini and Google Cloud Text-to-Speech. The frontend uses modern React patterns with Zustand/Jotai for state management, Tailwind CSS for styling, and shadcn/ui-inspired components. The backend utilizes PostgreSQL for relational data, implements clean architecture with separate domain/application/infrastructure layers, and provides a well-structured API with automatic OpenAPI schema generation.

This repository is a comprehensive XAML Behaviors library for Avalonia UI, porting the Microsoft.Xaml.Behaviors pattern to the Avalonia framework. It provides a declarative, XAML-friendly way to attach interactive logic (behaviors, triggers, actions) to UI controls without code-behind, covering common patterns such as event handling, data-driven triggers, command invocation, property changes, drag-and-drop, animations, validation, focus management, and more. The library is split into multiple NuGet packages: core interactivity (base classes), interactions (ready-to-use triggers/actions), custom interactions (control-specific behaviors), drag-and-drop, draggable elements, events, animations, responsive layout, scripting, and ReactiveUI integration. A key innovation is the use of Roslyn source generators to produce strongly-typed, reflection-free versions of actions and triggers, improving AOT compatibility and compile-time safety. The architecture follows a layered design: the foundation is the `Avalonia.Xaml.Interactivity` namespace with `Behavior`, `Trigger`, `Action` base classes and the `Interaction` static class for attaching behaviors. On top of that, `Avalonia.Xaml.Interactions.Core` provides common triggers/actions like `EventTriggerBehavior`, `InvokeCommandAction`, `ChangePropertyAction`, and `DataTriggerBehavior`. The `Custom` package adds hundreds of specialized behaviors for controls (e.g., `AutoCompleteBoxOpenDropDownOnFocusBehavior`, `SplitViewStateBehavior`, `FocusTrapBehavior`). Drag-and-drop is handled by a dedicated framework with `DropHandlerBase`, `ManagedDragDropService`, and behaviors like `PanelDragBehavior`. Animations are built using Avalonia's composition API, with helpers like `AnimationFactory` and `FluidMoveAnimation`. The source generators in `Xaml.Behaviors.SourceGenerators` produce typed wrappers from attributes like `[GenerateTypedAction]` and `[GenerateTypedTrigger]`, reducing boilerplate and runtime reflection. Key entry points for consumers are the `Interaction.Behaviors` attached property in XAML, the `Interaction.ExecuteActions` method, and the various behavior/trigger/action classes. The library depends on Avalonia UI (StyledElement, Control, Visual, TopLevel, etc.) and optionally on ReactiveUI. It includes extensive documentation via DocFX, sample applications demonstrating all features, and unit tests using Avalonia's headless testing infrastructure. The codebase is well-structured with clean abstractions, though its large surface area and reliance on internal Avalonia APIs present some maintenance risks.

Mosparo is a self-hosted, open-source spam protection system that replaces CAPTCHA on web forms. It is built as a monolithic Symfony 6.4 application (PHP 8.1+) with Doctrine ORM supporting MySQL, PostgreSQL, and SQLite. The system provides a multi-tenant architecture where each project (website) can define custom spam detection rules (field rules for words, emails, domains, IPs, user agents, etc. and submission rules like random value detection) and security measures (honeypot, minimum time, proof-of-work, request delaying, IP lockout, equal submission blocking). Integration is done via a frontend JavaScript widget that communicates with a verification API. The codebase also includes an administration panel for system settings, user management, GeoIP2 integration, rule package imports, statistics, and self-update capabilities. The architecture follows standard Symfony patterns with controllers, services (helpers), repositories, and Twig templates. The rule engine is extensible via interfaces and is reasonably well-tested at the unit level. The project is actively maintained with a robust CI/CD pipeline and Docker support.

FluentModbus is a .NET library that implements the Modbus protocol (TCP and RTU) for client and server communication. The library provides a full set of function codes (class 0, 1, and partial class 2) including read/write holding registers, coils, discrete inputs, input registers, and combined read-write operations. Both synchronous and asynchronous APIs are available. The server supports multiple unit identifiers, frame validation via a user-defined callback, events for register/coil changes, and configurable endianness. The client exposes high-level generic methods as well as low-level byte-oriented access. The codebase is well-structured with abstract base classes (MobusClient, ModbusServer), separate request handlers for TCP and RTU, and clean separation of concerns. Dependencies are minimal (logging abstractions, I/O, memory). The library includes comprehensive unit tests and samples.

This repository provides Chinese input method addons for the Fcitx5 input method framework. It implements Pinyin (including Shuangpin, fuzzy pinyin, stroke filtering, cloud pinyin, prediction) and table-based input methods (Wubi, Cangjie, Erbi, etc.) as Fcitx5 modules. The architecture follows a plugin/addon pattern, with engines handling key events, candidate generation, and text commit. Supporting modules handle punctuation, fullwidth characters, simplified/traditional Chinese conversion (via OpenCC), cloud pinyin (with pluggable backends like Google and Baidu), and pinyin helper (stroke lookup). GUI tools for custom phrase editing and dictionary management are included. The codebase is well-structured, uses modern C++17, and integrates tightly with Fcitx5's event and configuration systems. External dependencies include libime, Qt6 (for GUI), OpenCC, curl, nlohmann_json, and optionally Lua. The project is actively maintained with a comprehensive test suite.

CCteam-creator is a Claude Code skill that enables multi-agent team orchestration through file-based planning and role-based collaboration. It sets up persistent agent teams with specialized roles (backend-dev, frontend-dev, researcher, e2e-tester, reviewer, custodian) that communicate via SendMessage while maintaining state in .plans/ directories. The system includes mechanisms for context recovery, team snapshots, doc-code synchronization, invariant-driven review, and automated code quality checks via golden_rules.py. Team-lead (the main conversation) acts as the control plane managing task delegation, phase gates, and operational protocols.