This is the Supabase JavaScript SDK monorepo, providing isomorphic client libraries for Supabase backend services. It is a well-structured TypeScript monorepo managed with pnpm and Nx, containing six core packages: auth-js (authentication), postgrest-js (database queries via PostgREST), realtime-js (WebSocket-based realtime subscriptions), storage-js (file storage and vector index API), functions-js (edge function invocation), and the umbrella supabase-js package that combines them into a single `createClient()` entry point. The SDK supports multiple runtimes (Node.js, Deno, browsers, Bun, React Native, Cloudflare Workers) and includes optional OpenTelemetry tracing support. The codebase demonstrates high craftsmanship with extensive TypeScript generics for type-safe query building, fluent builder patterns, robust error handling hierarchies, and comprehensive integration tests against local Supabase infrastructure. It is actively maintained with frequent releases, automated CI/CD, and a strong focus on backward compatibility.
Nuxt is a production-grade, open-source meta-framework for building full-stack web applications with Vue.js. It provides a comprehensive developer experience with file-based routing, server-side rendering (SSR), static site generation (SSG), incremental static regeneration (ISR), and a powerful module ecosystem. The repository is a monorepo containing the core framework (`@nuxt/nuxt`), a toolkit for module authors (`@nuxt/kit`), configuration schema (`@nuxt/schema`), and multiple builder integrations (Vite, Webpack, Rspack) plus a Nitro-based server engine (`@nuxt/nitro-server`). Architecturally, Nuxt operates in two phases: build-time and runtime. At build time, it loads configuration, installs modules, scans components and pages, generates optimized code (auto-imports, route definitions, plugin arrays), and bundles the application using the configured builder. At runtime, it handles SSR/CSR rendering, data fetching via `useFetch`/`useAsyncData`, state management with `useState`, routing with vue-router, and server-side logic via Nitro. The framework is highly extensible through hooks, modules, and layers, allowing customization at every level. Key entry points include `createNuxt`, `loadNuxt`, and `build` from `@nuxt/kit`, the CLI (`nuxi`), and runtime composables like `useFetch`, `useAsyncData`, `useHead`, and `useRouter`. External dependencies include Vue 3, Vite/Webpack/Rspack, Nitro, unhead, ufo, devalue, and many others. The codebase is actively maintained with a large test suite (unit, integration, e2e) and a sophisticated diagnostics system for developer feedback.
This is a Nuxt.js 2 authentication module that provides zero-boilerplate authentication support. It implements various authentication schemes (local, OAuth2, OpenID Connect, refresh tokens) and integrates with popular providers like Auth0, Google, Facebook, and Laravel-based systems. The module handles token storage, automatic refresh, user management, and provides middleware for route protection. It uses a modular architecture with core auth logic, scheme implementations, provider configurations, and utility functions.
This is a Nuxt 3 module that integrates Cloudflare Turnstile, a privacy-focused CAPTCHA alternative. It provides a Vue component (`<NuxtTurnstile>`) for client-side rendering of the Turnstile widget, a composable (`useScriptCloudflareTurnstile`) for script loading via `@nuxt/scripts`, and a server-side utility (`verifyTurnstileToken`) for token validation in Nitro endpoints. The module automatically handles script injection, token refresh, and exposes a reset method. It also supports an optional validation endpoint at `/_turnstile/validate`. The architecture follows the standard Nuxt module pattern: `src/module.ts` registers components, composables, and server handlers. External dependencies include Cloudflare's Turnstile API, `@nuxt/scripts`, `@nuxt/kit`, `defu`, and `pathe`. The codebase is well-structured, typed, and includes end-to-end tests with Playwright.
This is a Nuxt module for device detection that provides a reactive `$device` object and `useDevice()` composable. It determines device type (mobile, tablet, desktop), operating system (iOS, Android, Windows, macOS, Linux), browser (Chrome, Firefox, Edge, Safari, Samsung), and crawler status by parsing the User-Agent header and/or CDN-provided headers (Amazon CloudFront, Cloudflare). The core detection logic is encapsulated in `src/runtime/generateFlags.ts`, which is a standalone, well-tested function. The module is built for Nuxt 3+ (ESM-only) and uses `crawler-user-agents` for crawler detection with a build-time generated regex for performance. The codebase is small, focused, and demonstrates good engineering practices with clean separation of concerns, comprehensive tests, and proper use of Nuxt module APIs.
This is a monorepo for Auth.js (formerly NextAuth.js), a framework-agnostic authentication library for web applications. The core engine (`@auth/core`) handles OAuth/OIDC, email/passwordless, credentials, and WebAuthn/Passkey authentication flows. It provides a unified API for session management (JWT or database-backed), CSRF protection, and cookie handling. The library is designed to be integrated into multiple frameworks via separate packages: `@auth/nextjs`, `@auth/sveltekit`, `@auth/express`, `@auth/qwik`, and `@auth/solid-start`. Each framework package adapts the core `Auth` function to the framework's request/response model, offering server-side handlers, middleware, and client-side hooks. The repository also includes over 80 built-in OAuth/OIDC provider definitions (e.g., Google, GitHub, Discord, Auth0) and 20+ database adapters (e.g., Prisma, Drizzle, MongoDB, PostgreSQL, DynamoDB) that implement a standard `Adapter` interface for user persistence. The project is now part of Better Auth, and the README recommends new projects use Better Auth unless specific feature gaps exist. The monorepo contains development apps, example applications, and a comprehensive documentation site built with Nextra.
Inspira UI is a curated collection of beautifully designed, copy-paste-ready Vue/Nuxt UI components, inspired by Aceternity UI and Magic UI. The repository serves both as a component library and a documentation/demo site built with Nuxt 4, Tailwind CSS v4, and a rich ecosystem of animation and WebGL libraries (motion-v, Three.js, OGL, GSAP). The architecture is a standard Nuxt application with i18n (English, French, Chinese), content management via @nuxt/content, and a custom registry system that generates component metadata for CLI installation. Key entry points include the Nuxt configuration (nuxt.config.ts), the app configuration (app.config.ts) for UI theming, and the registry build script (scripts/build-registry.mts) that crawls component files and produces Zod-validated schemas. The primary data flow is static: markdown documentation files in content/ are rendered alongside live interactive playgrounds that allow users to tweak component props via DialKit config panels. External dependencies are heavy but modern, including motion-v for spring animations, Three.js/OGL for WebGL effects, canvas-confetti for particle effects, and @vueuse/core for utilities. The codebase demonstrates consistent patterns (barrel exports, cn() class merging, shader-based backgrounds, context injection for compound components) and a strong emphasis on visual polish and developer experience.
Nuxt Security is a Nuxt 3+ module that automatically configures applications to follow OWASP security patterns through HTTP headers and middleware. It provides security response headers (including CSP with nonce/hash support for SSR/SSG), request size and rate limiting, XSS validation, CORS support, and optional features like Basic Auth and CSRF protection. The architecture uses Nitro plugins to integrate with Nuxt's server lifecycle, separating concerns between configuration, middleware, build-time plugins, and runtime hooks. The module handles both SSR and SSG modes appropriately, using nonces for CSP in SSR and computed hashes for SSG, with proper strict-dynamic support.
unplugin-icons is a universal build tool plugin that enables on-demand import of thousands of SVG icons as framework-specific components. It integrates with Vite, Webpack, Rollup, Nuxt, Rspack, and esbuild via the unplugin abstraction. The core architecture consists of a loader that resolves icon paths (e.g., `~icons/mdi/account`), fetches SVG data from Iconify or custom collections, and passes the SVG through a compiler that generates code for Vue 3, React/JSX, Svelte, Solid, Astro, Ember, Qwik, Web Components, or raw SVG strings. Options allow customization of scale, style, class, icon customizer, and auto-install of icon sets. The resolver module enables auto-importing icons as components in Vue/React/Solid projects via unplugin-vue-components or unplugin-auto-import. The codebase is well-structured, with clear separation between build tool adapters, core logic, and compilers. It relies on external dependencies like @iconify/utils for SVG loading and optional peer dependencies for framework-specific compilation.
This is a full-stack web application for managing a WireGuard VPN server, implemented with Nuxt 4 (Vue 3 frontend) and Nitro (backend) with a SQLite database via Drizzle ORM. It provides a web-based admin UI for configuring the WireGuard interface (MTU, port, device, CIDR, routing table), managing clients (create, enable/disable, set expiry, per-client firewall rules, custom DNS/MTU), viewing traffic charts, and monitoring client status. The application supports multi-user authentication with password login, TOTP two-factor authentication, and OAuth providers (Google, GitHub, generic OIDC). It also includes an experimental AmneziaWG obfuscation mode, Prometheus and JSON metrics endpoints, a CLI for administrative tasks (password reset, client listing, QR code generation), and integration with iptables/nftables for per-client firewall rules. The system is packaged as a Docker image and relies on the host kernel's WireGuard module and iptables tooling.
This is a Nuxt 3 module that integrates Apollo GraphQL client into Nuxt applications. It provides a flexible configuration system for defining multiple Apollo clients with HTTP and WebSocket endpoints, authentication token management, and SSR support. The module auto-imports composables like useAsyncQuery, useQuery, useMutation, and useSubscription, and provides hooks for custom authentication and error handling. It also supports hot module replacement for Apollo client configuration files. The architecture uses Nuxt's module system (defineNuxtModule) to hook into the build process. It reads client configurations from nuxt.config or external files, generates runtime templates, and sets up a Nuxt plugin that creates ApolloClient instances with appropriate links (HTTP, WebSocket, auth, error). The composables layer provides SSR-friendly async query wrappers and authentication helpers. WebSocket support includes a restartable client for reconnection. Key entry points are src/module.ts (module setup), src/runtime/plugin.ts (client creation and plugin), and src/runtime/composables.ts (user-facing composables). External dependencies include @apollo/client, @vue/apollo-composable, graphql-ws, and @nuxt/kit.
This repository is a production full-stack application for browsing, searching, downloading, and publishing galgame (visual novel) sticker packs. It is a pnpm monorepo containing a Nuxt 4 SSR frontend (`apps/web`) and a Go Fiber v3 API (`apps/api`) backed by PostgreSQL. The API exposes both internal service endpoints and a public read-only OpenAPI "face" for sticker content, while integrating with external ecosystem services: an OAuth 2.0 identity provider (PKCE, httpOnly session cookies, BFF pattern), a centralized content-addressed image service, a catalog service for games/characters, and a community service for comments, notifications, and reactions. Deployment is Docker images to GHCR via Dokploy, with versioned SQL migrations and GitHub Actions CI building all images on push to the `svelte-kit` branch. The backend is well-layered: handlers own HTTP concerns, services contain business logic without importing Fiber, repositories use GORM, and repeated cross-service communication is isolated in reusable `pkg` clients. Noteworthy engineering includes batch hydration for pack covers/tags/authors, trigram GIN search over flattened multilingual text, cursor pagination for notifications, and RFC 9457 problem-detail error responses in the public API. The frontend is organized into feature modules and includes a race-condition-safe catalog picker, OAuth PKCE utilities, and server-side OG image generation. The codebase is maintained and technically current, though some operational risks remain: dual error dialects between internal and public APIs, silent degradation when optional upstream services are down, and a few hardcoded backfill mappings in one-time scripts.
This repository is a starter template for Nuxt 4 applications, created by Anthony Fu. It provides a pre-configured setup with modern tooling including Vue 3, Vite, UnoCSS for atomic CSS, Pinia for state management, PWA support via @vite-pwa/nuxt, and auto-imports for composables and components. The architecture follows Nuxt's file-based routing and SSR model, with a Nitro server layer for API endpoints (e.g., a simple pageview counter). The codebase demonstrates clean, idiomatic usage of Nuxt 4 features like `useState`, `useFetch`, layout system, and the Composition API. It is not a production application but a foundation for building Nuxt projects, with several reusable configuration modules and composables.
This repository provides a production-ready documentation template built on Nuxt 4, Nuxt UI 4, and Nuxt Content 3. The codebase implements a static site generator for technical documentation with full-text search, automatic navigation, dark mode, and optimized OG images. It includes a built-in MCP (Model Context Protocol) HTTP server that exposes two tools (`list-pages` and `get-page`) for AI assistants to discover and read documentation content programmatically. Additionally, it integrates `nuxt-llms` to pre-render `/llms.txt` and `/llms-full.txt` files for LLM consumption. The architecture follows a standard Nuxt/Nitro server-rendered app with prerendering enabled, relying on modules for search, image optimization, and content management. The repo is explicitly a template intended for forking, with clean configuration-driven customization via `app.config.ts` and a well-documented content structure.
Kanri is an offline-first Kanban board desktop application built with Tauri (Rust backend) and Nuxt (Vue 3 frontend). It manages boards, columns, and cards with rich features including drag-and-drop, tags, due dates, subtasks, rich text descriptions, custom backgrounds, and multiple themes (dark, light, Catppuccin, custom). Data is persisted locally via Tauri's plugin-store as a single JSON file, with no cloud dependency. The application supports importing from Trello, KanbanElectron, GitHub Projects, and Kanri's own format, as well as full/partial export. It includes a sidebar for pinned boards, keyboard shortcuts, zoom adjustments, and a comprehensive settings page. The architecture is a monolith: the frontend runs in a WebView, communicating with the Rust backend via Tauri commands for file system access, dialogs, window state, and autostart. State management uses Pinia stores with debounced auto-save. The project is in maintenance mode, accepting only small fixes and no AI-generated contributions.
This repository is a full-stack self-hosted media download manager and library preparation layer centered on yt-dlp. The backend is implemented in Python using aiohttp, SQLite (via SQLAlchemy), and includes a structured feature-based architecture (auth, presets, tasks, conditions, downloads, streaming, notifications, ytdlp integration). The frontend is a Nuxt 3 / Vue 3 single-page application with comprehensive i18n support. Core capabilities include automated download scheduling with cron-like task definitions, conditional filtering, Cloudflare challenge solving, real-time WebSocket updates, streaming via on-the-fly HLS transcoding with hardware acceleration fallback, and a browser extension for quick URL submission. The codebase demonstrates good engineering practices: event bus for decoupled communication, singleton-based service containers, repository pattern for data access, custom migration framework, and extensive async test coverage. Notable external dependencies are yt-dlp (core downloader), ffmpeg (transcoding), curl_cffi (impersonation), and apprise (notifications). While the architecture is modular and well-organized, there is some code duplication across CRUD repositories and migration files, and tight coupling to yt-dlp internals via custom patches. The project is actively maintained with frequent commits, a large test suite, and clear containerization support.
This is a Nuxt module that integrates Swiper.js into Nuxt 3 applications using Web Components. It provides automatic registration of `<swiper-container>` and `<swiper-slide>` custom elements, a Vue composable (`useSwiper`) for reactive Swiper instance control, and support for both bundled and individual Swiper module imports. The module is minimal, well-typed, and leverages Nuxt's module system for configuration. It includes a playground and test fixture but no complex business logic. The codebase is clean and modern, with proper TypeScript types and a structured setup, though the test suite is practically empty. The composable is well-crafted and could be extracted as a standalone utility.
This repository serves as the landing page for the Nuxt web framework, providing a minimal but polished interface to kickstart Nuxt projects. The core functionality is a gallery of starter templates—each pointing to a GitHub repository branch—with one-click redirections to CodeSandbox, StackBlitz, or a local `npm create nuxt@latest` command. The application is built with Nuxt 4 and leverages server routes for API lookups (slug-based) and redirects, client-side data fetching via `useFetch`, and a performant static generation pipeline. It also includes a custom `style-inlining` module that purges unused CSS and inlines critical styles during prerendering, and a `purge-comments` Vite plugin that strips HTML comments from Vue templates at build time. The UI is styled with Tailwind CSS and Nuxt UI components, and the entire site is designed to be lightweight (budgeted at 270 KB total). It is a genuinely useful tool for the Nuxt community, acting as both a promotional site and a practical starter launcher.
TypeWords is a browser-based English vocabulary and article memorization application built with Nuxt 3 / Vue 3. It operates on a local-first architecture, storing user progress in IndexedDB, with an optional (now obsolete) Supabase cloud sync. The application is a monolith SPA but is well-modularized into a custom UI kit (app/base/), core business logic (app/core/), and page components (app/pages/). The core learning mechanic is typing-based practice, supporting multiple modes (follow-write, dictation, self-test, spelling) for both individual words and full articles. It integrates the FSRS (Free Spaced Repetition System) algorithm for intelligent review scheduling. Static dictionary data (CET-4, GRE, NCE articles) is loaded from bundled JSON files. The practice flow is managed by a sophisticated, serializable state machine (practice-flow-types/runtime), demonstrating strong architectural patterns. The codebase exhibits high craftsmanship in several isolated components, such as the global dialog stack, event bus, and versioned cache. These are genuinely reusable patterns. However, the project suffers from significant technical drift: it relies on experimental Vue Macros ($ref/$computed), has zero automated tests, contains dead code (obsolete Supabase sync), and bundles third-party libraries statically. The TypeScript configuration is lax (strict: false), increasing refactoring risk. TypeWords is a feature-rich, community-driven project (10k+ stars) that effectively solves a specific learning problem. Its architecture is a valuable study for developers building local-first, content-rich Vue applications. However, its lack of tests and reliance on experimental features make it a risky candidate for direct production reuse without significant hardening. It is best suited for educational analysis or as a foundation for a new project willing to address the technical debt.
This is a self-hosted, free image hosting service (Telegraph-Image) built as a serverless application on Cloudflare Pages. It provides image upload, storage (Telegram Bot API or Cloudflare R2), serving with optional moderation (Workers AI or moderatecontent.com), and an admin dashboard (Vue-based) for managing images (list, block, delete, whitelist, edit names, toggle likes). The architecture follows a clean provider pattern for storage and moderation modules, uses middleware chaining via Cloudflare Pages Functions, and includes features like short links (KV-backed), anti-hotlinking, and deployment self-checks. The frontend is hybrid: a dependency-free modern homepage and an older Nuxt.js SPA for the admin panel. The codebase is well-tested with unit and e2e tests, but has technical debt from a legacy Nuxt frontend, deprecated `document.execCommand` usage, and reliance on external CDN resources for admin UI.