This is a monorepo containing starter templates and final code for the official Next.js Learn courses. It includes multiple independent Next.js applications demonstrating the Pages Router, App Router, data fetching, authentication, SEO optimization, and more. The code is educational, well-structured, and follows modern Next.js patterns (server actions, streaming, suspense, etc.). It is not a production application but serves as a reference implementation for learning. The dashboard example includes a full CRUD invoice management system with PostgreSQL, NextAuth authentication, and Tailwind CSS styling. The basics examples cover static generation, dynamic routes, API routes, and TypeScript. The SEO example demonstrates performance optimization techniques like dynamic imports and lazy loading.
Pingvin Share is a self-hosted file sharing platform designed as an alternative to services like WeTransfer. It provides a full-stack application with a NestJS backend and a Next.js frontend, featuring user authentication (local, OAuth2, TOTP, LDAP), file uploads with chunked transfers, password-protected and expiring shares, reverse shares for receiving files, an administrative panel for managing users and system configuration, and support for multiple storage backends (local filesystem or S3). The application includes virus scanning via ClamAV, email notifications, and extensive internationalization. The backend employs a modular architecture with distinct modules for authentication, user management, share handling, file storage, configuration, and scheduled jobs. Key reusable patterns include an abstracted file storage service (supporting local and S3 providers), a strategy-based OAuth provider interface, and a dynamic configuration service that loads settings from the database with optional YAML file overrides and runtime update notifications. The frontend presents a polished user interface with custom hooks for configuration and user state, reusable input components for timespans and file sizes, and a sophisticated chunked file upload UI with progress tracking and error recovery. Although the original repository has been archived (as of June 2025) with a recommendation to use a maintained fork, the codebase demonstrates solid engineering practices, clear separation of concerns, and several reusable components that could be adapted for similar projects. The Dockerized deployment and comprehensive feature set make it a viable self-hosted solution for file sharing needs.
Agregarr is a full-stack Plex collection management application built with Next.js and Express, written in TypeScript. It automates the creation, synchronization, and visual customization of Plex collections by integrating with numerous external media sources and APIs including Trakt, TMDB, IMDb, Letterboxd, MDBList, AniList, MyAnimeList, Tautulli, Overseerr, Radarr, and Sonarr. The core architecture follows a monolithic pattern: a single server process running both the React frontend and Express backend, with SQLite persistence via TypeORM and a robust migration system. In production, Agregarr performs scheduled full syncs and incremental quick syncs of collection definitions to Plex, applies poster overlays based on configurable conditions (ratings, resolution, audio codecs, HDR formats), manages placeholder items for upcoming content, and can auto-request missing media through Radarr/Sonarr or Overseerr. The UI provides per-library collection views with drag-and-drop reordering, a visual poster editor with snap-to-guides and layering, an overlay editor with condition evaluation, and dashboard statistics from Tautulli. The codebase demonstrates solid engineering with clear separation of concerns, a template method pattern for collection sources (`BaseCollectionSync`), consistent API client wrappers, and modular UI form sections. However, it carries significant maintenance overhead from fragile web scraping (IMDb WAF, Cloudflare bypass), a large dependency surface including Chromium and Playwright, commented-out legacy code from its Overseerr fork, and reliance on external APIs that may change unexpectedly. The project is actively maintained with frequent migrations and feature additions.
This is a TypeScript library providing a builder API for typesafe Next.js server actions with Zod validation. It is structured as a monorepo with core package `zsa`, React hooks (`zsa-react`), React Query integration (`zsa-react-query`), and OpenAPI exposure (`zsa-openapi`). The core library supports input validation (JSON, FormData, useActionState), procedures for middleware chaining with context propagation, typed error handling via `ZSAError`, configurable retries and timeouts, and client-side hooks (`useServerAction`, `useActionState`). The OpenAPI module generates REST endpoints and OpenAPI specifications from server actions. The codebase is well-organized with fluent builder patterns, comprehensive test coverage (Jest + Playwright), and a documentation site using Fumadocs. However, it is a personal project currently lacking support for Next.js 15, and all packages are pre-1.0 (0.x), indicating potential instability and limited maintenance commitment.
RDocumentation 2.0 is the production Next.js frontend for rdocumentation.org, a searchable documentation browser covering every version of every R package published on CRAN and Bioconductor. It is a pages-router Next.js application (Next 14, React 18) deployed as a Docker container on ECS/Kubernetes with CircleCI. The application renders package pages with READMEs, function/topic documentation with syntax-highlighted examples and MathJax-rendered math, download statistics, GitHub repository metrics, collaborator profiles, and search results with pagination. It also implements numerous legacy redirect routes (e.g. campus/help, link/[topic], bare package/topic URLs) that resolve to canonical versioned URLs server-side, plus a local health-check endpoint used by container orchestration. The architecture is a server-rendered UI that delegates all data access to an external backend API at api.rdocumentation.org, supplemented by the GitHub GraphQL API (requiring a GITHUB_TOKEN) for repo star/fork/issue counts and cranlogs.r-pkg.org for monthly download data. Search and autocomplete are client-side, hitting the backend's Elasticsearch-backed search_functions and search_packages endpoints directly. The most interesting engineering resides in the lib/ layer: a custom R-version comparator (R versions are not semver; segments like "1.0.10" vs "1.2-3" need numeric segment comparison), a search query parser that recognizes both stats::lm and lm(stats) scoped-search formats, and client-side deduplication logic that collapses duplicate package/function versions while preserving relevance order β compensating for known quirks in the backend API (identical relevance scores tie-broken by insertion order, latest=1 flag dropping packages with null latest_version_id, function searches lacking topic documents for newest versions). Operational reality is documented honestly in docs/runbook.md: the UI is the most modern component in a larger legacy system. The backend API, worker, and Elasticsearch components date from 2015-2016 and run Node 8; the Depsy collaborator data source has been dead since 2018; and the frontend has minimal error handling when the API is unavailable. The UI code itself is well-structured and cleanly separated between components, lib helpers, and pages, but it ships without unit tests (only Playwright health checks), TypeScript is configured non-strict, and several dependencies lag their ecosystems (ESLint 7, TypeScript 4.9, react-markdown 5's deprecated plugin API, an old recharts beta).
DeepV-Ki is an AI-powered wiki generator for code repositories that combines a Next.js frontend with a FastAPI backend. The system allows users to input a repository URL and automatically generates documentation, architecture diagrams (Mermaid), and provides a RAG-based Q&A interface. It features multi-LLM provider support (OpenAI, Google Gemini, Azure, AWS Bedrock, Ollama), GitLab/GitHub/Bitbucket integration, asynchronous task processing with Celery, and multi-layer caching. The architecture follows a monorepo structure with clear separation between frontend (React/Next.js) and backend (Python/FastAPI) components, communicating via REST APIs. The system includes sophisticated authentication (SSO, session management), progress tracking, and real-time WebSocket communication for streaming AI responses.
LaResume is a full-stack, open-source resume builder and job application tracker built with Next.js (App Router), TypeScript, and Prisma (MongoDB). It provides multiple LaTeX-powered resume templates (sb2nov, techpro, deedy, mteck) with real-time preview, ATS optimization, and PDF export. The application includes a Kanban-style job tracker, shareable resume links with view analytics, and a one-time payment model for premium features (unlimited downloads, sharing). Authentication is handled by Clerk, and payments are processed via LemonSqueezy and Dodo Payments. The frontend uses shadcn/ui components, Redux Toolkit (RTK Query) for state management, and next-intl for internationalization across 12 languages. The backend exposes RESTful API routes for resume CRUD, sharing, compilation, and job board management, with LaTeX compilation running in a Dockerized TeX Live environment. The codebase also includes marketing pages (pricing, features, FAQ, contact) and SEO optimizations (JSON-LD, sitemap, Open Graph).
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.
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.
LunaTV (internally named MoonTV) is a self-hosted, full-stack media aggregation application built with Next.js 14, React 18, TypeScript, Tailwind CSS, and PWA tooling. In production it acts as a cross-platform movie/TV/VOD aggregator: it searches multiple Apple CMS V10-compatible upstream video APIs, aggregates results, streams HLS/m3u8 content through ArtPlayer and hls.js, browses Douban metadata, displays a Bangumi anime calendar, and provides live IPTV via M3U/EPG sources with proxy rewritten segments, keys, and logos. It also ships authentication, favorites, play records, skip-intro settings, search history, an admin panel for managing video sources/categories/users/live configs, and encrypted data export/import. The repository is an application, not a data-research project; its data aggregation is runtime functionality rather than analytical pipelines.
This repository implements a full-stack AI-powered food recommendation application called 'δ»ε€©εδ»δΉ' (What to eat today). The system combines a Next.js frontend with a Python Flask backend that uses a GraphRAG (Retrieval-Augmented Generation) architecture leveraging Neo4j for graph-based recipe relationships and Milvus for vector similarity search. Users interact via a chat interface to receive personalized recipe recommendations with step-by-step cooking instructions. The application includes a comprehensive recipe knowledge base in markdown format, Docker-based deployment orchestration, and a modular RAG pipeline with intelligent query routing and session management.
Overseerr is a full-stack self-hosted web application for managing media requests in a Plex ecosystem. Users can search for movies and TV shows via TMDB, submit requests (including 4K variants), and have those requests automatically pushed to Radarr/Sonarr for download. The application also tracks media availability by scanning Plex libraries, syncs Plex watchlists, and provides a comprehensive notification subsystem supporting Discord, Telegram, Slack, email, webhooks, and web push. It includes user management with granular permissions, quota enforcement, issue reporting, and a highly customizable discovery page built from TMDB-driven sliders, genres, networks, and studios. The frontend is Next.js (React) with Tailwind CSS, SWR, Formik, and react-intl i18n; the backend is Express with TypeORM on SQLite. The project is feature-rich and has been widely adopted, but the README states it is superseded by the Seerr community fork, and the codebase relies on several aging dependencies (Next.js 12, React 18, Tailwind 3) and a hardcoded TMDB API key. Despite this, the code is well-organized with clear separation between API clients, entities, routes, and UI components, and many parts are written with solid engineering patterns such as a base external API client with caching/rate limiting, a template-method scanner base class, and a clean notification agent interface.
Astrofox is a desktop application (Electron + Next.js) for creating audio-reactive motion graphics in real time. It provides a timeline-based editor where users compose layers (2D canvas renderings, 3D geometries, images, videos, text) and apply post-processing effects (blur, glitch, VHS, etc.) that are dynamically modulated by audio analysis via a reactor system. The application supports live input from microphone, desktop audio, and MIDI controllers, and can export videos to file using ffmpeg (desktop) or MediaRecorder (web). The architecture is a monolith with an Electron shell; the UI is a single-page React app with Zustand state management, React Three Fiber for 3D rendering, and a custom WebGL compositor with a pass-based shader pipeline. A plugin system allows external displays and effects via sandboxed workers or shader code. The codebase is extensive but shows signs of technical debt (heavy use of `@ts-nocheck` in many files, legacy migration code, no visible tests). Several subsystems (storage abstraction, audio analysis, compositor passes, ffmpeg wrapper) are well-isolated and could be reused in other projects.
Notty is a full-stack, cross-platform notes application (an Apple Notes-style clone) built with a React 19 + Vite + Tailwind 4 frontend, a Hono API running on Cloudflare Workers, and per-user Durable Objects that each own a SQLite database. Clients include a web app, a Tauri 2 desktop app (with local SQLite, markdown export/import, cloud sync, deep-link auth, and a quick-note hot corner), and a mobile variant. Realtime collaboration is powered by Yjs with three persistence paths (Durable Object SQLite, browser IndexedDB, and Cloudflare R2), and authentication uses Better Auth with passkeys, Google/GitHub/Apple social login, and anonymous sessions. The backend also serves server-rendered public pages generated from TipTap JSON with URL sanitization and RSS 2.0 feeds, and integrates Supermemory for AI-powered note indexing. File storage and full version-history snapshots live in R2, with branch management (create/checkout/merge/delete), diff views, and restore-with-auto-backup. The architecture is notable for its platform adapter pattern (web/desktop/mobile adapters abstracting storage and sync) and per-user Durable Object isolation, but the codebase carries meaningful baggage: dead code from an earlier NextAuth-based iteration (src/lib/auth.ts, old NotesContext, DarkModeSwitch, search-results.tsx), no visible unit tests beyond a race-condition QA script, a non-standard FNV-1a-based lock token instead of a real HMAC, and a merge operation that is actually a replace. Optimistic update logic in the notes context is fragile and can diverge from server state under rapid tab switches. Despite these issues, the core architecture is sound and the adapter pattern is genuinely reusable.
This repository is a large, personal competitive programming solution archive spanning multiple platforms (LeetCode, Codeforces, CSES, AtCoder, etc.) with a companion Next.js web application (LeetGoat) for managing and browsing problems. The codebase contains over 3,900 files, predominantly short algorithmic solution scripts in Python, C++, and JavaScript, accompanied by reusable algorithm templates and a structured problem metadata system using Prisma and Supabase. While the primary content is the solution library, the integrated web application provides authentication, admin CRUD for problems and tags, drill grouping, and practice pages. The app uses tRPC for type-safe APIs, Supabase for auth, and Prisma for database access. However, many site pages are placeholders ("Coming Soon"), indicating an early-stage product. Code quality varies widely: many solutions are well-commented and demonstrate strong algorithmic thinking (DP, segment trees, graph algorithms), while others are incomplete, contain known bugs, or carry disclaimers like "BAD SOLUTION". The templates directory contains genuinely reusable components (sparse tables, DSU, segment trees, centroid decomposition) that could be extracted for other projects. Maintenance is ongoing with frequent commit activity, but the sheer volume and mixed concerns (solutions + web app) introduce technical drift. No testing suite or CI is evident, and some solutions depend on external libraries (sortedcontainers) not always available in competitive programming environments.
Upstat is a self-hosted, open-source status monitoring and uptime tracking tool. The system consists of a Go (Fiber v2) backend API and a Next.js 15 web dashboard, deployed via Docker Compose with support for both PostgreSQL and SQLite databases. The backend periodically pings configurable HTTP endpoints, records heartbeats, calculates uptime percentages, and manages incidents triggered by status transitions. It integrates with multiple notification channels (Discord, Slack, Telegram, Ntfy, Gotify) and provides public status pages with real-time latency charts. The frontend uses shadcn/ui components, React Hook Form with Zod validation, and a custom client fetch wrapper for authenticated API calls. The monorepo also includes a documentation site (Fumadocs) and a static landing page. While the architecture is well-structured with clear separation of concerns (controllers, routes, models, utils), the codebase shows signs of technical drift including outdated dependencies, hardcoded secrets in Docker Compose files, committed SQLite database artifacts, and documentation inconsistencies between the manual API docs and generated OpenAPI spec. The project is functional and suitable for small to medium deployments but would benefit from dependency updates and cleanup before production use.
This repository implements a full-featured graphic design SaaS application, a clone of Canva. It is built with Next.js 14 (App Router), React 18, TypeScript, Tailwind CSS, and uses Fabric.js 5.3.0 for the canvas editor. The application allows users to create visual projects (designs) with layers including shapes, text, images, drawings, and AI-generated content. It supports background removal, image filters, color manipulation, and font adjustments. Authentication is handled via NextAuth v5 with credentials, GitHub, and Google OAuth, integrated with a PostgreSQL database through Drizzle ORM. Subscriptions (Free/Pro tiers) are managed via Stripe, limiting certain features like unlimited projects and AI capabilities. The dashboard lists user projects and templates, while the editor provides a rich toolbar, collapsible sidebars, and keyboard shortcuts. External dependencies include Unsplash for stock images, UploadThing for user file uploads, Replicate for AI inference (image generation, background removal), and Stripe for payments. The architecture follows a feature-based module structure with dedicated folders for auth, editor, projects, subscriptions, AI, and images. Server API routes are built using Hono.js mounted under a catch-all route, and client-side data fetching uses TanStack Query. State management for modals and UI is handled by Zustand. The codebase is well-organized for a production-grade tutorial project but lacks automated tests and contains some type safety shortcuts.
LiveCanvas is a collaborative whiteboard and diagramming web application built with Next.js 14, Convex as the real-time backend, and Kinde for authentication. It allows users to create teams, manage files, and edit documents using Editor.js alongside an Excalidraw-based canvas for freeform drawing. The architecture follows a standard Next.js App Router pattern with client-side rendering for authenticated routes and server components for the landing page. Data flows through Convex mutations and queries, with file content (document JSON and whiteboard elements) persisted as strings. The application is functional but exhibits several minor issues: the dark mode CSS is incorrectly defined (identical to light mode), there are typos in mutation argument names ('archieved' instead of 'archived'), and the codebase lacks tests or CI/CD configuration. While it demonstrates integration of multiple third-party libraries, the components are tightly coupled to the app's specific data model and are not easily reusable outside this project.
CoCo Downloader is a multi-platform music retrieval and acquisition tool with a web frontend (Next.js/React) and a desktop client (Python/PyQt5). It enables users to search, preview, and download music from multiple Chinese streaming services (QQ Music, NetEase Cloud Music, Kugou, etc.) by reverse-engineering their APIs and scraping their HTML. The architecture follows a monolithic design for each platform, with shared provider abstraction patterns but separate implementations. The web app exposes API routes that proxy requests to music providers, while the desktop client uses a similar pattern with Qt-based UI. Notable features include multi-quality downloads, playback with lyrics display, caching, and theme support. The repository demonstrates moderate engineering craftsmanship with clean provider interfaces but suffers from duplicated code across platforms, hardcoded and potentially brittle API parameters, and security concerns (exposed API keys). It is a functional hobbyist-grade application with a dedicated community (553 stars, 166 forks).
AgentKit is a full-stack framework for building constrained, reliable LLM agents, developed by BCG X and now deprecated. The codebase consists of a FastAPI backend (Python 3.10) that orchestrates LangChain-based agents through a meta-agent and a simple router, executing tools like SQL queries, PDF question-answering, visualizations, image generation, and summarization. The Next.js 14 frontend provides a conversational chat interface with streaming responses, tool action rendering, and configurable UI components. The application is Dockerized with PostgreSQL, Redis, Minio, and Caddy, and supports optional features such as user authentication (NextAuth), feedback collection (LangSmith), and Celery-based background tasks. The architecture is monolithic in code but service-oriented in deployment, with configuration-driven agent behavior via YAML files. While the codebase demonstrates solid engineering patterns (e.g., streaming callbacks, base tool classes, state management), it is explicitly deprecated, relies on outdated LangChain imports and API versions, and requires significant maintenance to be viable for new projects. The repository serves as a reference for building constrained agents but is not recommended for production use without substantial updates.