This repository implements the Salesforce Lightning Design System (SLDS) as a reusable React component library. It provides over 60 accessible UI components including buttons, modals, tooltips, data tables, and layout elements that follow SLDS guidelines. The library emphasizes accessibility with quarterly audits, includes comprehensive documentation via Storybook, and provides utilities for common React patterns like ARIA prop handling and DOM portal management. Components are designed to be composable and customizable while maintaining visual and behavioral consistency with the Salesforce design system.
This repository is a comprehensive collection of React interview questions and coding exercises, designed as an educational resource for developers preparing for React interviews. It contains over a dozen standalone React projects built with modern tooling (Vite, TypeScript, React 19), each demonstrating a specific UI pattern or hook implementation. The codebase is well-organized into three main sections: a coding-exercise app with a registry pattern for interactive problem-solving, a coding-hooks library of reusable custom hooks (useDebounce, useFetch, useLocalStorage, etc.), and a set of coding-projects (accordion, autocomplete, carousel, data table, infinite scroll, modal, nested comments, shopping cart, star rating, theme switcher, todo, tree view). The projects are cleanly implemented with TypeScript, proper state management, and accessibility considerations. While primarily educational, the custom hooks and several UI components are production-quality and directly reusable in other projects.
CopilotKit is a comprehensive SDK and framework designed to integrate AI agents into user interfaces across web, mobile, and chat platforms. It functions as a middleware layer connecting frontend UI components (React, Vue, Angular) with backend agent frameworks (LangGraph, CrewAI, PydanticAI, etc.). The core value proposition lies in its ability to synchronize state between the agent and the UI, support generative UI (A2UI) for dynamic component rendering, and facilitate human-in-the-loop workflows. The repository is structured as a monorepo containing core runtime packages, framework-specific adapters, and an extensive suite of integration showcases. The architecture relies on a centralized runtime (`@copilotkit/runtime`) that handles agent connections via SSE and manages tool execution. Frontend interactions are managed through hooks (`useCopilotKit`, `useAgent`) that subscribe to the runtime. The codebase demonstrates a polyglot approach, supporting Python, TypeScript, Java, and C# backends alongside multiple frontend frameworks. While the core SDK is well-structured, the repository exhibits significant code duplication across its 20+ integration showcases, which serve as both documentation and regression tests.
Conductor is a production-grade workflow orchestration engine originally built at Netflix, now maintained by Orkes and the community. It provides durable execution for microservices, AI agents, and adaptive workflow graphs. The system defines workflows as versioned JSON DAGs with support for dynamic forks, loops, retries, timeouts, cancellation, pause/resume, and human-in-the-loop approvals. It has a modular Spring Boot backend with multiple persistence backends (PostgreSQL, MySQL, Cassandra, Redis, SQLite, Elasticsearch/OpenSearch) and event queue integrations (AMQP, NATS, SQS). The frontend is a modern React application with XState state machines, Material-UI, and a plugin system for extensibility. The codebase also includes a comprehensive AI integration layer with LLM providers (OpenAI, Anthropic, Gemini, etc.), vector databases, MCP tool calling, and the A2A agent-to-agent protocol. The architecture is microservices-ready with REST and gRPC APIs, a scheduler for cron-based workflows, and external payload storage (S3, GCS, Azure Blob). The project is actively maintained with a large community, but shows signs of technical drift due to multiple persistence backends, two coexisting UI codebases (legacy and modern), and some deprecated components.
Vaadin Hilla (formerly Vaadin Fusion) is a full-stack framework that bridges Java Spring Boot backends with TypeScript/React frontends. Its core function is automatic, type-safe code generation: Java classes annotated with @Endpoint or @BrowserCallable are parsed into OpenAPI specifications, which are then used to generate TypeScript client stubs, form models (with validation constraints mapped from JSR-380 annotations), and reactive signal bindings. This eliminates the need for manual API contracts and provides end-to-end type safety between server and client. The framework also includes a file-based router, a CRUD layer (ListService, FormService) integrated with JPA repositories, and reactive full-stack signals for real-time data synchronization via WebSocket push. Architecturally, Hilla is a monorepo organized into Java backend packages (endpoint, engine-core, typescript-generator) and TypeScript frontend packages (generator-core, react-crud, react-form, file-router, react-signals). Build integration is provided through Maven and Gradle plugins that trigger code generation during the build lifecycle. The code generator follows a plugin-based pipeline where each plugin (backbone, model, signals, push, subtypes, transfertypes) processes the OpenAPI schema to produce specific TypeScript output. The frontend runtime includes a middleware-enhanced ConnectClient for HTTP calls, declarative authorization via @AnonymousAllowed/@RolesAllowed, and a full i18n system. Security is a first-class concern with CSRF protection, JWT support, and Spring Security integration demonstrated across multiple test applications. The system does not include data pipeline or research code; it is a production-ready application framework. Notable reusable artifacts include a clean validator pattern in lit-form, a generic CommandRunner interface for external process execution, tree-merging utilities in the file router, and the full-stack signal implementation that demonstrates a command-based reactive state pattern. The codebase is actively maintained with extensive integration tests, though some areas (snapshot tests, dual Lit/React support, Atmosphere push dependency) introduce maintenance complexity and potential drift risks.
ra-supabase is a TypeScript library that integrates react-admin with Supabase. It provides a dataProvider, an authProvider, and OpenAPI-schema-driven UI guessers, allowing developers to generate a complete admin interface from a Supabase project with minimal configuration. The dataProvider translates react-admin CRUD operations into Supabase REST queries, supporting pagination, sorting, filtering, and embedded relationships through a custom `@` syntax. The authProvider wraps Supabase Auth, handling email/password login, OAuth callbacks, password reset, and session management. The guessers fetch the Supabase OpenAPI schema and generate List, Show, Edit, and Create pages, or a full `<AdminGuesser>` scaffold.
react-query-key-manager is a small, dependency-free TypeScript library that provides type-safe, composable, and collision-free query key management for @tanstack/react-query. It exposes two main functions: `key()` wraps a function returning a query key array, augmenting it to support both direct invocation and zero-argument composition calls; `defineQueryKeys()` creates namespaced key collections with recursive nesting, compile-time validation that all functions are wrapped with `key()`, and runtime duplicate-registration detection in development. The library uses advanced TypeScript techniques (const type parameters, mapped types, conditional types) to enforce API usage at build time and to produce precise IntelliSense types. The code is concise (~60 lines of core logic), well-structured, and fully self-contained. It solves a common pain point in large React Query applications—preventing magic string keys, collisions, and poor type safety—through a clever combination of type-level constraints and runtime utilities. The design philosophy emphasizes zero overhead and copy-pasteability, making it easy to vendor into any project. It is framework-agnostic and works with TypeScript 5.0+ and React Query v4/v5. However, the library is in an early stage (version 0.0.2) and lacks a test suite. The registry and keyNames are module-level singletons, which could cause issues in extreme edge cases like multiple library copies, but for typical usage it is solid. Overall, it is a well-crafted utility that delivers on its promises with a clean, type-safe API.
This is a monorepo for SurveyJS, a comprehensive open-source form/survey library that renders dynamic JSON-based forms across multiple frontend frameworks (React, Angular, Vue 3, and plain JavaScript). The core engine (`survey-core`) handles model parsing, validation, expressions, triggers, input masks, drag-and-drop, theming, and localization. It provides 20+ question types (text, checkbox, radio, dropdown, matrix, ranking, file, signature, etc.) with extensible UI components via framework-specific rendering packages. The library also includes a built-in linter for survey JSON static analysis and a tester for programmatic survey test execution. Architecture follows a layered pattern: core logic separate from UI, with each framework package consuming the core via a shared set of exported model classes. The codebase is large (2896 files) but well-structured, featuring a custom expression parser (PEG), a modular action-bar system, advanced popup management with focus trapping, and a generic drag-drop engine. Maintenance is active with frequent releases, but there is some technical drift in the form of commented-out legacy testcafe tests, auto-generated theme files, and cross-framework duplication that requires careful synchronization.
This is a Avalanche blockchain faucet service that allows users to request test tokens for various EVM-compatible networks and subnets. The application consists of a Node.js/Express.js backend with a React.js frontend. It implements sophisticated rate limiting (global, IP-based, wallet-based, and common token disbursal), captcha verification (reCAPTCHA v2/v3), and a pipeline check system requiring either mainnet balance validation or coupon redemption for token requests. The service supports multiple EVM chains and ERC20 tokens, with automatic nonce and balance management, transaction queuing, and mempool limit handling. Key architectural features include modular middleware, decoupled services for coupon and mainnet checking, and clean separation between blockchain interaction logic and API handling.
ToolJet is a comprehensive low-code/no-code application development platform designed for building internal tools, workflows, and AI agents. The system features a visual drag-and-drop editor (AppBuilder) that allows users to construct UIs using a library of widgets, connect to diverse data sources via a plugin architecture, and manage application logic through a backend NestJS service. It supports multi-tenancy, version control (Git), and enterprise-grade security features like SSO and RBAC. The architecture is a monorepo with a React-based frontend and a NestJS-based backend, utilizing PostgreSQL for persistence and Redis for caching.
Nextron is a CLI tool and scaffolding system that integrates Next.js with Electron for building cross-platform desktop applications using web technologies. It provides a streamlined development experience by orchestrating Next.js dev server, webpack bundling for Electron main and preload scripts, and optional production packaging with electron-builder. The repository contains the core library (CLI, build helpers, webpack configurations) and a rich set of example projects demonstrating integrations with UI frameworks (Ant Design, Chakra UI, Material UI, Tailwind CSS, Emotion, i18next) and features like window state persistence, static export, and custom build options. The architecture is monolithic, centered around a command-line interface with `dev` and `build` commands, and the codebase shows disciplined engineering with TypeScript, ESLint, Prettier, and lefthook. While primarily a development tool, its examples serve as practical templates for Electron+Next.js application patterns.
SigNoz is a full-stack open-source observability platform that ingests OpenTelemetry data (traces, metrics, logs), stores it in ClickHouse, and provides a rich web UI for querying, dashboards, alerts, and infrastructure monitoring. The backend is written in Go with a modular architecture using factory/provider patterns, SQL migrations, and OpenFGA-based authorization. The frontend is a React/TypeScript SPA with Zustand state management, react-query, uPlot charts, and a comprehensive query builder supporting PromQL, ClickHouse SQL, and builder queries. The enterprise edition adds anomaly detection, RBAC, licensing, and usage metering. The codebase is actively maintained with extensive testing (unit, integration, e2e) and CI/CD, though some legacy API versions and deprecated clients indicate ongoing migration.
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
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.
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.
Twinkle Tray is a Windows desktop application for managing monitor brightness and display settings. It uses Electron for the main process and React for the UI, communicating with monitors via DDC/CI, WMI, and software gamma ramps. The application features a system tray icon, brightness panel, settings window, and supports automatic adjustments based on time of day or ambient light. It relies on numerous Windows-specific native addons for low-level hardware access, which introduces maintenance risks but provides deep hardware integration.
Materio is a free admin dashboard starter template built on Next.js 14 App Router, MUI v5, and Tailwind CSS, published by ThemeSelection. It ships as two parallel, functionally identical codebases: javascript-version/ and typescript-version/. Everything in the repo is static UI - hardcoded demo data, mock ApexCharts, placeholder auth forms - there is no API layer, database, or authentication logic. Its job is to be a polished starting point for admin applications, and it executes that role well: an extensive per-component MUI theme override system, a custom collapsible vertical menu subsystem, and a cookie-persisted settings context for dark/light mode. Architecturally it follows Next.js App Router conventions: root layout (app/layout.jsx), a dashboard layout that wraps the VerticalLayout shell (navigation, navbar, footer), and a blank layout for login/register/error pages. The most interesting engineering lives in src/@menu (a self-contained vertical navigation layer with context-driven collapse/expand and breakpoint behavior), src/@core/theme (dozens of isolated MUI component overrides), and a few genuinely reusable React hooks (useObjectCookie, useImageVariant). All dashboard data is fabricated; adopters must wire real data and backend logic themselves. The template is actively maintained (last commit March 2026, one open issue, automated issue triage workflows). Drift risks are version pinning to Next.js 14 / MUI v5.15 and the maintenance cost of keeping JS and TS variants in sync.
The Hostel Management system is a MERN stack application designed for managing student hostels. It features user authentication (login, registration, profile management), student CRUD operations, attendance tracking by room, and analysis views with CSV export capabilities. The frontend is built with React and Redux, utilizing React-Bootstrap for UI components, while the backend uses Node.js with Express and MongoDB for data storage, secured with JWT-based authentication. The architecture follows a traditional client-server model. The frontend communicates with the backend via RESTful API endpoints. Key modules include authentication middleware, token generation utilities, and reusable UI components such as a search box and form container. The system allows administrators to manage users and students, while regular users can view and update their profiles and attendance. Despite functional implementation, the codebase exhibits some areas for improvement, including missing dependency declarations in React hooks (leading to potential stale closures) and tight coupling in certain components. However, the core functionality is sound, and the system demonstrates competent full-stack development practices suitable for a small to medium-sized application.
This repository is a personal portfolio website built with Next.js 14, React, and TypeScript. It features a blog section with MDX-powered articles sourced via Contentlayer, a projects showcase, and a responsive UI built with Chakra UI. The application uses static site generation (SSG) for optimal performance and includes client-side search functionality for articles and projects. Key architectural elements include the Next.js app router, file-based routing, and a modular component structure separating layouts, UI components, and data utilities. The site implements modern web development practices such as dark/light theme support, image optimization with blur placeholders, analytics integration (Vercel and Google Analytics), and error monitoring via Highlight. Content is sourced from MDX files in the data/articles directory and static JSON files for projects and publications. The build process leverages Next.js's incremental static regeneration (ISR) capabilities through Contentlayer, ensuring content updates without full rebuilds. Notable reusable components include a custom BlurImage component that enhances perceived performance by showing a blurred placeholder during image loading, and a Callout component for styling informational, warning, and error messages in MDX content. Both components are decoupled from specific business logic and demonstrate solid encapsulation patterns suitable for extraction into other projects.
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.