ZaloCRM is a production-grade, multi-tenant customer relationship management system deeply integrated with the Vietnamese Zalo messaging platform. It serves real-estate sales teams by unifying contact management, real-time chat, lead scoring/automation, appointment scheduling, media library, RBAC, privacy controls, and third-party integrations (Facebook Lead Ads, Telegram bridge, Google Sheets). The system is deployed as a Node.js/Fastify monolith with PostgreSQL (Prisma ORM), Redis (BullMQ queues, rate limiting), MinIO/S3-compatible storage, and Socket.IO for real-time events. It relies on the unofficial Zalo SDK (zca-js) for messaging operations and supports multiple AI providers (Anthropic, Gemini, OpenAI) for reply drafting, sentiment analysis, and appointment parsing. The architecture follows an open-core model: the Community edition ships with extension stubs (`_ee-stubs`) that are replaced in the Enterprise edition. Key entry points include auth routes (JWT with rotating refresh tokens), Zalo account management (QR login, reconnect), friend sync (cron-driven diff-then-emit), and a rich chat operations module (reactions, edits, forwards). Background jobs handle lead pool assignment, care session monitoring, scoring decay, and engagement pattern classification. The system maintains strong data invariants through Prisma extensions (tenant context, RLS preparation, safe-contact-write) and a custom privacy layer that redacts private-nick messages based on viewer role. Data flows center on the Zalo account pool: inbound messages are ingested via socket listeners or friend sync, routed to conversations via a global-aware resolver, and triggers automation hooks (care sessions, auto-tags, sequence advancement). Analytics are derived from daily engagement materialization and scoring engine (4 dimensions with weights). External dependencies are managed via Redis-backed rate limiters, while storage operations are abstracted behind a `StorageDriver` interface with local/R2 implementations. The codebase is actively maintained with daily commits, extensive Prisma migrations, and a comprehensive test suite covering privacy invariants, merge policies, and regression scenarios.
LUML is an agent-native MLOps platform that orchestrates the full machine learning lifecycle: experiment tracking, model packaging, registry, deployment, monitoring, and AI-mediated code generation. The monorepo contains multiple services: a FastAPI backend (multi-tenant platform API with PostgreSQL), a Vue 3 frontend (SPA with Pinia, PrimeVue), a satellite runtime for edge deployment and monitoring (Docker/Kubernetes), an SDK for experiment tracking and model packaging (supporting sklearn, XGBoost, LangGraph, LLM evaluation), a Prisma service for agent-driven code generation (Claude/Codex orchestrator with git worktree isolation), a local experiment tracker (lumlflow) with both a Textual TUI and web interface, and WASM-based in-browser ML workers (prompt optimization, tabular forecasting). The architecture is microservice-oriented with a shared SDK and wire contracts. The platform is production-grade with comprehensive testing (unit, integration, E2E), CI/CD pipelines, OpenAPI contracts, and a well-defined RBAC permission matrix. It demonstrates high craftsmanship in areas like monitoring drift computation (PSI, multivariate), WebWorker RPC proxies, and LLM judge scoring, though the sheer size and number of packages introduce some coordination complexity.
Halo is a full-stack content management system (CMS) and blogging platform built on Spring Boot WebFlux (reactive) and Vue 3. It provides a Kubernetes-inspired extension model for defining custom resources (posts, pages, comments, attachments, themes, plugins) with automatic RESTful CRUD endpoints, indexing, and reconciliation controllers. The system features a plugin architecture (PF4J-based) that allows third-party extensions to contribute UI bundles, security filters, notification handlers, search engines, and theme template processors. The frontend is split into an admin console and a user center, both built with Vue 3, FormKit, TanStack Query, and a rich-text editor (Tiptap). Security includes multiple authentication methods (password, OAuth2, email code, TOTP two-factor), RBAC authorization, remember-me, device management, and sudo confirmation. The theme engine uses Thymeleaf with custom dialects and a finder pattern to expose backend data to templates. The codebase is large but well-organized, with clear separation between API interfaces and implementations, extensive use of reactive programming, and a strong emphasis on extensibility through extension points.
This repository is Taro, a large-scale cross-platform application framework that compiles a single React/Vue/Solid codebase to multiple targets: WeChat/Alipay/Baidu/ByteDance/QQ/JD mini-programs, H5 web applications, React Native, and HarmonyOS. It is a monorepo containing over 100 packages coordinated via pnpm workspaces. The architecture spans CLI tooling (`@tarojs/cli`), build runners (Webpack5 and Vite with platform-specific loaders), a runtime layer that simulates DOM/BOM for non-browser targets (`@tarojs/runtime`), platform adapters that map component and API specifications for each target (e.g., `@tarojs/platform-weapp`, `@tarojs/platform-harmony`), and Rust-based SWC plugins for compile-time JSX optimization (`crates/swc_plugin_compile_mode`). The project is actively maintained with a large community (over 37K stars), frequent commits, and thorough testing across packages, including unit, integration, snapshot, and e2e tests. However, some platform-specific stubs (e.g., `temporarilyNotSupport` for Harmony) and multiple parallel Harmony implementations indicate medium technical drift in certain areas.
ChatDev 2.0 (DevAll) is a zero-code multi-agent orchestration platform for building and executing graph-based AI workflows. Users define directed acyclic or cyclic graphs in YAML, composing agent nodes (with LLM providers, memory, tools, thinking modes), human-in-the-loop nodes, Python executors, subgraphs, and control-flow edges with conditions and data transformations. The system supports dynamic parallel execution patterns (Map/Tree), multiple memory stores (simple, file-based FAISS, cloud Mem0), and extensible tooling via local Python functions or MCP servers. The architecture is a full-stack application: a FastAPI backend with REST and WebSocket endpoints for workflow execution, batch runs, artifact streaming, and session management; a Vue 3 frontend with a visual workflow editor (VueFlow), dynamic schema-driven forms, and real-time execution monitoring; a CLI entry point (`run.py`); and a Python SDK (`runtime/sdk.py`) for programmatic use. The codebase is well-structured with registry patterns for extensibility, declarative configuration dataclasses with auto-generated UI forms, and a modular runtime with pluggable node executors, edge conditions, and memory stores. While primarily an application, the project has strong research roots (OpenBMB lab, Tsinghua NLP) and includes academic references (ChatDev, Co-Learning, MacNet). It serves as both a production-grade tool for multi-agent automation and a research platform for experimenting with agent architectures, memory systems, and collaborative workflows. The repository includes 20+ example workflows demonstrating diverse use cases from software development and data visualization to 3D scene generation and deep research.
Open Video Downloader (formerly youtube-dl-gui) is a cross-platform desktop GUI for downloading videos and audio from YouTube and over 1000 other websites, using yt-dlp as its core engine. It provides a queue-based download workflow with features including format/codec selection, subtitle management, SponsorBlock integration, authentication (cookies, tokens, passwords), input filtering (date, size, match filters), and extensive output customization (containers, filename templates, directory organization). The application also manages automatic updates of both itself and its helper binaries (yt-dlp, ffmpeg, ffprobe, deno, AtomicParsley) via a signed manifest. The architecture is a Tauri 2 application with a Rust backend and Vue 3 frontend. The Rust backend handles yt-dlp process management, output parsing (progress, errors, metadata), binary updates, configuration persistence, and concurrent download scheduling. The frontend uses Pinia stores for state management, Vue Router for navigation, and composables for reusable logic. Communication between frontend and backend occurs through Tauri IPC commands and events, with a well-defined command structure in Rust and corresponding listener plugins in TypeScript. Key entry points include src/main.ts (Vue app bootstrap), src-tauri/src/main.rs (Rust entry), src/router.ts (route definitions), and src/plugins/tauriListeners.ts (event listener registration). The primary data flow begins when a user adds a URL: the frontend sends an IPC command to the backend, which runs yt-dlp to fetch metadata, parses the JSON output into structured models, and returns the data to the frontend. The user then configures download options, and the backend spawns a yt-dlp download process, streaming progress events back to the frontend for real-time UI updates. External dependencies include yt-dlp, ffmpeg, ffprobe, deno, AtomicParsley, the SponsorBlock API, system keyring (via Tauri stronghold), and Sentry for error reporting.
VxeTable is a Vue 3 component library for building complex, enterprise-grade data tables and grids. It provides a comprehensive set of features including virtual scrolling for millions of rows, inline editing, Excel-style copy-paste, column resizing/dragging, filtering, sorting, pivot tables, tree/gannt views, and export/import/print. The library is architected as a set of Vue components (VxeTable, VxeGrid, VxeColumn, VxeToolbar, VxeColgroup) with an extensible plugin system based on hooks and renderers. It relies on a companion UI library (vxe-pc-ui) for modals, buttons, selects, and other controls, and uses xe-utils for utility functions. The codebase is large and well-organized, with separate modules for editing, filtering, keyboard navigation, validation, column customization, and export. Performance is a key focus, with virtual scrolling implemented for both X and Y axes. The library supports i18n with over 20 languages and includes a comprehensive theming system with light/dark modes. While primarily a UI component library, it also includes proxy-based server-side data operations in the VxeGrid component. The repository includes a demo application (examples/) for testing features, though the main artifact is the published npm package.
This is a full-stack cultivation world simulator game (xianxia RPG) with a Python backend (FastAPI + asyncio) and a Vue 3 + TypeScript + PixiJS frontend, supported by an optional Electron desktop shell for Epic Games Store distribution. The simulation engine runs a month-by-month tick system orchestrating ~29 phases (lifecycle, actions, social, war, world events, etc.) producing emergent narratives driven by LLM calls (OpenAI/Anthropic compatible) for character decisions, story generation, world lore rewriting, and roleplay interactions. The codebase is heavily data-driven with static game configurations (sects, techniques, items, regions) loaded from CSV files and multi-language localization via gettext PO files. It exposes a public REST API (query/command) and WebSocket for real-time state updates, supports save/load with JSON snapshots and SQLite event storage, and includes comprehensive test coverage (pytest, vitest, Playwright) and CI/CD workflows. While the architecture shows strong engineering patterns (effect system, action registry, single-choice decision framework, phased simulation pipeline), it carries risks from tight coupling of global singleton registries, LLM dependency, and use of `eval` in effect conditions.
Vexip UI is a large, TypeScript-first Vue 3 component library with over 78 high-quality components, built as a monorepo with multiple internal packages (`@vexip-ui/utils`, `@vexip-ui/hooks`, `@vexip-ui/config`, `@vexip-ui/icons`, `@vexip-ui/bem-helper`, etc.). It provides a consistent prop system via `useProps`, BEM-based theming, extensive composable hooks, custom directives, and a global configuration provider. The codebase is actively maintained, with comprehensive unit and SSR tests, bilingual documentation (VitePress), and a playground. It follows modern Vue 3 patterns (Composition API, JSX/TSX, TypeScript generics) and demonstrates strong engineering practices in component architecture, state injection, and performance (virtual scroll, lazy rendering, resize observers). While heavily coupled internally, many of its building blocks (e.g., BEM helper, PostCSS plugin, utility functions) are published as standalone packages and are reusable in other Vue projects.
SmartNode is a satellite relay simulation platform for space-based data backhaul, combining a Flask REST API backend with a Vue 3 frontend that visualizes satellite constellations on a Cesium 3D globe. It simulates LEO/MEO/GEO satellites, ground stations, and relay links, processing data transmission requests with configurable QoS, security, and value profiles. The backend implements orbital propagation (SGP4/TLE, Keplerian elements), ITU-R link budget models (rain attenuation, gaseous absorption, laser ISL), and scheduling strategies (GreedyMaxRate, QoS-aware admission control, handover with hysteresis). Results are persisted in SQLite and an append-only event log, with real-time updates pushed via SSE. The platform includes a full observability stack (Prometheus, Grafana, OpenTelemetry), containerized deployment, and extensive testing (unit, integration, property-based, golden regression, load). While primarily an application, it incorporates significant data/research components in orbital mechanics, communications, and scheduling algorithms, making it a hybrid but application-dominant project.
Nextcloud Social is a federated social networking application implemented as a Nextcloud app. It allows each Nextcloud user to become an ActivityPub actor (Person), enabling posting, following, liking, boosting, replying, and direct messaging across the Fediverse. The system is fully compatible with the Mastodon client API, supporting timelines, lists, filters, scheduled posts, polls, stories, collections, trends, and moderation features. The backend is written in PHP, structured with controllers, services, database request builders, and ActivityPub model classes. The frontend is built with Vue 3, Pinia, and Vue Router, providing a responsive single-page application for timelines, profiles, and settings. The app integrates deeply with Nextcloud's dashboard, notifications, search, user migration, and admin settings. Federation is handled via ActivityPub protocols with HTTP signature verification, outbound delivery queues, and WebFinger discovery. The codebase is well-tested with both PHPUnit and Vitest suites, covering unit, integration, and federation wire compatibility tests.
Sard Uniapp is a UI component library built on Uniapp + Vue 3 framework providing 117+ reusable components for cross-platform application development. The library follows a modular architecture where each component includes implementation, type definitions, styling, and unit tests. Key features include tree shaking support, TypeScript integration, theme customization, internationalization, dark mode support, and >80% unit test coverage. The library is designed for multi-end compatibility targeting H5, WeChat mini-program, Alipay mini-program, and native Apps (excluding nvue/uvue).
This repository is a full-stack, multi-tenant AI API gateway platform (named 'sub2api') that proxies requests to a wide range of AI model providers including OpenAI, Anthropic, Gemini, Grok, DeepSeek, and many others. It provides authentication (JWT, OAuth, API keys), rate limiting, token-level billing, subscription management, user and admin management, payment processing (Alipay, WeChat Pay, Stripe, Airwallex, EasyPay), content moderation, channel monitoring, and operational dashboards. The backend is written in Go using the Gin framework and Ent ORM, with PostgreSQL and Redis for data storage and caching. The frontend is built with Vue 3, TypeScript, and Pinia stores, offering both admin and user interfaces. The system is designed for production deployment with Docker, includes extensive unit and integration tests, and supports a plugin architecture for extensible OAuth transport. Despite its large codebase and many features, the architecture follows a clear service-repository pattern with well-isolated packages, making it a solid example of a complex API gateway implementation.
Buefy is a Vue 3 UI component library providing approximately 40+ Bulma-based components (buttons, inputs, tables, modals, datepickers, carousels, trees, etc.) that can be consumed individually or as a full bundle. It includes programmatic APIs for overlay components (dialog, toast, notification, snackbar, loading) and a global configuration system for icon packs, locale, and default behaviors. The library is published as the `buefy` npm package and is designed for tree-shaking via individual component registration. The architecture is a monorepo with two packages: `packages/buefy` (the library) and `packages/docs` (a Vite-based documentation site). Components are built using Vue 3 Options API with `defineComponent`, mixins for cross-cutting concerns (form validation, tabbed containers, notice behavior, compat fallthrough), and a consistent prop/event/slot pattern. SCSS styles are organized per component and leverage Bulma's CSS variable system for runtime theming. The library does not handle external data; it only manages UI state and provides a structured way to build Bulma-themed Vue 3 interfaces. Key entry points include `packages/buefy/src/index.ts` (main library export), `packages/buefy/src/utils/config.ts` (global configuration), and per-component index files that register each component as a Vue plugin. Data flows are limited to parent-child communication via provide/inject (e.g., Tabs, Steps, Table) and form element integration with a `BField` parent for validation. External dependencies include Vue 3 (>=3.4), Bulma CSS framework, and optional icon packs (Font Awesome, Material Design Icons). Build tooling uses Rollup, esbuild, Babel, and Vitest for testing.
AnonAddy (addy.io) is a self-hosted anonymous email forwarding service built with Laravel, Inertia.js, and Vue 3. In production, it allows users to create email aliases that forward to real inboxes, with support for custom domains, PGP/MIME encryption, user-defined rules (sender/subject/header conditions with actions like block, quarantine, label), and a blocklist. The system receives inbound email via a Postfix pipe, applies rules, and either forwards, replies, or sends-from aliases with rewritten headers, List-Unsubscribe banners, and optional DKIM signing. Outbound sending handles VERP bounce tracking and stores failed deliveries with deduplication. The architecture is a monolith Laravel application with a REST JSON API (used by mobile/extension clients) and a server-driven SPA frontend. Key entry points include the ReceiveEmail console command, the CustomMailer driver, and numerous API controllers under /api/v1/. The frontend uses reusable Vue components and Inertia form handling across pages for alias, recipient, domain, rule, blocklist, and settings management.
A browser-based tool for testing and configuring PlayStation DualSense, DualSense Edge, and DualShock 4 controllers via the WebHID API. It provides real-time visualization of all inputs (joysticks, buttons, triggers, gyroscope, accelerometer, touchpad), output control (lightbar, player LEDs, rumble, adaptive triggers, audio), and diagnostics (battery, telemetry, firmware info). For DualSense Edge, it offers profile editing including button remapping, joystick sensitivity curves, trigger deadzones, and vibration intensity. Built as a single-page application with Vue 3, TypeScript, and Pinia, it uses a custom device-based routing architecture that dynamically loads controller-specific views based on the HID device type. Communication with controllers is handled entirely in the browser through raw HID report parsing and construction, with audio streaming over USB (quadraphonic PCM) and Bluetooth (Opus via WebCodecs). The codebase is heavily modularized with composables for media playback, microphone capture, and state management. While primarily an application, the repository includes significant reverse-engineering work of the HID communication protocols for these controllers, making it a valuable reference for implementing controller support. The code is organized for extensibility, with a clean pattern for adding new controller types.
This is a monorepo providing a feature-rich sketch-ruler component library for Vue 3, targeting design tools, low-code platforms, and big-screen visualization. It includes a framework-agnostic core package (`@sketch-ruler/core`) with 2D transform engine, plugin system, snap engine, canvas manager, and minimap engine—all zero DOM dependencies. Separate packages handle canvas rendering (`@sketch-ruler/canvas`) with optimized label caching, offscreen caching, and input management (mouse, keyboard, wheel), and a selection engine (`@sketch-ruler/selecto`). The main Vue package (`vue3-sketch-ruler` / `@sketch-ruler/sketch-ruler`) provides Vue components (SketchRuler, Minimap, RulerLine) plus composables for canvas transform, ruler scale, and snap detection. The architecture is cleanly layered, well-tested with Vitest, and shipped via npm. The demo site showcases multiple use cases (editors, whiteboards, org charts, big-screen displays). The code demonstrates mature engineering with reusable patterns, though the large monorepo and external demo dependencies introduce some maintenance surface.
MiroFish is a full-stack web application that implements a swarm intelligence prediction engine. It ingests real-world documents (PDF, Markdown, TXT), extracts seed information via LLM-driven ontology generation, builds a knowledge graph using Zep Cloud, and then generates agent profiles and simulation configurations for the OASIS multi-agent simulation framework. The system runs dual-platform simulations (Twitter-like and Reddit-like) to model social evolution and produce predictive reports through a ReACT-based report agent that queries the knowledge graph and interviews simulated agents. The frontend is a Vue 3 SPA with a 5-step wizard guiding users through graph building, environment setup, simulation execution, report generation, and deep interaction with agents. The architecture follows a monolith-with-subprocesses pattern: a Flask backend serves REST APIs for graph management, simulation lifecycle, and report generation, while simulation subprocesses run independently and communicate via a file-based IPC protocol. The system relies heavily on external services: an OpenAI-compatible LLM API for generation tasks, Zep Cloud for persistent graph storage and retrieval, and the OASIS simulation engine. The codebase is well-structured with clear separation into API routes, service modules, utility functions, and frontend components. It includes comprehensive i18n support (7 locales), Docker deployment, and CI/CD via GitHub Actions. While primarily an application, MiroFish has strong data/research characteristics: its core value proposition is predictive simulation driven by LLM-generated ontologies and agent profiles, and it uses GraphRAG techniques for report generation. The repository includes standalone scripts for star history tracking and validation, but these are auxiliary to the main application. The code demonstrates good engineering practices with reusable utilities (LLM client with retry, Zep pagination, file parser, retry decorators) and a consistent pattern for asynchronous task management and polling.
This repository contains a desktop application for managing Nintendo Switch emulators, built with Tauri (Rust backend) and Vue 3 (frontend). It supports installing, updating, and configuring multiple emulators including Yuzu, Ryujinx, Eden, and Citron. The application provides features for firmware management, key installation, cheat code management, save backup/restore, and a self-update mechanism. The backend uses a layered architecture with commands, services, repositories, and models, while the frontend uses Vuetify 3 components and Pinia state management. The download subsystem is particularly notable, featuring a unified DownloadManager trait with two implementations: one using the native Rust bytehaul library and one using the aria2 external tool as fallback on Windows. The code also includes sophisticated network utilities with DNS-over-HTTPS resolver, GitHub API circuit breaker, mirror fallback chain, and adaptive parallelism. Configuration is persisted atomically with debounced saves, and progress is broadcast to the frontend via a typed event system. The codebase demonstrates good engineering practices with clear separation of concerns, error handling via typed AppError/AppResult, extensive test infrastructure (though many tests are marked ignored as they require network access), and platform-specific handling for Windows, macOS, and Linux. However, the UI is entirely in Chinese, and some external dependencies (CDN URLs, emulator project APIs) may require ongoing maintenance.
ACGTI (ACG Type Indicator) is a production-grade, open-source web application that delivers a personality quiz matching users to anime characters based on MBTI dimensions. The frontend is a Vue 3 SPA with TypeScript, Vite, and vue-router, featuring 39 Likert-scale questions, 8 archetypes, and over 100 curated characters with multilingual support (zh-CN, zh-TW, en, ja). The backend runs on Cloudflare Pages Functions with D1 database for anonymous statistics collection, AI-generated insights via Workers AI, and a cron worker for periodic stats snapshots. The codebase includes extensive offline analysis scripts (Python and Node.js) for weight calibration, probability simulation, and data validation, demonstrating a hybrid character with strong data engineering practices. The architecture is clean: frontend scoring engine is decoupled from backend, i18n is well-structured, and CI/CD pipelines enforce data integrity. While the project is actively maintained and uses modern tooling, some manual synchronization points (e.g., count constants, duplicate data sources) introduce minor fragility.