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.
The auth0-spa-js repository is a JavaScript/TypeScript SDK for authenticating Single Page Applications (SPAs) with Auth0. It implements the Authorization Code Flow with PKCE, providing methods for user login (redirect and popup), silent token acquisition, token refresh, logout, and user information retrieval. The SDK includes advanced features such as Multi-Factor Authentication (MFA), passkey/WebAuthn support, DPoP (Demonstrating Proof of Possession) for token security, Multi-Resource Refresh Tokens (MRRT), and custom token exchange per RFC 8693. Architecture-wise, it is modular with separate concerns: core authentication (Auth0Client), caching (memory and localStorage), storage (cookies and session storage), Web Worker for token operations, and specialized modules for MFA, passkeys, and account management. Key entry points include the `createAuth0Client` factory function and the `Auth0Client` class. The library relies on @auth0/auth0-auth-js for low-level Auth0 interactions and browser-tabs-lock for cross-tab synchronization.
Hoppscotch is an open-source, multi-platform API development ecosystem that serves as a full-featured alternative to Postman. It supports REST, GraphQL, WebSocket, SSE, Socket.IO, and MQTT protocols, with advanced features like pre-request and test scripting (sandboxed), environment variables, team collaboration, mock servers, published documentation, AI assistant, and extensive import/export (Postman, Insomnia, OpenAPI, HAR, cURL). The monorepo is organized into packages: a Vue 3 frontend (hoppscotch-common), a NestJS/GraphQL/Prisma backend (hoppscotch-backend), a Tauri desktop app (hoppscotch-desktop), a Node.js CLI (hoppscotch-cli), a Tauri agent for interceptor (hoppscotch-agent), a shared kernel abstraction layer (hoppscotch-kernel), versioned data schemas (hoppscotch-data), a JavaScript sandbox engine (hoppscotch-js-sandbox), and self-hosted web/admin panels. The architecture emphasizes functional programming with fp-ts, reactive state management via RxJS DispatchingStores, dependency injection with dioc, and a kernel/relay pattern that abstracts HTTP execution across platforms. The codebase is actively maintained with extensive test coverage and demonstrates high craftsmanship in areas like versioned data migration, sandboxed script execution, and cross-platform kernel design.
Piral is a production-grade micro-frontend framework that enables building modular single-page applications (SPAs) with independently developed, runtime-integrated modules called pilets. The repository is a monorepo containing the core framework (piral-core, piral-base, piral), a CLI toolchain (piral-cli, piral-cli-webpack5), over 20 feature plugins (authentication, UI components, state management, search, notifications, etc.), and 15+ framework converters (React, Vue, Angular, Svelte, Blazor, etc.). The core architecture provides a shell application with pilet loading, extension slots, event system, shared dependency management via import maps, and state management using Zustand. The CLI supports scaffolding, building, debugging, validation, and publishing of both pilets and Piral instances. The codebase demonstrates strong engineering practices with extensive TypeScript, unit tests (Vitest), and a consistent plugin/converter pattern. Some technical drift exists in legacy pilet specifications and multiple router version adapters, but the project remains actively maintained.
The TodoMVC repository serves as a collection of reference implementations of the TodoMVC specification across numerous frontend frameworks. It provides a static file server (server.js) to serve these examples and includes comprehensive Cypress-based test infrastructure to validate implementations against the specification. Each framework implementation is self-contained in the examples/ directory, with shared assets in todomvc-common/ and todomvc-app-css/. The repository enables comparative evaluation of frameworks through identical feature implementations and automated testing.
This is the official Auth0 React SDK (`@auth0/auth0-react`), a client-side library that provides React bindings for Auth0 authentication. It wraps the core `@auth0/auth0-spa-js` library and exposes a React-friendly API via context, hooks, and higher-order components. The architecture follows a standard React context provider pattern: `Auth0Provider` wraps the application tree, and `useAuth0` (or `useAuth0Suspense`) provides authentication state and methods (login, logout, token management, MFA, passkeys). The SDK supports OAuth2 Authorization Code Grant with PKCE, refresh token rotation, DPoP, and custom token exchange. It is designed for single-page applications and is compatible with React 19+, including Next.js App Router (via `'use client'` directive injection). Key entry points include `Auth0Provider` (the root provider), `useAuth0` (primary hook), `useAuth0Suspense` (Suspense-enabled variant), `withAuthenticationRequired` (HOC for route protection), and `withAuth0` (legacy HOC). The SDK manages authentication state through a reducer (`src/reducer.tsx`) and provides a rich error hierarchy (`OAuthError`, `MfaRequiredError`, etc.). External dependencies are minimal: React, ReactDOM, and `@auth0/auth0-spa-js`. The codebase is well-tested with Jest unit tests (using a manual mock for the underlying SDK) and Cypress integration tests against a live Auth0 tenant. The SDK demonstrates strong engineering practices: typed interfaces, memoized context values, structured error handling, and a clear separation of concerns between the provider, hooks, and HOCs. It includes generated TypeDoc documentation and example applications for Vite, Gatsby, and Next.js. While the library is tightly coupled to the Auth0 ecosystem, its patterns (context-based auth, Suspense integration, error hierarchy) are reusable in other authentication contexts.
docsify is a client-side JavaScript documentation site generator that converts Markdown files into a fully functional, single-page application website with no build step required. It runs entirely in the browser, dynamically loading and rendering content from Markdown files served as static assets. The architecture centers on a core class composed via mixins (Fetch, Events, Render, VirtualRoutes, Router, Lifecycle) and a plugin system with lifecycle hooks (init, mounted, beforeEach, afterEach, doneEach, ready). Key features include hash or HTML5 history routing, full-text search using IndexedDB via Dexie.js, embed support for external files with fragment extraction, virtual routes for dynamically generated content, Vue.js component compatibility, and a theming system driven by CSS custom properties. The project includes built-in plugins for emoji, zoom-image, front-matter, external-script, Google Analytics, Gtag, Matomo, Disqus, and Gitalk. The codebase demonstrates solid software engineering practices: mixin-based composition, clean plugin API, memoized caching, debounced scroll handling, and a well-organized test suite covering unit, integration, and E2E tests. While not a data or research project, it showcases reusable patterns in client-side SPA development, particularly in routing abstraction, plugin lifecycle, and CSS theming. Some technical debt exists: deprecated configuration options (themeColor, topMargin), a forked YAML parser for front-matter, heavy use of globals, and an auto-generated emoji data file that may become stale. Overall, it is a mature, well-crafted tool with high utility for documentation sites.
Routify (@roxi/routify) is a file‑based routing framework for Svelte applications. It provides a build‑time plugin system that parses a directory structure (files, `_module`, `_reset`, `[param]`, `[...spread]`) into a route tree, and a runtime that renders routes with support for multiple routers, decorators, inline pages, and SSR/SSG. The library integrates with Vite via a dedicated plugin and with Express for server‑side rendering. It is not a standalone application but a library published on npm, with a CLI (`routify build`, `routify create`) and a rich set of example projects demonstrating usage with SvelteKit, Tailwind, TypeScript, mobile layouts, and more. The codebase is well‑structured, with clear separation between build‑time and runtime logic, a plugin architecture, and comprehensive tests. Despite its pre‑release version (`3.0.0‑next.22`), the library is actively maintained and production‑ready for many use cases.
ReactFlux is a modern, customizable web frontend for Miniflux, a self-hosted RSS reader. It is a client-side single-page application (SPA) built with React 19, Vite 8, and nanostores for fine-grained state management. The application provides a rich reading experience with multiple article layouts (list, card, column), dark/light/system themes, keyboard shortcuts, touch gestures, offline support via PWA, and internationalization (6 languages). It communicates exclusively with a Miniflux server through its REST API, handling authentication, feed/category management, article fetching, and status updates. The architecture follows a component-based design with clear separation of concerns: API layer (src/apis), state stores (src/store), custom hooks (src/hooks), reusable UI components (src/components/ui), and utility functions (src/utils). The codebase demonstrates good engineering practices with well-factored hooks for complex behaviors like optimistic entry actions, infinite scroll pagination, and long-press context menus. It also includes a settings schema with versioned migration and import/export, accessible modal and scroll area components, and a feed icon fetcher with fallback chain. While the project is actively maintained and uses modern dependencies, it lacks automated tests and has a large CSS footprint with many responsive overrides. The tight coupling to the Miniflux API and reliance on experimental React Compiler features introduce some maintenance risk. Overall, ReactFlux is a strong example of a feature-rich client-side application with reusable patterns, suitable for developers building similar RSS reader interfaces or learning advanced React patterns.
oidc-spa is a production-grade OpenID Connect (OIDC) client library designed for browser-first single-page applications. It implements the Authorization Code + PKCE flow with security-first defaults including in-memory token storage, DPoP (Demonstration of Proof-of-Possession) support, token substitution to prevent token leakage, and browser runtime freezing to resist monkey-patching attacks. The library provides framework-specific adapters for React, Angular, Next.js, Nuxt, TanStack Start, and React Router, each offering hooks, guards, and middleware for seamless authentication integration. It also includes a Vite plugin for build-time injection, a mock OIDC adapter for testing, and server-side utilities for access token validation (RFC 9068). The core is framework-agnostic, with a custom reactive event system (Evt) for state management and cross-tab synchronization via BroadcastChannel. The repository contains extensive example applications demonstrating login/logout, protected routes, role-based access, and auto-logout overlays across multiple frameworks.
This is an Angular SDK library (`@auth0/auth0-angular`) that integrates Auth0 authentication (OAuth2/OIDC) into Angular single-page applications. It wraps the Promise-based `@auth0/auth0-spa-js` into Angular's reactive ecosystem using RxJS Observables, dependency injection, and Angular Router. The library provides core authentication flows (redirect/popup login, logout, token management), route protection via guards, automatic bearer token injection via HTTP interceptors, and additional features such as MFA, passkeys (WebAuthn), enterprise account linking, custom token exchange, and a MyAccount API client. It supports both traditional NgModule-based and modern standalone (functional) Angular patterns. The playground application included serves as a development and e2e test harness with a local OIDC provider. The architecture is clean, well-tested, and follows Angular best practices, though the core logic is delegated to the underlying Auth0 SPA SDK.
IT-Tools is a single-page application (Vue 3 + TypeScript + Vite) that provides a curated collection of over 80 client-side developer utilities. These utilities include hashing, encoding, formatting, conversion (JSON, YAML, TOML, XML, etc.), crypto (JWT, RSA, bcrypt), network tools (IP subnet calculator, MAC address lookup), text manipulation, and many others. All processing occurs entirely in the browser; there is no backend. The app is a monolith with lazy-loaded per-tool routes, using a custom UI component library (c-*) alongside Naive UI, Pinia for state, vue-i18n for translations, and VueUse composables. It is containerized (Docker) and can be self-hosted or used via the hosted version on Vercel/Netlify. The repository demonstrates a strong convention for tool definition, testing, and internationalization, though tool quality varies. It is not a data research or analytics project.
DevDocs is a web application that aggregates and serves API documentation for hundreds of programming languages, frameworks, and tools in a unified, searchable, offline-capable interface. The backend is a Ruby/Sinatra server that provides the static assets and a minimal API, while the frontend is a custom JavaScript single-page application with client-side search, keyboard navigation, and a service worker for offline access. The core data generation pipeline consists of Ruby scrapers that fetch documentation pages from official sources, apply a chain of filters (HTML cleaning, entry extraction, URL normalization, image optimization), and produce normalized JSON indexes and cached pages stored on disk. The architecture is largely monolithic with a strong separation between the scraping pipeline (lib/docs) and the frontend (assets/javascripts). While primarily an application, it contains a substantial data engineering component in its scraper/filter system, which is reusable and generalizable for other documentation aggregation projects.
Szurubooru is an image board (booru) web application for uploading, tagging, and discussing media content. It features a client-side single-page application (SPA) built with vanilla JavaScript and a server-side Python backend using SQLAlchemy ORM with a RESTful API. The system uses PostgreSQL for data storage and is deployed via Docker containers. Key architectural concerns include a clean separation between client and server, with the client handling UI interactions and the server managing data persistence and business logic. The application implements common web application patterns such as event-driven client-side components, optimistic locking for concurrent updates, and a modular serialization framework for API responses. While the codebase demonstrates solid engineering practices, it shows signs of technical drift due to reliance on outdated base images (Node.js 14 and Python 3.9) and legacy build tools (browserify/babelify). The project is actively maintained, as evidenced by recent commits and ongoing issue activity.
This repository is a comprehensive React workshop containing three main applications: a vacation search SPA, an e-commerce store using React Router's data APIs (loaders/actions), and a Next.js app demonstrating React Server Components. It also includes extensive course materials covering React fundamentals, advanced hooks, form abstractions, and performance optimization. The applications showcase modern React patterns including context API, custom hooks, component composition, and data fetching evolution from useEffect to React Query to loader functions.
This is a Preact single-page application that provides a user interface for uploading files to a backend API (DirectLink) that returns direct download links. The frontend handles file selection via drag-and-drop or file input, uploads with progress tracking, and maintains a history of uploaded files stored in localStorage. It uses valtio for reactive state management, Material UI and styled-components for styling, and axios for HTTP requests with retry logic. The application is cleanly structured with reusable custom hooks (useUnmountEffect, useProxyState) and a portal-based dialog system (DialogContainer). The backend is a separate binary not included in this repository. The codebase demonstrates modern frontend engineering with good separation of concerns and moderate complexity.
Nakarte is a client-side single-page web mapping application built with Leaflet and Knockout, specialized for outdoor activities like hiking, cycling, and mountaineering. It provides an extensive catalog of map layers (OSM, satellite, topographic, overlays) with a strong focus on European and Russian regions. The application includes comprehensive GPS track management: loading from files (GPX, KML, GeoJSON, etc.) and online services (Strava, Garmin, OSM, Wikiloc), editing, elevation profiles, and exporting to GPX/KML/ZIP or Garmin JNX format. Additional features include search with multiple providers, panorama viewers (Mapillary, Wikimedia), azimuth/distance measurement, coordinate display in various formats, map printing with page layout, session save/restore, and custom layer configuration. The architecture is a classic Leaflet-based SPA with Knockout for UI bindings, webpack for bundling, and a separate CORS proxy server for tile access. External dependencies include Leaflet, Knockout, protobuf for track serialization, and various external API services. The codebase shows signs of organic growth with legacy code patterns (vendored scripts, relaxed ESLint for old files) and mixed English/Russian comments.
GraphvizOnline is a client-side Single Page Application (SPA) designed for editing and rendering Graphviz DOT language diagrams directly within the browser. The architecture is purely frontend, utilizing the Ace Editor library for syntax highlighting and `viz.js` (Graphviz compiled to JavaScript/WebAssembly) for rendering. The application manages state via URL parameters and hash fragments, enabling shareable links and presentation modes without backend dependencies. It functions as a self-contained static web tool, relying on bundled dependencies for core functionality.
This is a full-stack web application starter kit combining Angular (frontend) and Spring Boot (backend) with JWT-based authentication. The system provides user registration, login, role-based access control (USER/ADMIN), and protected API endpoints. The frontend communicates with the backend via RESTful APIs, with authentication handled through JWT tokens stored in cookies. The architecture follows a standard client-server pattern with clear separation of concerns: Angular handles UI presentation and user interactions, while Spring Boot manages business logic, data persistence, and security. Key features include route guards for client-side protection, custom JWT filters for server-side authentication, and centralized service layers for API communication.
Fwitter is a Twitter-like social media application built with React and FaunaDB. It functions as a single-page application where the frontend communicates directly with FaunaDB for all data operations, authentication, and authorization. The architecture uses React hooks for state management, React Router for navigation, and FaunaDB's User Defined Functions (UDFs) encapsulated in a query manager layer to handle data interactions securely. Key features include user registration/login, posting text/media content, liking/commenting/refweeting, following users, and searching by tags or usernames. The application demonstrates FaunaDB's capabilities for building serverless applications with fine-grained access control through roles and UDFs.