This repository is a monorepo for `react-router-devtools`, a Vite plugin that provides a comprehensive debugging and inspection UI for React Router v7+ applications. It integrates with TanStack DevTools to offer tabs for active page, routes, network waterfall, timeline, settings, errors, and custom plugins. The core mechanism uses Babel-based AST transformations to instrument server and client data functions (loaders, actions) with timing, tracing, and context wrappers without requiring user code changes. The package exports multiple entry points for client, server, and context integration, and supports both framework mode (Vite plugin) and declarative mode (EmbeddedDevTools component). The repository also includes a full documentation site built with React Router, example plugins (icon-library, tailwind-palette), and several test applications. It is a well-crafted developer tool with a modular architecture, but has some technical drift due to tight coupling to React Router internals and reliance on Babel AST transforms that may break with ecosystem changes.
This repository is an official Nx example showcasing a micro-frontend architecture with two frontends: an Angular application for product browsing and a React application for a shopping cart, backed by a .NET minimal API. The code demonstrates cross-framework component reuse via custom elements (Web Components), multi-framework state management (NgRx for Angular, useReducer/Context for React), and Nx's monorepo capabilities including code generation, dependency graph, and CI/CD integration. Data is entirely static, with the .NET API used only for OpenAPI codegen; there is no runtime API consumption. The architecture is clean and modular, emphasizing Nx best practices for large monorepos.
Nellavio is a production-grade, open-source Next.js dashboard starter designed for building modern SaaS products, internal tools, and admin panels. It provides 90+ reusable UI components, 60+ chart variations, authentication (Better Auth) with RBAC, i18n (next-intl), theme switching, and extensive data visualization pages (analytics, orders, customers, products, calendar, charts showcase). The architecture follows App Router with clear separation: server components for data fetching (Apollo Client GraphQL with mock fallback), client components for interactive views, Zustand for global state, and TanStack Table for data tables. The codebase is well-tested with Vitest, Storybook, and CI/CD (GitHub Actions). Despite some hardcoded demo data and recent migrations (Clerk→Better-Auth, Tremor→Recharts), the engineering practices are strong, making it a solid foundation for bootstrapping dashboard-centric applications.
This repository is an AI-powered stock research platform that combines a full-stack application (FastAPI backend, React/TypeScript frontend, Electron desktop app) with extensive data/research capabilities. It ingests market data from over a dozen providers (Tushare, yfinance, AkShare, etc.) with priority-based fallback chains, performs AI analysis via LiteLLM (supporting multiple LLM providers), and generates structured research reports, decision signals, and backtesting results. The platform supports multi-agent discussions, strategy screening, portfolio management, alerts, and multi-channel notifications (WeChat, Feishu, Telegram, email, etc.). It covers 13 international markets with trading calendars and market phase detection. The architecture is a monolith with modular services, using SQLite per-workspace isolation. While primarily an application, it has strong data/research characteristics including a screening engine derived from AlphaSift, decision signal lifecycle with outcome tracking, and skill opinion weight calibration. The codebase is well-structured with extensive tests, CI/CD, and reusable patterns like the data fetcher base class and notification sender template.
This is a full-stack todo application built with Next.js 15, React 19, and TypeScript. It features AI-powered natural language todo input, reminders via email, workspace collaboration, and a subscription model. The application uses a PostgreSQL database with Drizzle ORM for data storage, better-auth for authentication, and Resend for sending emails. The frontend is styled with Tailwind CSS and uses shadcn-ui components. Key architectural elements include API routes for todos, reminders, workspaces, and user settings, along with a cron job for processing reminders. The codebase demonstrates good engineering practices with reusable utilities for timezone handling, email sending, toast notifications, and a command palette.
PlumeLens (鉴翎) is a local bird photo analysis and culling workstation for bird photographers. It uses on-device ML models—YOLOv26l for detection, a custom 11-keypoint pose estimator, CLIPIQA+/HyperIQA for quality assessment, and DINOv3 with LoRA adapters for species classification—to process photos without any cloud upload. The system scans user photo directories (read-only), performs detection, pose estimation, quality scoring, and species identification, then presents a grading interface (reject/record/usable/select) with manual review and species override capabilities. Export supports JPG/RAW with XMP sidecars, and a geographic archive module visualizes species sightings on an interactive map with conservation status. The architecture is a desktop application split into an Electron+React frontend and a Python FastAPI backend. The backend runs as a subprocess managed by Electron, communicating via REST APIs and Server-Sent Events for progress. The ML pipeline is orchestrated in `engine/pipeline/manager.py` with ONNX Runtime and PyTorch inferences. The frontend uses React 19, TanStack Query, Zustand, and a virtualized grid for handling large photo sets. The application is packaged for macOS (arm64) via electron-builder and PyInstaller. While the primary delivery is a desktop application, the repository also contains extensive model training scripts, evaluation frameworks (`evals/`), and dataset preparation utilities, making it a hybrid project with significant research and data engineering components. Model integrity is enforced via SHA-256 manifest verification at startup, and all inference is deterministic with versioned pipeline hashes to invalidate caches on updates.
This repository provides a comprehensive AI-assisted UI/UX design system toolkit, primarily packaged as a skill for AI coding assistants (Claude Code, Cursor, Windsurf, Copilot, etc.) and distributed via the 'ui-ux-pro-max-cli' npm package. Its core functionality includes a curated knowledge base of 79 UI styles, 192 product color palettes, 74 font pairings, 119 UX guidelines, 22 tech stacks, and 192 reasoning rules – all stored as structured CSV files. A BM25 search engine (implemented in Python) enables domain‑aware retrieval, while a design system generator aggregates search results and applies reasoning rules to output complete design system recommendations (colors, typography, style, layout patterns, motion, anti‑patterns). The gallery Next.js app provides a browsable, filterable interface for the style catalog. Architecturally, the project is a hybrid of data curation and application delivery. The canonical source of truth lives in `src/ui-ux-pro-max/`, which is synchronised to `cli/assets/` and `.claude/skills/` via a CI‑enforced sync script. It includes sub‑skills for brand management, slide/presentation generation, banner design, icon/logo generation, and UI styling (with shadcn/ui and Tailwind integration). The CLI tool installs these skills into the appropriate AI assistant configuration directories, with platform‑specific templates for 20+ assistants. Automated workflows refresh Google Fonts and Phosphor icon catalogs weekly, and a suite of Python tests validates data contracts, stack freshness, and search relevance. Despite its active maintenance and rich functionality, the codebase suffers from significant file duplication across three directory trees, hardcoded version pins for frameworks, and test brittleness tied to exact data row counts. The design system generator and search engine are well‑crafted and reusable, but the overall project is tightly coupled to its curated CSV schema and the ecosystem of AI coding assistants. It represents a mature, production‑grade toolkit for developers who want AI‑assisted design generation, but the heavy duplication and external API dependencies (Gemini, Atlas Cloud, MuAPI) introduce moderate technical drift risk.
Carbon is a Next.js web application for creating and sharing beautiful images of source code. It provides a CodeMirror-based editor with extensive customization: syntax themes (30+ built-in), fonts (13 options), background colors/images (including Unsplash integration), window themes, padding, shadows, and line numbers. Users can import code via paste, file drop, or GitHub Gist URLs. Export options include PNG/SVG at multiple resolutions, clipboard copy, Twitter sharing, Imgur upload, and embed codes. Saved snippets persist via Firebase authentication with automatic Twitter/Slack unfurling. The app runs as a PWA for offline use. Architecture is a Next.js 12 monolith with API routes for oEmbed and server-side image generation (Puppeteer/Chrome AWS Lambda). State is managed through URL parameters (with base64-encoded complex state), localStorage, and React state. The codebase demonstrates solid engineering with custom CodeMirror modes for 6 languages, a sophisticated theme builder, and well-encapsulated UI components.
Chat2DB is an AI-powered database client and SQL workspace supporting over 40 databases via a plugin architecture. It provides a full-featured SQL editor with syntax highlighting, autocompletion, and execution, along with database metadata browsing, data import/export, BI dashboards, and an AI assistant that can generate SQL, explain queries, and create charts. The system is designed as a hybrid desktop/web application, with a React/TypeScript frontend (using Ant Design, Monaco Editor, Zustand for state management) and a Java Spring Boot backend with a layered domain model. The desktop version uses JCEF (Chromium Embedded Framework) for native integration, while the web version runs as a standalone server. Database support is modular via SPI plugins, each providing metadata, SQL builders, value processors, and completion logic. The architecture is centered around a plugin system where each database type implements interfaces like IPlugin, IDbMetaData, and IDbManager, enabling extensible multi-database support. The frontend uses Zustand stores with slice-based state management, and the backend provides REST APIs for SQL execution, AI chat, and data management. Key entry points include the frontend main page (CommunityMainPage), backend controllers (e.g., DbSqlController, AiChatController), and plugin registration via META-INF/services. Data flows involve SQL execution requests from the editor to the backend, which delegates to the appropriate database plugin and returns results asynchronously with streaming support for AI and large result sets. External dependencies include Java/Spring Boot, React, Monaco Editor, ANTLR for SQL parsing, ECharts for charts, and various JDBC drivers for database connectivity. The system also integrates with AI model APIs (e.g., OpenAI, Claude) via configurable endpoints. The codebase demonstrates a strong separation of concerns through its SPI plugin pattern and state management slices, though it exhibits some duplication across database plugins and has limited test coverage.
BetterDiscord is a client modification for Discord that injects into the Electron app to provide a plugin and theme system, custom CSS editor, addon store, updater, and developer tools. The architecture is a monolith within the Discord client, structured as three packages: injector (main process), preload, and renderer. Key entry points include the main process (`src/electron/main/index.ts`), preload script (`src/electron/preload/index.ts`), and renderer initialization (`src/betterdiscord/index.ts`). Data flows involve IPC between main and renderer, webpack module interception for patching Discord's React components, file system access for addons and settings, and GitHub API for updates. External dependencies include Electron, React, Monaco Editor, lucide-react, and react-spring. The codebase is well-structured with TypeScript, has tests, and exposes a comprehensive API (`BdApi`) for plugin developers. However, it heavily relies on Discord's internal webpack modules and hardcoded module IDs, making it brittle and requiring frequent updates as Discord changes. The project is actively maintained with recent commits and responsive issue triage.
FlowGram is a comprehensive, production-grade visual workflow development framework from ByteDance. The codebase implements two distinct editing paradigms — fixed-layout (automatic positioning with composite nodes like loops, branches) and free-layout (node-position-free with lines) — both built on a shared plugin architecture using inversify for dependency injection. The framework includes a form engine with reactive fields, validation, and effects; a variable engine with AST-based type inference and scoped lifecycle; and a runtime engine capable of executing workflows with executors for LLM, HTTP, code (QuickJS sandbox), and conditions. The repository contains over 40 packages managed via Rush monorepo, encompassing core libraries, plugins (history, minimap, auto-layout, group, snap, clipboard, export), UI material libraries (Semi UI, Ant Design), a CLI tool for scaffolding, multiple demo applications, and comprehensive documentation. The system is actively maintained with regular commits, CI workflows, and E2E tests. Notable technical decisions include a local fork of the use-gesture library for canvas interaction, heavy decorator-based IoC, and support for both React 17 and 18. While the architecture is well-structured and extensible, the codebase shows signs of duplication between fixed and free layouts, numerous demo-specific components, and some deprecated APIs that indicate ongoing refactoring.
Jellyfish is an open-source, full-stack AI short drama studio application. It provides an end-to-end production pipeline for generating vertical short dramas from scripts: script parsing (division, element extraction, consistency checking), storyboard generation (shot breakdown, asset linking, camera language), image/video generation via multiple AI providers (OpenAI, Volcengine), and async task orchestration with Celery. The backend is built with FastAPI, SQLAlchemy 2.0 async, and Redis; the frontend uses React 18, TypeScript, Ant Design, and Vite. The application is production-oriented with Docker Compose deployment, GitHub Actions CI, and automated OpenAPI client generation. It emphasizes visual consistency through global seed, style inheritance, and asset reuse. While primarily an application, it includes a significant amount of AI/LLM agent code for script analysis, giving it a hybrid character with research-oriented structured extraction pipelines.
This repository is a React component library, react-mosaic-component, that implements a tiling window manager (nested resizable/draggable panels) as a controlled or uncontrolled React component. It allows users to arrange panels in an n-ary tree of splits, tabs, and leaf nodes, with full drag-and-drop reordering, resizing, tab management, and theming support. The codebase is a well-structured Nx monorepo with a Docusaurus documentation site, a live demo, CI/CD pipelines, and extensive unit tests. While functionally complete and battle-tested, the code reveals some technical debt: a mix of class components and hooks, occasional `any` type usage, a reliance on `immutability-helper` for all tree mutations, and an active legacy binary-tree migration path that adds maintenance surface. The architecture is sound for its domain, and the immutable tree update factories and drag-and-drop state machine demonstrate non-trivial engineering.
Mythic is a cross-platform, post-exploitation, red teaming command-and-control (C2) framework. It enables operators to manage remote agents (callbacks), generate payloads, issue tasks, exfiltrate files, harvest credentials, and automate workflows through an event-driven system. The architecture is a multi-container Docker deployment: a Go backend (using Gin, RabbitMQ, PostgreSQL, gRPC) handles agent communication, task orchestration, and data persistence; a React frontend (Material-UI, Apollo Client) provides a rich operator interface with real-time updates via GraphQL subscriptions (backed by Hasura); and a CLI tool (Mythic_CLI) manages container lifecycle, configuration, and service installation. Key entry points include the agent message webhook (HTTP POST/GET), web controllers for CRUD operations, and RabbitMQ RPC handlers for internal service communication. External dependencies include RabbitMQ, PostgreSQL, Hasura GraphQL engine, Docker, and gRPC. The system is designed for extensibility through payload type containers, C2 profiles, translation containers, and custom browser scripts.
Taro UI is a multi-platform UI component library designed for the Taro framework, enabling developers to build applications that run on WeChat Mini Program, H5, React Native, Alipay, and other platforms with a single codebase. The library provides over 40 reusable UI components (including form controls, layout elements, navigation tools, and feedback mechanisms) with consistent APIs across platforms. Architecture follows a monorepo structure with core components in packages/taro-ui/src, platform-specific adaptations in packages/taro-ui/rn, documentation built with VitePress, and multiple demo applications showcasing usage. The library relies on Taro as a peer dependency and utilizes utilities like classnames and dayjs for cross-platform compatibility. Recent active maintenance has included migration to Function Components + Hooks, build system upgrades to tsup, TypeScript 5.3 adoption, and CSS precompilation efforts to address prior technical debt.
This is a large, mature React UI component library (Fusion Design / @alifd/next) by Alibaba, providing 50+ enterprise-grade components for building complex web applications. It includes form elements, data display (Table, Tree, Calendar), navigation (Menu, Nav, Tab), overlays (Dialog, Drawer, Balloon), and utilities (Upload, Rating, Slider). The architecture follows a consistent pattern: each component is wrapped with ConfigProvider for theming, locale, and prop deprecation handling, and sub-components are attached via assignSubComponent. The library includes extensive documentation demos, accessibility tests, and internationalization for 12+ languages. While the codebase shows signs of technical debt (dual v1/v2 components, coexistence of Moment and Day.js, mix of class and functional components, deprecated lifecycle polyfills), it remains well-maintained with active issue triage and incremental TypeScript migration. The library's core value is its comprehensive, configurable component set and the design system integration with Fusion Design.
KokonutUI is an open-source UI component library for modern React applications, specifically targeting Next.js projects with Tailwind CSS v4 and Motion (Framer Motion). The repository contains over 40 reusable, animated components distributed through a shadcn-style registry, allowing developers to copy-paste or install them via `npx shadcn@latest add @kokonutui/<name>`. The library covers backgrounds (beams, flow field, shape hero), buttons (attract, gradient, hold, particle, slide-text, social, switch, v0), cards (apple activity, bento grid, card flip, card stack, carousel, currency transfer, liquid glass, mouse effect, spotlight, tweet), inputs (avatar picker, file upload, loader, team selector), navigation (action search bar, morphic navbar, profile dropdown, smooth drawer, smooth tab, toolbar), AI-specific components (AI input search, AI loading, AI prompt, AI text loading, AI voice), and text effects (dynamic, glitch, matrix, scroll, shimmer, sliced, swoosh, type writer). The project also includes custom hooks (use-auto-resize-textarea, use-click-outside, use-copy-to-clipboard, use-debounce, use-file-input, use-intersection, use-mobile, use-tags) and a comprehensive documentation site powered by Fumadocs with MDX content. A build script generates registry JSON files and agent-facing resources (llms.txt, agent skills index). The codebase follows modern React patterns (compound components, asChild, controlled/uncontrolled state, composition over props) and includes extensive AI agent skills for component architecture, Next.js best practices, and React design patterns. While the library is functional and well-structured, it lacks tests and has a large dependency surface; it is also tightly coupled to Next.js and serves as a marketing funnel for a pro version.
EldoraUI is a modern, open-source React/Next.js component library distributed via a shadcn/ui-style registry. It provides over 40 animated UI components, including text animations, device mockups, 3D globes, interactive cards, and full-page blocks (headers, CTAs, pricing tables, testimonials). The repository is a monorepo with a Next.js documentation site that showcases each component with live previews, code examples, and MDX-based guides. Components are designed for copy-paste installation via CLI (`npx shadcn add`) and rely on Tailwind CSS, Motion (Framer Motion), Three.js, and Radix UI primitives. The library targets 'design engineers' building modern, animated interfaces. While the codebase is actively maintained and demonstrates strong craftsmanship in several complex components (e.g., Browser, CobeGlobe, TextAnimate), it exhibits some technical drift: pervasive typos in block names ('testimonal'), fragile DOM coupling in the table of contents, outdated TODO comments, and potential registry duplication. Overall, it is a solid, production-quality component library with high reusability.
mdx-bundler is a JavaScript/TypeScript library that compiles and bundles MDX (Markdown + JSX) content into a single evaluable JavaScript string. It uses esbuild for fast bundling and MDX v3 for compilation. The library allows users to provide MDX source code along with any dependency files (local, remote, or in-memory) and returns a bundled code string, parsed frontmatter, and errors. The bundled code can then be rendered in the browser using a client-side helper (`getMDXComponent`) that supports multiple JSX runtimes (React, Preact, Vue, Hono, etc.). It supports custom remark/rehype plugins, image bundling, global externals for dependency sharing, and flexible esbuild configuration. The architecture is centered around a single async function `bundleMDX` that orchestrates gray-matter parsing, esbuild with an in-memory file plugin, and MDX compilation. The client-side functions are minimal wrappers around `new Function` evaluation. The repository includes comprehensive tests for React, Preact, Vue, and Hono runtimes, and follows semantic release practices.
graphql-hooks is a lightweight React GraphQL client library that provides a set of hooks for querying, mutating, and subscribing to GraphQL endpoints. It is designed as a minimal yet feature-rich alternative to Apollo Client, with a focus on small bundle size (22.9 kB gzipped). The library is organized as a Lerna monorepo containing the core package (`graphql-hooks`), an in-memory cache (`graphql-hooks-memcache`), SSR utilities (`graphql-hooks-ssr`), and a Babel plugin for compile-time GraphQL query extraction (`babel-plugin-extract-gql`). In production, the system operates as a client-side GraphQL executor within React applications. The primary entry points are React hooks: `useQuery`, `useMutation`, `useManualQuery`, and `useSubscription`. These hooks internally use `GraphQLClient` to send HTTP or WebSocket requests, passing through an optional middleware pipeline. The client supports caching via a pluggable interface (defaulting to `graphql-hooks-memcache` with LRU eviction and TTL), automatic refetching after mutations, file uploads via the GraphQL multipart spec, and server-side rendering by pre-fetching query results and injecting initial state into the HTML. Key data flows begin when a React component calls a hook. The hook interacts with `GraphQLClient`, which applies middleware (e.g., Automatic Persisted Queries or custom interceptors) before sending the request. Responses are cached and returned to the component. Mutations can optionally trigger refetches of related queries via an event emitter. The architecture promotes separation of concerns via middleware, a clean cache API, and support for multiple transport layers (HTTP, WebSocket, Full-WS). External dependencies include React (peer), `graphql-ws` or `subscriptions-transport-ws` for subscriptions, and `formdata-node` for file uploads in Node environments.