This repository provides a GitHub Action that wraps the lychee link checker to validate links in Markdown, HTML, and text files. The action downloads and installs a specified version of lychee, runs it with configurable arguments, and processes the output to set exit codes and generate reports. The core action is well-designed with robust version handling and error processing, but the associated workflow files show signs of technical drift due to outdated action versions (e.g., actions/checkout@v7 which doesn't exist). The action is actively maintained with recent commits and automated version update workflows.
This repository is a collection of Helm charts for deploying Grafana's observability stack on Kubernetes, including Loki (log aggregation), Tempo (distributed tracing), Mimir (metrics), Grafana (dashboards), Promtail (log shipping), Fluent Bit, and various enterprise variants (Enterprise Logs, Enterprise Metrics). The architecture follows a microservices decomposition pattern where each chart defines Kubernetes resources (Deployments, StatefulSets, Services, ConfigMaps, RBAC, etc.) for individual components such as ingesters, distributors, queriers, compactors, and gateways. Configuration is driven by values.yaml files and Helm template helpers (_helpers.tpl) that generate resource definitions with support for persistence, autoscaling, monitoring (ServiceMonitors, PrometheusRules), and security contexts. In production, these charts enable operators to deploy and manage a full observability pipeline: agents (Promtail, Fluent Bit, Grafana Agent) collect logs and metrics, which are ingested by Loki/Tempo/Mimir, stored in object storage (MinIO, S3) or persistent volumes, and queried through frontend services. The rollout-operator chart provides custom Kubernetes resources (ReplicaTemplate, ZoneAwarePodDisruptionBudget) for safe rolling updates. Many charts are now deprecated or migrated to other repositories (e.g., grafana/loki, grafana/mimir, grafana-community/helm-charts), indicating a consolidation effort. The repository remains maintained with CI/CD workflows for linting, validation, and release, but the high deprecation rate and reliance on custom CRDs introduce maintenance overhead and potential drift from upstream versions.
SenseNova-Skills is a composable collection of AI agent skills for office automation, built around the SenseNova model family. It provides production-grade capabilities for image generation and recognition, presentation (PPT) creation, Excel data analysis, deep research with structured evidence, and multi-source search (academic, social, code, finance). The skills are designed to run in Agent Skills-compatible runtimes (OpenClaw, hermes-agent) and are bundled into the Raccoon product for enterprise use. The architecture is modular: each skill is a self-contained directory with a SKILL.md manifest, scripts, prompts, and schemas. The deep research skill implements a multi-agent pipeline with formal JSON schemas and validators. The PPT skill has a multi-stage pipeline from user input to HTML-to-PPTX conversion via Playwright. The codebase demonstrates solid engineering with reusable components like a shared LLM/VLM client, export pipeline libraries, and validation infrastructure. However, it suffers from duplicated utility code across skills, complex environment variable fallback chains, hardcoded paths, and dependency on external APIs and headless browsers. The repo is actively maintained with biweekly reports and frequent commits.
OpenCart is a free and open-source e-commerce platform written in PHP. It provides a complete online store solution with both a storefront (catalog) and an administrative backend. The architecture follows a custom MVC framework with a route-based dispatch system, event hooks, and an extension system for payments, shipping, modules, and themes. The frontend uses a mix of jQuery (admin) and a custom WebComponent framework (catalog) with a custom template language called Curlytag. The system supports multi-store, multi-language, and multi-currency out of the box, with background task processing for cache generation and email delivery. In production, OpenCart handles product catalog management, shopping cart and checkout flows, customer accounts, order processing, payment integration, shipping calculations, tax handling, and reporting. It includes CMS capabilities (articles, blogs, comments), GDPR compliance tools, and SEO-friendly URL rewriting. The admin panel provides full control over store settings, localization, user permissions, and extension management. Key entry points include the storefront index.php (catalog), admin/index.php (admin panel), and system/framework.php (application bootstrap). External dependencies include a database (MySQL/PostgreSQL), optional caching (Redis/Memcached), and third-party libraries for email, template rendering (Twig), and code editing (CodeMirror). The system is designed to be extensible through a plugin architecture that allows adding new payment gateways, shipping methods, and frontend modules.
llama.ui is a browser-based chat interface for local and cloud LLM inference. It is not a data/research repository: it is a React 18 + TypeScript + Vite 7 single-page application packaged as a PWA with offline storage. The app connects to llama.cpp, LM Studio, Ollama, vLLM, and OpenAI-compatible cloud providers through a provider-factory abstraction, streams completions over SSE, and persists conversation history entirely client-side in IndexedDB via Dexie. Entry points are src/main.tsx and src/App.tsx, with routes for chat, settings, and welcome; state is managed through React Context stores (app, chat, inference, modal).
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.
grzyClothTool is a GTA V modding tool suite consisting of two main applications: CodeWalker (a WinForms-based game file viewer/editor with DirectX 11 rendering) and grzyClothTool (a WPF-based clothing addon manager using MVVM pattern). The tool enables users to import, preview, organize, optimize, and build GTA V clothing assets for FiveM/singleplayer/AltV platforms. Key features include 3D asset preview via CodeWalker integration, duplicate detection, texture optimization, auto-save functionality, and project management. The architecture separates concerns with shared libraries (CodeWalker.Core), plugin support via MEF, and navigation systems for view switching. Data flows involve scanning game files, importing assets (.ydd/.ytd), organizing via tags/groups, resolving conflicts, optimizing resources, and building final addon packages.
Tape is a decentralized video-sharing platform built on Lens Protocol. The monorepo contains multiple frontends: a legacy Next.js app (apps/web), a newer Vite + TanStack Router rewrite (apps/web-vite), an Expo/React Native mobile app, an embeddable video player, and an Open Graph image generator. The backend consists of a Hono API (apps/api) for oEmbed, DID resolution, metadata, and event ingestion, plus a cron service (apps/cron) for cleanup, analytics flushing, and S3 backups. Smart contracts for permissionless signup live in apps/contracts. The platform supports video upload, short-form bytes, comments, mirrors, collects, tips, follows, notifications, search, and profile management, all interacting with Lens Protocol's GraphQL APIs and on-chain contracts. Data flows through several layers: media is uploaded to IPFS/S3/Arweave, metadata is stored on Arweave or IPFS, and social actions are executed via Lens Protocol typed-data signing and broadcasting. The platform also runs an in-house analytics pipeline: browser events are queued through a service worker to Redis, flushed to ClickHouse by cron jobs, and backed up to S3. Postgres (via Prisma) stores platform-level data such as allowed tokens, profile toggles, curated profiles, and platform stats. Redis is used for caching and queueing throughout. Although primarily an application, the repository has a meaningful data/analytics component (ClickHouse schema, event/trail tracking, Redis-backed queues, S3 backup jobs) that could be reused independently. The codebase is actively maintained but carries migration debt: two web frontends, two UI kits (packages/ui and packages/winder), two Lens GraphQL clients (v1 and v2), and commented-out cron services indicate an in-progress transition. No meaningful test suite is present; CI focuses on Biome checks and builds.
Rubick is a cross-platform desktop application built with Electron and Vue 3 that serves as an extensible productivity toolbox. Its core functionality includes a global shortcut-triggered launcher (Alt/Option+R) for quick access to applications, files, and folders, a plugin system that treats plugins as installable npm packages, and WebDAV-based cross-device data synchronization via PouchDB. The architecture features a main Electron process managing multiple renderer windows (main search interface, plugin market, detached plugin windows, and tutorial guide) with communication through IPC. Key dependencies include Vue 3, Ant Design UI library, PouchDB for local storage with WebDAV sync, and native modules for global hotkeys and file icons. The plugin system allows users to extend functionality through a built-in market, with plugins stored locally and loaded into isolated BrowserView instances for security.
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.
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.
This repository contains a build system for FullPageOS, a Raspberry Pi distribution that boots directly into a full-screen Chromium browser kiosk displaying a configurable webpage. The build process uses CustomPiOS to modify a Raspbian base image, installing Chromium, lighttpd (with FullPageDashboard), x11vnc for VNC access, and a set of scripts that manage the browser startup, URL resolution (with serial number substitution), page refresh, and crash recovery. The resulting OS image is designed for digital signage or single-purpose web displays. The repo includes a comprehensive testing framework with end-to-end tests that run in QEMU, verifying Chromium launch, lighttpd service, emoji rendering, and translation disabling via screenshot pixel analysis. The CI pipeline builds images for armhf and arm64 and runs the e2e tests automatically. While the core build scripts are functional and well-structured, they are tightly coupled to the CustomPiOS ecosystem and not independently reusable. The testing components, particularly the screenshot analysis and headless Chromium rendering tests, exhibit higher craftsmanship and could be adapted for other kiosk image validation efforts.
TripStar is a full-stack, multi-agent AI travel planning platform. It uses a FastAPI backend with a modular agent system (trip planner, weather, hotel agents) orchestrated by a large language model, and a Vue 3 + TypeScript frontend with a dark glassmorphism UI. The backend provides REST APIs and WebSocket real-time status updates for asynchronous trip generation tasks. It integrates data from multiple sources: Xiaohongshu (via reverse-engineered signed API and SSR scraping), Google Maps, and AMap (with automatic fallback). The LLM extracts structured attractions from scraped text, plans itineraries, and repairs malformed JSON output. The system also includes user preference memory with weighted decay and TOP-K recall, a knowledge graph module, and export to image/PDF. The frontend features interactive maps, a budget panel, multi-city support, and a floating AI chat widget. The application is Dockerized with a multi-stage build and supports Chinese, English, and Japanese through i18n. The architecture is cleanly separated into backend services (agents, API routes, memory, map dispatcher, scraper), and frontend views (Home, Landing, Result, AIChat). The map dispatcher pattern provides a unified interface for geocoding and POI search across Google and AMap, and the memory manager implements a reusable preference-learning system. However, the codebase has technical debt: heavy reliance on Xiaohongshu's undocumented API (fragile), a monolithic 42k-token CSS file from Paper Kit 2 (2017) with deprecated techniques, and a complex ~2000-line Result.vue component. Dependencies are not fully locked, and the scraper's JavaScript signature engine may break with anti-bot updates. Overall, TripStar is a solid, functional application with several reusable patterns, but it carries moderate maintenance risks due to its external dependencies and some aging code. Note: This is a hybrid application with a strong data-crawling component (Xiaohongshu scraping and LLM extraction), but the dominant character is a production-ready web application with a clear user interface and API.
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 implements AMD's MxGPU virtualization solution, providing SR-IOV support for AMD GPUs (MI200, MI300, Navi32). It consists of a kernel module (GIM) that manages virtual functions, a core library (libgv) for hardware abstraction and RAS, and a user-space system management interface (SMI) with CLI and Python bindings. The architecture is layered: the kernel driver (gim/) communicates with hardware and exposes IOCTLs; libgv/ provides hardware-specific implementations via function pointer tables; smi-lib/ provides a unified API for monitoring, partitioning, RAS, and NIC management. Key entry points include the GIM kernel module (gim/gim_shim/gim_drv.c), the SMI CLI (smi-lib/cli/cpp/src/smi_cli_main.cpp), and the SMI library (smi-lib/src/amdsmi.c). Data flows involve PF-VF mailbox communication, RAS error logging via CPER, and telemetry collection through SMU firmware interfaces. External dependencies include Linux kernel headers, DKMS, and optional NIC libraries. The codebase is large and professionally structured, with extensive hardware abstraction layers, unit tests, and packaging scripts, though it carries maintenance risks from ASIC-specific duplication and embedded firmware blobs.
This repository contains 'asn', a comprehensive Bash-based CLI tool for performing ASN lookups, IP geolocation, path tracing, RPKI validation, Shodan scanning, and more. It can operate in interactive mode or as a self-hosted web server using ncat. The script integrates numerous public APIs (Team Cymru, RIPEStat, ipinfo.io, IPQualityScore, Cloudflare Radar, Shodan, etc.) to provide a unified network reconnaissance and OSINT tool. It is a monolithic shell script (~3700 lines) with tightly coupled functions, limiting reusability. Despite its single-file architecture, it demonstrates solid engineering with caching mechanisms, color-coded output, JSON output support, and a responsive server mode. The project is actively maintained with Docker support, a man page, and CI/CD.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
MediaElement is a mature, client-side JavaScript library that provides a consistent, cross-browser HTML5 video and audio player experience. It wraps native `<video>` and `<audio>` elements with a unified API and UI, while supporting a plugin-based renderer system for fallback and streaming formats including YouTube, Vimeo, HLS, DASH, Facebook, SoundCloud, Twitch, and Dailymotion. The library is distributed as two bundles: a core `mediaelement.js` (API only) and `mediaelement-and-player.js` (with full UI controls). It includes internationalization (i18n) for over 30 languages, subtitle/caption track support, and a range of player features (play/pause, progress bar, volume, fullscreen, time display) that can be customized via a feature injection pattern. Architecturally, the codebase is organized into core modules (`mejs.js`, `mediaelement.js`, `renderer.js`, `i18n.js`), renderer implementations (each self-contained and registered via a common interface), player features (each added as a method on the player prototype), and utility functions (DOM helpers, time formatting, media type detection, polyfills). The build system uses Grunt with Browserify and Babel 6, targeting older browsers (IE10+, iOS 7+, Android 3+). The library is designed to be framework-agnostic but includes optional jQuery/Zepto integration. While the library is functionally complete and widely used, it shows signs of technical drift: the build toolchain is outdated (Grunt, Browserify 13, Babel 6), some dependencies are stale, and the codebase relies on global namespace pollution (`window.mejs`). The player class (`player.js`) is monolithic and handles many responsibilities. Despite these issues, the core abstractions—especially the renderer registry and i18n engine—are well-designed and could be extracted for reuse in other projects.
text2vec is a Python library for converting text (words, sentences, paragraphs) into dense vector embeddings, with a strong focus on Chinese semantic similarity. It provides multiple embedding backends: Word2Vec (Tencent embeddings), Sentence-BERT, CoSENT, BGE, and BM25 for lexical ranking. The library offers a unified API via `SentenceModel` and `Similarity` classes, a command-line interface for batch embedding, and training/fine-tuning scripts for supervised and unsupervised text matching. It also includes deployment examples (FastAPI, Jina, Gradio) and evaluation benchmarks (C-MTEB, MTEB). While primarily an application/library, it has strong research components with detailed model comparison reports and dataset building scripts. The codebase is modular and well-documented, though some training code contains boilerplate repetition and dependency version ranges are broad, introducing potential drift.
flutter-pi is an embedded Flutter engine for Linux systems that enables running Flutter applications on hardware like the Raspberry Pi without an X11 or Wayland display server. It leverages DRM/KMS for display management, GBM for buffer allocation, and supports both OpenGL ES and Vulkan rendering backends. The application initializes the Flutter engine via its embedder API, sets up input handling (via libinput/evdev), and runs a main event loop (using systemd sd-event) to process vsync, input, and platform messages. The architecture is modular, separating concerns into core components: windowing, rendering (OpenGL/Vulkan), compositor, input, and a plugin system for extending functionality (e.g., audio, video, text input). Utilities for reference counting, logging, collections, and geometry are used throughout the codebase. The plugin system allows dynamic registration of Flutter platform channel handlers, enabling communication between Flutter Dart code and native plugins. While the codebase demonstrates solid engineering practices with reusable patterns (such as thread-safe reference counting and an event loop abstraction), it maintains tight coupling to the Flutter embedder API and Linux-specific graphics stack. Ongoing maintenance is evident through active CI/CD workflows and recent commits, though the presence of TODOs and conditional compilation flags indicates areas of technical debt and ongoing work.