This repository is a SharePoint Framework (SPFx) web part and companion pattern library that delivers Microsoft 365 Learning Pathways — a customizable training portal for Office 365. The application fetches structured JSON playlists and asset metadata from a public CDN (pnp.github.io), caches it client-side, and renders it through React components. Users can customize playlists and assets, with changes persisted to SharePoint lists via a custom data service. An UpgradeService migrates cached configuration and playlist data between major versions using version-specific migration functions (e.g., uCacheConfigV2V3, uPlaylistsV3V4). The repo also contains a style guide with atomic design (atoms/molecules/organisms/pages) and a dependency graph for template impact analysis. Although the dominant character is application, the repository is hybrid: it also stores a large static dataset of official Microsoft training content (playlists, assets, locale files) and a design-system data layer, so it is as much a content portal as a codebase. Maintenance is active but shows technical debt: duplicated locale lists, content drift between en-us and zh-cn asset files, disabled ESLint rules, and fragile cheerio-based CI scraping scripts.
Entropic is a local-first desktop AI workspace built with Tauri and React. It provides a full desktop environment including chat with an AI agent, file management (Finder), web browsing, office document editing (OnlyOffice integration), voice control, task board with cron jobs, and an integration marketplace (OAuth for Google, Outlook, Slack, etc.). The application runs a sandboxed runtime (OpenClaw) inside Docker/Colima on macOS/Linux or WSL2 on Windows, ensuring secure execution of agent actions. Communication with the agent gateway happens via WebSocket with structured RPC frames. The system supports two modes: local API keys (user provides LLM keys) and managed proxy mode with hosted authentication and billing via Supabase/Stripe. The architecture is a monolith with separate microservices for browser automation (Playwright) and skill scanning (Cisco AI Defense). The frontend uses React 18, TypeScript, Vite 5, and Tailwind CSS 4, while the backend is Rust with Tauri v2 plugins for deep-link, updater, store, stronghold, and shell access. The codebase demonstrates strong engineering practices with reusable hooks for audio recording/transcription, a custom markdown renderer with workspace link support, and a resilient WebSocket client. However, some components are monolithic (Chat.tsx ~4000 lines, Files.tsx ~3000 lines) and there are hardcoded model lists and pricing that may drift over time.
This repository implements a serverless document chat application that allows users to upload PDF documents and ask natural language questions. The backend is composed of AWS Lambda functions orchestrated by Amazon API Gateway, S3, SQS, and DynamoDB. PDF processing uses LangChain with FAISS for vector embeddings and Amazon Bedrock (Claude Sonnet) for LLM inference. The frontend is a React SPA with TypeScript, TailwindCSS, and AWS Amplify authentication. Architecture follows an event-driven serverless pattern: upload triggers S3 event → Lambda extracts PDF metadata, stores in DynamoDB, sends SQS message → another Lambda generates embeddings and stores FAISS index in S3. Chat requests invoke a Lambda that loads the FAISS index, retrieves relevant context, and uses a ConversationalRetrievalChain with DynamoDB-backed memory. The code is clean and follows AWS best practices with Powertools logging, but lacks tests and hardcodes the Bedrock region to us-east-1. It is a solid reference implementation for building a RAG-based Q&A system on AWS.
WeWe RSS is a monolithic NestJS application that provides RSS feed generation for WeChat public accounts (微信公众号). It acts as a middleware between the WeRead (微信读书) platform and standard RSS readers. The system allows users to add WeChat public accounts via article links, fetches account metadata and article lists through the WeRead platform API, stores them in a MySQL or SQLite database, and exposes RSS/Atom/JSON feeds. It includes a cron-based scheduler for periodic feed updates, an admin dashboard built with React and NextUI, and supports features like full-text extraction, title filtering, and OPML export. The architecture is typical for a NestJS application: controllers handle HTTP requests, tRPC provides a type-safe API layer for the frontend, Prisma ORM manages database interactions, and the frontend is a separate Vite/React app. The codebase is straightforward and functional, with no standout reusable components that could be easily extracted without modification.
FastUI is a Python/TypeScript framework for building web UIs declaratively from Python code, using React as the frontend renderer. The backend defines the entire UI as a list of Pydantic-validated component models, which are sent to the frontend via a REST API. The frontend (React) receives these component definitions and renders them using Bootstrap or custom components. The architecture enforces a strict separation of concerns: the backend describes the interface, the frontend implements the rendering. The project includes a Python package (fastui) with component models, form generation, authentication helpers, and a dev server; three npm packages (@pydantic/fastui, @pydantic/fastui-bootstrap, @pydantic/fastui-prebuilt) for the React frontend; and a demo application. The code is well-structured, fully typed, and includes comprehensive tests. However, the project has been officially declared inactive (see issue #368), so no further development is expected. The codebase remains functional and is a good example of declarative UI patterns, but reuse should account for the lack of ongoing maintenance.
Dejavu is a single-page web application that provides a modern UI for browsing, searching, and managing data in Elasticsearch and OpenSearch clusters. It is built with React 18, Redux, Redux-Saga, and Ant Design, and leverages the ReactiveSearch library for search UI components. The application runs entirely client-side, communicating directly with the Elasticsearch REST API. It supports CRUD operations, data import/export (JSON/CSV), field mapping management, term-based filtering, global search, and a search preview builder. The codebase is organized as a monorepo with two packages: a reusable browser component library (`@appbaseio/dejavu-browser`) and the main application (`dejavu-main`). The architecture follows a standard Redux pattern with sagas for side effects, and uses react-virtualized for high-performance data grids. While the code is well-structured and feature-rich, it relies on several outdated dependencies (Redux 3.x, redux-saga 0.16, react-router-dom 4.x, emotion 9.x) and uses Flow type annotations, which are now deprecated. The project appears to be in a stale maintenance state with no recent commits.
PrimeReact is a comprehensive React UI component library providing over 80 components including forms, data tables, overlays, menus, charts, and more. The repository also contains its official documentation website built with Next.js, featuring live demos, code snippets, accessibility guides, and theming documentation for both styled and unstyled (Tailwind) modes. The library follows a consistent architecture: each component extends a shared ComponentBase that defines default props, CSS classes, and pass-through theming support. It includes a custom hooks library, SVG icon set, and utility modules. However, the project is no longer under active development; only security fixes are published, with all new features and bug fixes moving to the PrimeUI fork. This has led to a growing divergence and a backlog of unresolved issues. The codebase shows signs of technical drift such as aging dependencies (Next.js 12), deprecated patterns, and extensive duplication in documentation and style definitions.
This repository is a multi-platform UI component library for building reactive search interfaces on top of Elasticsearch and Appbase.io. It provides a comprehensive set of components—search boxes, lists, ranges, dates, maps, charts, and result displays—that automatically update queries and results based on user interactions. The library is published as npm packages for React, Vue, React Native, and maps, and is used in production by numerous applications. Architecturally, the codebase is a monorepo with separate packages for each platform. Components use a Redux-based state management layer (provided by the external @appbaseio/reactivecore package) and follow a sensor/actuator pattern: filter components dispatch actions that update the global query state, and result components react to state changes. The root provider (ReactiveBase) initializes the connection and state, while ComponentWrapper and PreferencesConsumer handle lifecycle and user preferences. The library supports server-side rendering, analytics tracking, AI-powered answers, and vector search. Key entry points are the package index files (e.g., packages/web/src/index.js) that export all components. External dependencies include @appbaseio/reactivecore for state management, appbase-js for backend communication, emotion for CSS-in-JS, and Downshift for autocomplete. While the library is functional and widely adopted, the codebase exhibits significant duplication across platform packages, large monolithic component files (e.g., SearchBox.js ~2000 lines), snapshot-only tests, and some deprecated patterns (eval in chart rendering, hoistNonReactStatics). These factors contribute to a moderate quality score.
This repository is a monorepo providing a React component library for swipeable views (carousels/ tabs) with touch and mouse support. It is split into multiple packages: `react-swipeable-views` (browser implementation), `react-swipeable-views-core` (shared utilities), `react-swipeable-views-utils` (higher-order components for auto-play, virtualize, and keyboard binding), and `react-swipeable-views-native` (experimental React Native support). The main component (`SwipeableViews`) uses CSS transitions and transforms to animate slides, with lazy loading and resistance effects. The HOCs provide composable enhancements: `autoPlay` adds timed auto-advance with visibility change handling, `virtualize` renders only a window of slides for large lists, and `bindKeyboard` enables arrow key navigation. The library is well-tested with mocha, chai, and sinon, and has a comprehensive documentation site built with Next.js. However, the codebase is dated (class components, outdated Babel and Next.js versions, no hooks) and maintenance appears stagnant, with many open issues and infrequent updates. The core utility functions are clean, reusable, and demonstrate good software engineering practices.
This repository implements a full-stack content operations platform exclusively for Xiaohongshu (XHS), the Chinese social media platform. It provides a complete lifecycle for managing XHS notes: discovering content via search or URL crawling, saving to a local library, AI-assisted rewriting and title/tag generation, scheduling and publishing through XHS's Creator API, and monitoring engagement metrics. The system is built as a modern web application with a FastAPI backend (Python) and a React frontend (TypeScript, Ant Design), using SQLAlchemy for persistence and APScheduler for background job execution. The architecture is a monolith with clear separation of concerns: backend API routers for accounts, notes, drafts, AI, tasks, publishing, monitoring, and analytics; a service layer for business logic; and a set of adapters that encapsulate the reverse-engineered XHS API clients. The frontend provides a dashboard, discovery page, content library, draft editor, publish center, auto-ops scheduler, and analytics views. Authentication uses JWT tokens with refresh logic, and the system supports multiple XHS account types (PC web and Creator) via QR code or phone login. A notable aspect is the extensive reverse-engineering of XHS's anti-bot mechanisms. The codebase includes custom JavaScript modules for generating signatures (b1, MNS, X-S, X-T, websectiga, profileData) and browser fingerprint emulation, all executed locally via Node.js subprocesses. This allows the platform to interact with XHS APIs without a real browser, enabling automated content operations at scale. While the primary focus is on XHS, the platform abstraction layer (PlatformId enum, adapter interfaces) suggests an intention to support other social media platforms, though only XHS is currently implemented. The repository is a hybrid of application and data engineering: it is primarily a production-grade web application with scheduled tasks, user management, and a rich UI, but it also contains data pipeline elements such as crawling, normalization, and storage of XHS content for later analysis. The data models and analytics endpoints provide research-like capabilities (keyword tracking, engagement trends, benchmarks), but these are embedded within the application rather than forming a standalone data research project.
BigBlueButton is an open-source web conferencing system designed for online learning. It provides real-time audio/video, screen sharing, whiteboard, chat, polling, breakout rooms, and recording/playback. The architecture is distributed and polyglot: a Scala/Akka backend handles meeting logic and state via Redis pub/sub; a Java API layer exposes REST endpoints for meeting creation and recording management; a React frontend with GraphQL subscriptions enables real-time collaboration; Ruby workers process recordings; and a Go GraphQL middleware optimizes subscription delivery. The system integrates with FreeSWITCH for legacy voice and LiveKit for modern WebRTC audio. A plugin SDK allows third-party extensions via customizable UI areas and data consumption hooks. Despite a large feature set and active development, the codebase suffers from significant technical debt due to its multi-language nature, incomplete migrations (e.g., from Meteor to pure React), duplicated logic across frontend and backend, and outdated library versions. Reusable components include the Redis pub/sub framework, GraphQL subscription deduplication hooks, and an annotation export service.
This is a React admin dashboard template built with CoreUI, React 19, Vite, Redux, and Chart.js. It provides a comprehensive set of example pages demonstrating CoreUI components, form controls, charts, widgets, authentication flows, and icons. The codebase is well-structured with lazy-loaded routes, a simple Redux store for theme and sidebar state, and reusable layout components (AppSidebar, AppHeader, AppContent). It serves as a starting point for building admin panels rather than a production application. The template includes extensive documentation (ARCHITECTURE.md, DEVELOPMENT.md) and uses JSDoc comments. It is tightly coupled to the CoreUI ecosystem and contains no real backend integration or data fetching logic. The repository is primarily a showcase and scaffold for developers.
PearPass Desktop is an Electron/React password manager with a local-first architecture: encrypted vaults are stored on-device and synchronized peer-to-peer through Pear Runtime, with no central cloud account. The renderer is a large React application handling vault/record CRUD (logins, credit cards, identities, notes, Wi-Fi, passphrases, custom fields), folders, favorites, TOTP authenticator codes, import/export from other password managers, and extensive settings. The Electron main process spawns a Bare-sidecar vault worklet, exposes a preload bridge, and coordinates secure native messaging with a browser extension. The repo also includes Flatpak/Snap/AppImage/MSIX packaging, an Appling installer, and a Playwright E2E suite. Security is taken seriously: there is an encrypted session handshake (X25519 ECDH, Ed25519 transcript signatures, secretbox, sequence numbers), a method registry separating public vs secure IPC methods, master-password verification, auto-lock, and platform-specific clipboard cleanup. The codebase has extensive Jest unit coverage and Playwright E2E coverage for every record type. However, much of the actual vault crypto and UI kit logic lives in internal @tetherto packages, making this repository primarily application glue around private dependencies. Maintainability is mixed. The README explicitly states development is paused, and there are signs of drift: mixed JS/TS, duplicated attachment/schema logic across many modal forms, a frozen legacy UI component tree, commented-out E2E tests, a likely bug in pairing-token hash construction, and feature stubs marked UNSUPPORTED. It remains a well-organized and functional password manager, but a significant refactor would be needed to fully modernize it.
Gitlantis is a VS Code extension that turns the traditional file explorer into an interactive 3D ocean world. Users control a boat to navigate a seascape where directories appear as lighthouses and files as buoys, making code exploration more engaging. The extension communicates via webview with a React Three Fiber interface, offering features like branch switching, file opening, and settings customization. It also supports a standalone browser mode for demo purposes using sample data. Architecturally, the extension consists of a VS Code extension host that handles workspace and Git operations, and a rich webview application built with React 18, Three.js, React Three Fiber/Drei, and Zustand for state management. The 3D scene includes dynamic ocean tiling, boat physics (using React Three Cannon), collision-based node interaction, a compass, minimap, and ambient audio. The UI layer provides splash screens, loading states, settings modals with multiple tabs, and mobile joystick support. The codebase demonstrates modern frontend practices and creative use of 3D in a developer tool. However, it has several maintainability concerns: many @ts-expect-error comments for Three.js types, hardcoded demo data for browser mode, a complex dual-build setup, and no automated tests. Some components, like the settings modal and the dynamic backdrop, are well-abstracted and potentially reusable in other Three.js projects.
echarts-for-react is a React component library that provides a declarative wrapper around Apache ECharts, a popular JavaScript charting library. The core component manages the full lifecycle of an ECharts instance: initialization, option updates, event binding, theme switching, resize handling, and loading states. It exposes a `getEchartsInstance()` method for direct access to the underlying ECharts object. The library supports both Canvas and SVG renderers, custom themes, and locale configuration. It includes a `core` export for tree-shaking with ECharts modules, allowing bundle size optimization. The codebase is primarily TypeScript, uses class components (PureComponent), and depends on `size-sensor` for automatic resize detection and `fast-deep-equal` for prop comparison. It is a typical React wrapper library—well-structured for its purpose but not architecturally innovative. The project is actively maintained with recent commits and a responsive issue tracker.
This is a production-ready, multi-tenant SaaS starter kit built with Next.js (Pages Router), NextAuth.js, Prisma ORM (PostgreSQL), and Tailwind CSS. The system provides comprehensive enterprise features: email/password authentication, magic link, OAuth (Google, GitHub), SAML/SSO via BoxyHQ Jackson, directory sync (SCIM), webhooks via Svix, audit logging via Retraced, Stripe billing, API keys, and team-based role management (RBAC). The architecture follows a monolith with API routes under /pages/api, middleware for session validation, and a component-based frontend. Data flows center around team creation and management: users register (or SSO), create or join teams via invitations, then configure team-level SSO, directory sync, webhooks, billing, and API keys. The codebase demonstrates solid engineering practices with Zod validation, reusable UI components, and a clear separation of concerns, but shows signs of feature creep and some legacy patterns (e.g., Pages Router). It is well-suited for developers building a SaaS platform who need a jump-start on authentication, team management, and enterprise integrations.
Make.md is an Obsidian plugin (manifest id `make-md`) that turns a plain vault into a structured knowledge workspace. In production it registers custom leaf views (Spaces, Navigator, Blink), patches Obsidian's workspace and CodeMirror editor, and maintains a metadata layer called `Superstate` indexed by web workers. It ships a React-based frame layout engine where notes/spaces are rendered as configurable frame trees with style/action expressions evaluated at runtime, an MDB layer that reads and writes SQLite `.mdb` files via sql.js, and a predicate/filter/aggregate system powering table, calendar, list, and chart views. The plugin also includes a custom mathjs-based formula language, an HTML export pipeline, and a D3-driven visualization pipeline.
This is a monorepo (Yarn Berry workspaces) serving as a comprehensive educational resource for frontend fundamentals, maintained by the Korean fintech company Viva Republica (Toss). It comprises multiple VitePress documentation sites covering code quality, accessibility, debugging, and bundling, along with a real React application ('today-i-learned') that demonstrates the principles by using GitHub Discussions as a backend for a community TIL blog. The repository also includes a Claude Code plugin (frontend-fundamentals-plugin) that evaluates code against these principles using automated grading tasks. The architecture is documentation-centric with a shared navigation component, multi-language support (Korean, English, Japanese, Chinese), and Vercel serverless functions for GitHub OAuth and GraphQL API proxying. The TIL app is a production-grade React SPA (Vite, React Query, Panda CSS, Radix UI) that features post creation, comments, reactions, streaks, and weekly challenges. While the code is well-structured and the educational content is high-quality, much of the code is tightly coupled to the documentation context or the TIL app's specific domain, limiting broad reuse. The repository is actively maintained with recent commits and responsive issue management.
This repository is a monorepo containing the `@react-google-maps/api` library, which provides React components and hooks for the Google Maps JavaScript API (v3.x). It includes sub-packages for InfoBox and MarkerClusterer overlays. The library is the primary product, offering declarative React wrappers for map features like markers, info windows, polygons, directions, street view, and more. The codebase also includes a full-stack web application (`web-app`) built with React Router v7, Hono, and Cloudflare Workers, serving as the library's documentation site, license sales platform, and user dashboard. The web-app features authentication, Stripe payment integration, multi-language support (9 locales), and a comprehensive interactive documentation page with code examples. The library itself follows a consistent functional component pattern with hooks for lifecycle management, but suffers from some code duplication and verbose event listener handling. The commercial license change in v3.0.0 may impact community adoption. Overall, the repository is actively maintained and functional, but not exceptionally polished.
This repository is a front-end todo list application built with Next.js and React, demonstrating clean (hexagonal) architecture principles. The codebase is organized into domain, application, and infrastructure layers, promoting separation of concerns and testability. The domain layer contains pure use cases and interfaces, making it highly reusable. The infrastructure layer provides implementations for localStorage and in-memory storage. The application layer uses React components to interact with the domain via use cases. Despite the strong architectural foundation, the project suffers from significant technical drift due to outdated dependencies (Next.js 11, React 17, TypeScript 4.4, etc.), indicating a lack of recent maintenance.