Alumnet is a full-stack, AI-powered alumni exhibition and management system designed for school history museums. It consists of three workspaces: a touch-screen kiosk frontend (client) built with Vue 3, Three.js, and Tailwind CSS; an admin dashboard (admin) using Vue 3 and Element Plus; and a backend server (server) built with Express, TypeScript, PostgreSQL (with pgvector), and Qdrant for vector search. The system provides alumni CRUD, AI-powered natural language search via RAG, 3D galaxy visualization, timeline corridor, interactive message boards, video greetings, donation management, and comprehensive admin controls including content audit, backup/restore, and data import. It features JWT authentication with role-based access, privacy data masking, rate limiting, and a layered architecture (routes → services → repositories). The codebase includes extensive testing (unit, integration, property-based with fast-check) and is deployable via Docker Compose or PM2. While primarily an application, it incorporates data engineering patterns through its RAG pipeline and knowledge base management.
CloudSaver is a full-stack web application (Vue 3 + Express) for searching and saving cloud storage resources from multiple sources. It scrapes Telegram channels for shared files, parses links to popular cloud drives (115, Quark), and allows users to transfer them directly to their own cloud storage via cookie-based API. The system includes user authentication (JWT), role-based access, a responsive UI for desktop and mobile, and Docker support for easy deployment. The backend is structured with dependency injection (Inversify) and follows a controller-service-model pattern, while the frontend uses Pinia for state management and separate routing for PC and mobile views. The codebase is well-organized and demonstrates solid engineering practices, though it remains a typical CRUD application without exceptional innovation.
Snapshot is a decentralized, off-chain, gasless governance platform for DAOs and communities. This repository is the legacy (v1) frontend client, a Vue 3 single-page application (SPA) built with TypeScript, Vite, and Tailwind CSS. It provides a full-featured interface for creating and managing governance spaces, submitting proposals, voting (single-choice, approval, quadratic, ranked-choice, weighted), delegating voting power, and configuring treasury execution via plugins like oSnap and safeSnap. The application interacts with Ethereum and other EVM-compatible chains through Web3 wallets (MetaMask, WalletConnect), fetches on-chain data via subgraphs and RPC calls, and stores proposal content and vote receipts on IPFS. Key entry points include the space creation wizard (SetupView), proposal creation (SpaceCreate), proposal listing and voting (SpaceProposals, SpaceProposal), space settings (SpaceSettings), delegation management (SpaceDelegates), and a boost incentive system (SpaceBoost). The architecture follows a composable-first pattern with extensive use of Vue 3 Composition API, a plugin system for extensible governance features, and a custom UI component library (Tune). External dependencies include @snapshot-labs/snapshot.js for voting logic, @snapshot-labs/lock for wallet connection, Apollo Client for GraphQL queries, and various blockchain APIs (Alchemy, Covalent, Tenderly). The codebase is well-structured but shows signs of technical drift: duplicate code between safeSnap and oSnap plugins, hardcoded API keys, deprecated Vite plugin APIs, and incomplete localization files.
PaoPao-ce is a full-stack micro-community social media platform written in Go (backend) and Vue 3 (frontend). It provides a feature-rich experience similar to Twitter/Weibo, including posts (tweets) with multimedia attachments, comments, likes, collections, private messaging, user profiles, topic/tag support, and a wallet system with Alipay integration. The architecture is modular and configurable, supporting multiple databases (MySQL, PostgreSQL, SQLite), search engines (Meilisearch, Zinc), object storage backends (LocalOSS, MinIO, AliOSS, COS, Huawei OBS, S3), caching layers (Redis, BigCache), and observability tools (OpenTelemetry, Sentry, Pyroscope, pprof). The backend uses Gin for HTTP, GORM for ORM, go-mir for API code generation, and protobuf for gRPC services. The frontend is built with Vue 3, Naive UI, Vite, and Pinia. Key features include feature toggles for different deployment suites, a runtime settings override via admin UI, and background job processing for search indexing and metrics. The platform emphasizes self-hosting and customization, with comprehensive SQL migration scripts and support for desktop clients via Tauri. The codebase demonstrates solid engineering practices with interface-based dependency injection, layered architecture, and code generation, though it carries some technical debt from deprecated backends and WIP features.
Frank is a desktop assistant for League of Legends, built with Tauri (Rust) and Vue 3. It interacts with the League Client Update (LCU) API to provide features such as automatic match acceptance, champion pick/ban, rune recommendations, champion performance statistics, teammate analysis, and personal notes/blacklist management. The application consists of multiple windows: a main UI for home, rankings, runes, teammate analysis, and records; a background window that monitors game flow and auto-actions; an overlay for recent match details during gameplay; a match query window; and a post-game analysis window. It communicates with the LoL client via a custom Rust wrapper (shaco) that handles REST calls, WebSocket subscriptions, and the in-game API, and also fetches external data from Tencent CDN, lolfrank.cn, and a custom backend server for blacklist persistence. The architecture is modular, with separate Vue entry points for each window, Pinia state management, and a Rust backend that handles LCU integration, keyboard listening, window management, and system tray features. The code demonstrates significant reverse engineering of Riot's client APIs and game state management, packaged into a polished cross-platform desktop app.
TypeWords is a browser-based English vocabulary and article memorization application built with Nuxt 3 / Vue 3. It operates on a local-first architecture, storing user progress in IndexedDB, with an optional (now obsolete) Supabase cloud sync. The application is a monolith SPA but is well-modularized into a custom UI kit (app/base/), core business logic (app/core/), and page components (app/pages/). The core learning mechanic is typing-based practice, supporting multiple modes (follow-write, dictation, self-test, spelling) for both individual words and full articles. It integrates the FSRS (Free Spaced Repetition System) algorithm for intelligent review scheduling. Static dictionary data (CET-4, GRE, NCE articles) is loaded from bundled JSON files. The practice flow is managed by a sophisticated, serializable state machine (practice-flow-types/runtime), demonstrating strong architectural patterns. The codebase exhibits high craftsmanship in several isolated components, such as the global dialog stack, event bus, and versioned cache. These are genuinely reusable patterns. However, the project suffers from significant technical drift: it relies on experimental Vue Macros ($ref/$computed), has zero automated tests, contains dead code (obsolete Supabase sync), and bundles third-party libraries statically. The TypeScript configuration is lax (strict: false), increasing refactoring risk. TypeWords is a feature-rich, community-driven project (10k+ stars) that effectively solves a specific learning problem. Its architecture is a valuable study for developers building local-first, content-rich Vue applications. However, its lack of tests and reliance on experimental features make it a risky candidate for direct production reuse without significant hardening. It is best suited for educational analysis or as a foundation for a new project willing to address the technical debt.
Trainbot (Onlytrains) is a computer vision application that automatically detects trains passing a fixed camera, stitches the train's frames into a single composite image, and logs sightings to a SQLite database. It is designed to run on a Raspberry Pi with a camera (USB, Pi Cam 3, or video file) and can optionally upload results via FTP to a web server. The project is unmaintained as stated in the README. Architecturally, it is a monolith Go backend with three CLI binaries: `trainbot` (main detection loop), `confighelper` (interactive crop selection), and `cleanup` (orphaned blob removal). The backend captures frames using `pkg/vid` (abstraction over V4L2, libcamera-vid, ffmpeg), processes them through a stitch pipeline that detects motion, computes frame offsets via patch matching, fits a constant-acceleration model using RANSAC, and then blends frames into a single JPEG and an animated GIF. Results are stored in a SQLite database and served by a built-in HTTP server. The frontend is a Vue 3 static SPA that loads the SQLite database client-side to display train sightings, stats, and images with no server-side rendering. Key highlights include highly optimized image processing: the `pkg/pmatch` package offers four implementations of cosine-similarity patch search (slow Go, optimized Go, Cgo, Vulkan compute), and the `pkg/ransac` package provides a generic RANSAC fitter for the speed model. The codebase demonstrates strong engineering craftsmanship with a clear package structure, extensive tests, test data sets, and a CI pipeline. However, heavy reliance on Cgo and Vulkan, plus the explicit unmaintained status, introduce cross-compilation complexity and potential drift from modern tooling.
This is a Vue 3 Single-Page Application (SPA) that provides an interactive form-based interface for generating Markdown badges using the shields.io service. The application allows users to generate repo metadata badges, generic static badges, package version badges, dynamic data badges, image markdown/HTML, and a catalogue of pre-made badges. The code is written in TypeScript with a clean separation of concerns: core logic modules handle badge generation and URL construction, Vue components manage UI, and a simple store persists user preferences via localStorage. The architecture is monolithic with client-side routing via Vue Router. The project demonstrates solid software engineering practices with comprehensive unit tests, a Makefile for common tasks, and GitHub Actions CI/CD for linting, testing, and deployment. While the codebase is well-structured and maintainable, it relies on the deprecated Vue CLI and some packages are several major versions behind (e.g., TypeScript 4.6, ESLint 8), indicating moderate technical drift. The application is actively maintained with recent commits and a clear release process.
lx-music-desktop is a cross-platform Electron-based music player (Vue 3 + TypeScript) that aggregates multiple Chinese streaming services (NetEase, Tencent, Kugou, Kuwo, Migu, Baidu, Xiami). It provides music search, playback, playlist management, lyrics (including desktop lyric windows and karaoke-style font rendering), downloads with quality tiers, audio effects (EQ, convolution reverb, pitch shifting), cross-device synchronization over a custom WebSocket protocol, and an HTTP Open API for third-party control. The architecture spans three processes: main (Electron window/tray/IPC, SQLite persistence via better-sqlite3), renderer (Vue app with custom reactive stores and a plugin-based audio engine), and renderer-lyric (dedicated always-on-top lyric window). All built-in music sources were removed in v2.6.0 following a Tencent legal complaint; the app now relies entirely on user-supplied Music API scripts, introducing a sandboxed script runtime with security warnings. The repository is actively maintained (last commit 2026-09-19) but the project is in a transition phase—the maintainer has announced a successor project ('Any Listen'), and the codebase shows signs of legacy accumulation: extensive commented-out code, duplicated components (e.g., MusicSortModal), hardcoded API endpoints/signatures that break frequently, and a custom store implementation diverging from Vuex/Pinia. Despite this, the code is well-organized around provider SDK adapters, composable logic hooks, and a clear main/renderer IPC boundary, with several genuinely reusable patterns.
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 is a Cockpit web UI plugin for managing file sharing services on Linux servers, developed by 45Drives. It provides a single-page application with separate tabs for Samba (CIFS), NFS, iSCSI (using SCST driver, both single-server and clustered with Pacemaker), and S3 object storage (supporting MinIO, RustFS, Ceph RGW, and Garage backends). The architecture is a Vue 3 + TypeScript frontend that communicates with the server by executing shell commands, parsing configuration files (e.g., /etc/exports, smb.conf), and interacting with backend-specific CLIs (mc, radosgw-admin, garage) and S3-compatible APIs. Key entry points include App.vue for top-level routing, and per-tab main components (SambaTabMain, NFSTabMain, ISCSITabMain, S3ManagementMain). Data flows are user-driven: configuration changes are applied via system commands and written to configuration files, with systemd service management for start/stop/status. The codebase demonstrates reasonable engineering practices with error handling using neverthrow, but has some legacy code in file-sharing-old/ and significant coupling in the iSCSI cluster driver. It is actively maintained with frequent releases and many open issues.
Formvuelar is a Vue 3 form component library designed for backend-driven form workflows, with first-class support for Laravel-style validation responses. The source defines 19+ Fvl* components (input, textarea, select, search select, tag select, checkboxes, radio, switches, sliders, color/date pickers, file uploads, dropzone) and a root FvlForm component that coordinates submission, error display, dirty-state tracking, and upload progress. The core architecture uses provide/inject plus mixins: FvlForm creates a form context object and child controls inject it via formControl.js to read backend errors, clear errors on input, and expose loading and upload state. Submission is handled by Axios with per-form instances and interceptors; the library expects Laravel's 422 { message, errors } payload by default but can be adapted through global $formvuelar configuration.
city-roads is a browser-based single-page application that fetches OpenStreetMap road data and renders every road in a chosen city as WebGL line art. Users search for a city; the app geocodes the query via Nominatim, suggests administrative boundaries, and then loads data either from a prebuilt protobuf cache hosted on CloudFront/S3 or from the Overpass API. The downloaded OSM nodes and ways are parsed into a Grid object, projected into 2D local coordinates with a Mercator projection, and pushed into a w-gl WireCollection for fast canvas rendering. The UI supports changing road, background, and label colors, editing the city label, saving PNG and SVG exports, and generating Zazzle mug links. A console API exposed as window.scene and window.Query lets advanced users run arbitrary Overpass queries and compose multiple city layers. Architecturally it is a Vue 3/Vite frontend with a clean separation between small lib modules (request, progress, grid, query builders, exporters) and UI components. There is no backend; all data comes from OSM and Nominatim public services plus a static cache. The repository is primarily an application rather than a data-research project, but its lib layer contains genuinely reusable geospatial and Overpass utilities. The codebase is compact, mostly readable, and handles real-world failure modes such as Overpass mirror outages, large downloads, cancellation, and high-resolution exports. Notable weaknesses are the absence of automated tests and CI, leftover Vue CLI configuration, outdated dependencies (Vite 2, Vue 3.2), a debugger statement in App.vue, and a broken custom-projector branch in LoadOptions. Overall it is a solid, functional visualization app with several modular components that could be extracted for other OSM or WebGL projects.
MaterialSearch is a fully offline, local media search engine that uses CLIP (Chinese-CLIP) to search photos and videos by natural language or image similarity. The repository contains the frontend web application and a desktop GUI launcher; the core search logic (scanning, embedding, matching) lives in a separate, obfuscated pip package (`materialsearch-core`). The frontend is a Vue 3 single-page application built with Element Plus, providing five search modes (text-to-image, image-to-image, text-to-video, image-to-video, text-image similarity), along with file path copying, clipboard image paste, and video clip download. Deployment options include a Docker container (via docker-compose.yml) or a Windows executable bundle. The system is designed to run entirely on the user's machine with no data uploaded to the cloud, making it suitable for privacy-sensitive or air-gapped environments.
BD2ModManager is a Tauri + Vue 3 + TypeScript desktop application for managing mods for the game BD2 (Brown Dust 2). It is primarily an application, not a data/research repository, though it consumes static game data and remote CSV/JSON assets. The app provides mod lifecycle management (install, delete, sync/unsync, rename, update author, refresh), profile management, GitHub-based mod installation, and an integrated updater. The frontend is built with Vue 3 and Pinia, using Vue Router for navigation and composables for reusable logic; the backend is a Rust/Tauri shell that handles filesystem operations, symlinks, and the updater.
The hCaptcha Vue Component Library provides Vue 2 and Vue 3 components for integrating hCaptcha into Vue applications. The library consists of two packages (@hcaptcha/vue-hcaptcha for Vue 2 and @hcaptcha/vue3-hcaptcha for Vue 3) built from a shared Vue component source. The component handles loading the hCaptcha API script, rendering the widget, and emitting events for verification, expiration, and other hCaptcha callbacks. It also provides methods to programmatically execute and reset the challenge. A notable utility in the library is the script loader (hcaptcha-script.js) which ensures the hCaptcha API is loaded only once per page using a promise-based pattern. This utility is framework-agnostic and could be reused in other projects requiring singleton script loading. The repository is set up as a monorepo using Lerna, with separate build processes for Vue 2 (using Vue CLI) and Vue 3 (using Vite). While the component itself is well-maintained and functional, the build toolchain shows signs of technical drift with outdated dependencies (e.g., Vue CLI 3, Vite 2, Jest 26). The project is actively maintained with CI pipelines for building, testing, and releasing new versions.
This repository is a fully functional, offline single-player space strategy game (OGame clone) built with Vue 3, TypeScript, Pinia, and shadcn-vue. It implements the complete OGame feature set: resource management, building, research, fleet combat, defense, diplomacy, NPC AI, achievements, campaigns, and a battle simulator. The architecture is a modern SPA with client-side persistence (localStorage encrypted via AES), optional WebDAV cloud sync, and multi-platform builds (web, desktop via Electron, Android via Capacitor, Docker). The game logic is organized into modular TypeScript files under `src/logic/`, with a centralized game loop in `App.vue` that processes resource production, construction queues, fleet missions, NPC behavior, and achievement checks every second. The UI uses a custom component library built on shadcn-vue and Reka UI, with full internationalization (8 languages). The repository also includes a Go-based static server for production deployment and a battle simulation Web Worker for offloading heavy computation. While the codebase is well-structured and demonstrates good use of modern frontend patterns, it is heavily coupled to game state and lacks automated tests, which limits reusability of most modules outside this project.
AgentHub (also known as Maestro) is an Electron desktop application that orchestrates a virtual software development team of 46 AI agents powered by Claude Code CLI. The system enforces a 'Harness Engineering' methodology: Skills (standardized slash commands), Hooks (pre/post tool interceptors), Gates (quality checkpoints G0–G6), and FileWatchers (auto-sync markdown files to database). The GUI is intentionally limited to monitoring and three core operations—most workflow is driven by slash commands within Claude Code sessions. Architecture follows a three-layer pattern: Vue 3 + TypeScript renderer communicates via Electron IPC (contextBridge) to a main process with ~16 singleton services (session-manager, task-manager, gate-keeper, hook-manager, etc.). Persistence uses sql.js (SQLite in-memory) with a debounced disk save and 13 migrations. The source of truth is markdown files in `.knowledge/` and `.tasks/` directories, which are watched by chokidar and synced to the database. The app supports bilingual UI (zh-TW/en) and runs on Windows, macOS, and Linux. Key features include: sprint-based project management with task dependency tracking, interactive terminal sessions (xterm.js + node-pty), cost tracking per session, Git integration, a gate pipeline with review workflows, and a skill/hook management system with hash-based idempotent deployment. The codebase is well-structured with reusable components and services, though it shows some technical drift (alpha dependencies, brand name mismatch, Windows-specific paths) and high complexity from the extensive agent definitions and knowledge base.
GreenResourcesManager is an Electron + Vue 3 desktop application for local-first management of personal digital media collections—games, images, videos, novels, audio, websites, and software. It provides a config-driven UI with customizable pages, tag-based filtering, batch import, and built-in readers (EPUB, PDF, comic viewer, video player). Notable features include a desktop pet gamification system (affection, hunger, earnings), a disguise mode for privacy, a plugin system, and a local HTTP API for external access. Data is stored in SQLite with legacy JSON file backup. The application is actively developed (last commit April 2026) with a sizable feature set and internationalization (zh-CN, zh-TW, en, ja). However, the codebase shows significant technical drift: near-duplicate main-process code in `electron/` and `public/js/`, incomplete migration from JSON to SQLite, hardcoded Windows-specific paths, and extensive debug logging scattered throughout. The pet subsystem is tightly coupled and the plugin system remains marked as under development. While the config-driven UI pattern and composable architecture offer reuse potential, overall craftsmanship is average—functional but with notable boilerplate and coupling.
A cross-platform media aggregation desktop and mobile application built with Tauri v2 and Vue 3. It allows users to create, import, and manage custom JavaScript-based source extensions that scrape or fetch content from websites for books, comics, videos, photos, and music. The app includes a built-in code editor (Monaco) for authoring extensions, a download manager with HTTP and M3U8 support, text-to-speech (Edge TTS), cloud synchronization with conflict resolution (tombstones, incremental sync), DLNA casting (Android), and a source marketplace. The architecture is plugin-heavy, with many custom Tauri plugins for web scraping, media session, and command bridges. While the core functionality is comprehensive and actively maintained, the codebase exhibits tight coupling to custom plugins, limited test coverage, and security concerns from dynamic code execution of user-provided source scripts.