This is the marmelab/react-admin monorepo, a highly mature and widely-used frontend framework for building single-page admin panels in React and TypeScript. The repository is organized as a Lerna monorepo with core packages: `ra-core` (headless hooks, controllers, data provider abstraction, auth, i18n, store), `ra-ui-materialui` (all Material-UI based components for fields, inputs, lists, layouts, and buttons), and `react-admin` (umbrella entry point). It also includes scaffolding via `create-react-admin`, a no-code builder (`ra-no-code`), multiple data provider adapters (`ra-data-simple-rest`, `ra-data-graphql`, etc.), i18n packages (`ra-i18n-polyglot`, `ra-i18n-i18next`), and full-featured example applications (CRM, e-commerce demo, simple blog) that demonstrate real-world usage with authentication, filtering, theming, and offline support. Architecturally, the framework follows a clean separation of concerns: the core layer manages data fetching, authorization, navigation, and form state using React contexts and hooks, while the UI layer provides a comprehensive set of composable components. The data provider pattern abstracts any backend (REST, GraphQL, local storage) behind a uniform CRUD interface. The auth and i18n providers are similarly pluggable. The store abstraction (memory or localStorage) persists user preferences, selection, and saved queries. The routing is abstracted via a `RouterProvider` interface that supports React Router and TanStack Router. Over 26,000 GitHub stars and 5,400 forks attest to its community trust. The codebase exhibits strong engineering craftsmanship: extensive unit and integration tests (Jest, Cypress, Storybook), consistent use of TypeScript with generics, codemods for breaking changes, and a mature release process. The framework is actively maintained (dependabot, frequent releases, security patches) and remains well-aligned with its ecosystem (React 18, MUI v5, react-query v5, react-hook-form). Some deprecations and dual component implementations (Datagrid vs. DataTable) introduce minor friction, but overall this codebase is a gold standard for building enterprise admin UIs.
Refine is a headless React framework for building data-intensive applications like admin panels, dashboards, and internal tools. It provides a UI-agnostic core with adapters for Ant Design, Material UI, Mantine, and Chakra UI, plus data providers for REST, GraphQL, Supabase, Strapi, and other backends. The architecture centers around provider patterns (dataProvider, authProvider, etc.) and React Query-based hooks for data fetching and mutations. Key features include automatic CRUD generation via inferencer, undoable notifications, access control, i18n, and live updates. The monorepo structure manages numerous packages and examples, demonstrating a mature ecosystem with active development and comprehensive documentation.
ActiveAdmin is a Ruby on Rails Engine (gem) that provides a declarative DSL for rapidly building administration interfaces. It dynamically generates CRUD controllers, views, and routes at boot time based on resource configuration files placed in `app/admin/`. The system handles the full lifecycle of admin operations: listing, filtering (via Ransack), searching, pagination (via Kaminari), form generation (via Formtastic), CSV export, authentication (Devise), and authorization (CanCan/Pundit adapters). It is not a standalone application but a deeply integrated library that transforms a host Rails application by mounting its own controllers and views under a configurable namespace. The architecture follows a modular, engine-based pattern. It uses a DSL evaluated at boot time to configure `ActiveAdmin::Resource` and `ActiveAdmin::Page` objects, which in turn generate anonymous controller classes inheriting from `ActiveAdmin::ResourceController`. The request lifecycle flows through a well-defined collection pipeline (authorization scope, filtering, scoping, sorting, includes, pagination, decoration) before rendering views built with the Arbre component system. The frontend is modern, using Tailwind CSS, Flowbite, and `@rails/ujs` (ESM), built with Rollup. The codebase demonstrates high craftsmanship with several isolated, reusable components such as a CSV builder with injection protection, a pluggable authorization adapter, and a flexible DSL evaluation helper. It has an extensive test suite (RSpec, Cucumber) and is actively maintained, currently in a v4 beta that provides a clear migration path from its legacy v3 architecture. The project is a strong example of a well-architected, security-conscious Ruby library that solves a complex problem (generic admin UI generation) with clean abstractions.
AdminLTE is a professional, open-source admin dashboard template and UI framework built on Bootstrap 5.3. It provides a comprehensive set of responsive layout components, widgets, and vanilla TypeScript plugins (sidebar push menu, treeview, card widget, direct chat, fullscreen toggling, color mode, sidebar search, accessibility manager) activated via data-lte-* attributes. The architecture is modular: SCSS sources are compiled into a production-ready CSS bundle, and TypeScript sources are bundled into UMD and ESM builds. The project includes an extensive demo site with over 50 pages (dashboard, tables, forms, charts, mailbox, etc.) and a documentation site built with Astro and MDX. It ships with an optional extended color palette (14 WCAG AA-compliant colors) and a runtime primary color switcher, as well as a legacy v3 color compatibility sheet. The repository is the HTML/JS/CSS core; framework-specific editions exist for React, Vue, Angular, Laravel, and others.
Payload CMS is a headless content management system framework built on Next.js and TypeScript. It functions as a full-stack application generator, allowing developers to define content schemas (collections, globals) which automatically produce an admin UI, REST/GraphQL APIs, and database schemas. The architecture is a monorepo utilizing pnpm workspaces, with distinct packages for core logic (packages/payload), the admin interface (packages/ui), and database/storage adapters (packages/drizzle, packages/db-mongodb, packages/storage-*). It heavily leverages Next.js App Router and React Server Components for data fetching and rendering. The system supports polyglot persistence through adapters for PostgreSQL (via Drizzle ORM), MongoDB (via Mongoose), SQLite, and Cloudflare D1. It also abstracts file storage across providers like S3, Azure, GCS, and Vercel Blob. A significant portion of the codebase involves complex integration with the Lexical rich text editor and a robust plugin ecosystem for features like SEO, Ecommerce, and Multi-tenancy. The framework emphasizes developer experience through CLI tools, codemods for version upgrades, and extensive type generation. Maintenance is active with frequent commits and a large test suite covering integration and E2E scenarios. However, the complexity of maintaining multiple database and storage adapters alongside rapid Next.js ecosystem changes introduces a medium level of technical drift risk. Generated files in the admin UI and API routes require careful handling to avoid conflicts during framework updates, and the sheer number of open issues (846) suggests ongoing technical debt management.
Keystone 6 is a powerful, schema-driven headless CMS and application framework for Node.js. It allows developers to define their data model in TypeScript, from which it automatically generates a full GraphQL API, a Prisma ORM layer, and a beautiful React-based Admin UI. The framework excels in its extensibility, offering a rich document editor with custom component blocks, granular access control, flexible authentication strategies, and deep integration with modern frameworks like Next.js, Remix, and Astro. This monorepo contains the core packages, a comprehensive set of examples, and extensive integration tests. While the codebase is actively maintained and demonstrates high craftsmanship, its sheer size and explicit internal instability markers indicate a medium level of technical drift in some areas.
Vendure is a mature, open-source headless commerce platform built on NestJS, GraphQL, and TypeORM. It provides a complete backend for e-commerce operations including product catalog management, order lifecycle, payment/shipping/tax processing, promotions, and multi-channel support. The monorepo contains a core backend package, two parallel admin UIs (an older Angular-based admin-ui and a newer React-based dashboard), a CLI tool for scaffolding and migrations, and a plugin ecosystem with official plugins for email, asset server, job queues (BullMQ), caching (Redis), telemetry (OpenTelemetry), and AI integration via the MCP (Model Context Protocol) plugin. The architecture is modular with a strategy pattern for extensibility, an event bus for domain events, a job queue system, and a custom fields system. The codebase demonstrates strong engineering practices with extensive test coverage, CI/CD pipelines, and active maintenance. Notable reusable components include a generic finite state machine framework, a runtime-resolved custom fields system, an OAuth 2.1 authorization server, a dynamic form engine, and a tag-based cache invalidation service.
This repository provides a comprehensive component library for building admin dashboards and CRUD applications in React. It wraps react-admin's headless core (`ra-core`) with a shadcn/ui aesthetic, delivering over 80 reusable components including data table, forms, inputs, fields, buttons, layout elements, and a rich text editor. The architecture follows a provider pattern for data, authentication, and internationalization, making it backend-agnostic. It includes a demo e-commerce application, a Storybook for visual testing, a marketing website, and a shadcn registry for easy installation via the `shadcn add` command. The codebase is well-structured with extensive unit tests and documentation, though it depends on pre-release Base UI and several react-admin enterprise features that require a paid subscription.
DS2API is a production-grade API proxy/gateway that translates DeepSeek's web chat API into OpenAI, Claude, Gemini, and Ollama-compatible endpoints. It provides a full-featured web UI for administration, account management, proxy configuration, and API testing. The system handles authentication (JWT, API keys, managed accounts), streaming responses with tool call detection, and multi-protocol request normalization. Architecturally, it is a Go backend with a React frontend (Vite + Tailwind). The backend is modular: protocol-specific handlers (OpenAI chat/responses, Claude messages, Gemini generate, Ollama chat) share a common prompt compatibility layer that normalizes requests to DeepSeek's internal format. A custom DeepSeek client manages authentication, PoW challenges, session lifecycle, and streaming. The SSE parsing infrastructure, tool call sieve, account pool, and config store are reusable components with extensive test coverage. Key data flows: incoming API requests are parsed and normalized to a unified prompt representation (role-tagged messages, tool descriptions, file references). The prompt is sent to DeepSeek's web chat API via a streaming or non-streaming completion runtime. Responses are parsed from SSE chunks, transformed (thinking extraction, tool call normalization, citation handling), and streamed back in the original protocol format. The system supports retry logic, account switching, and current input file injection for large contexts. External dependencies include DeepSeek's web chat API (reverse-engineered), Go standard library, chi router, utls for TLS fingerprinting, Node.js for Vercel streaming and WebUI build, and React/Vite for the frontend. The project is actively maintained with CI/CD pipelines, Docker images, and Vercel deployment support.
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.
This repository provides deployment configurations and scripts for self-hosting the UI Bakery low-code platform. It contains Docker Compose files for local, Azure, and external database setups, Kubernetes manifests for orchestration, and shell scripts for installation, setup, and updates. The repository does not include the application source code but rather orchestrates pre-built Docker images of UI Bakery's services (gateway, frontend, backend, etc.). The installation script guides users through environment configuration, secret generation, and service startup via Docker Compose. While functional and demonstrating good practices in input validation and cryptographic secret generation, the update script contains a bug in the external database handling section, and the scripts lack modularity, limiting reusability beyond this specific deployment context.