This repository is a starter theme for building headless ecommerce storefronts with Shopify using Astro. It provides a server-rendered Astro application with Svelte islands for interactive components like the cart drawer and add-to-cart form. The application fetches product data from the Shopify Storefront GraphQL API, displays product listings and detail pages, and manages a shopping cart with persistent state via nanostores. It is configured for deployment on Vercel and uses Tailwind CSS for styling. The architecture is a monolithic web application with clear separation of concerns: `src/utils` contains the Shopify API client, GraphQL queries, Zod schemas for runtime validation, and configuration; `src/stores` manages cart state; `src/components` contains Astro and Svelte components for UI. The Shopify client (`src/utils/shopify.ts`) intelligently switches between public and private access tokens based on server/client rendering and includes buyer IP forwarding for accurate pricing. The codebase demonstrates modern practices: TypeScript strict mode, Zod validation of external API responses, Svelte 5 runes, and responsive image generation with srcset. While the theme includes demo content (hardcoded reviews, accordions) and a hardcoded API version (2023-01), the core utilities are well-crafted and reusable. The Shopify API client and image component can be extracted into other projects with minimal changes. Overall, this is a solid, professional-grade starter theme that showcases a clean integration between Astro, Svelte, and Shopify.
This is an enterprise-ready monorepo starter for content-driven websites, combining Strapi v5 (headless CMS) as the backend and Next.js 16 (App Router) as the frontend, managed with Turborepo and pnpm. In production, it provides a visual page builder with dynamic zones in Strapi, rendered server-side by Next.js with ISR and cache revalidation via Strapi document middleware. The system includes end-user authentication (Better Auth + Strapi JWT), localization (next-intl), media handling (imgproxy), SEO helpers, preview mode, optional CDN purge (Azure Front Door), and observability (Sentry, Azure Monitor). It is not a data research repository; the hybrid nature comes from data seeding workflows and Strapi config-sync exports that version content-model layouts and permissions, but the dominant character is a full-stack web application starter. The architecture is a monorepo with two primary apps (`apps/strapi` and `apps/ui`), shared packages (`packages/design-system`, `packages/logging`, `packages/eslint-config`, `packages/shared-data`, `packages/strapi-types`), a Docusaurus documentation site (`apps/docs`), and a Playwright QA workspace (`qa/tests/playwright`). Key entry points include the Strapi bootstrap and admin panel extensions, the Next.js middleware chain (`proxy.ts`) implementing basic auth, redirects, auth guard, and security headers, catch-all ISR pages, and API routes for revalidation, CDN purge, and Strapi proxying. The primary data flow is content authored in Strapi → published → document middleware triggers UI revalidation → Next.js fetches Strapi content via server-side API clients and renders pages with ISR. External dependencies are modern and pinned (Next.js 16, React 19, Strapi v5, TailwindCSS v4, Better Auth). The codebase demonstrates high craftsmanship with clean abstractions: a composable proxy middleware chain, pluggable CDN and telemetry providers, a typed Strapi API client with pagination, a hierarchy service computing fullPath changes with redirect compaction, and a shared logging package with OpenTelemetry correlation. Testing is comprehensive with Vitest unit tests and Playwright e2e/visual/SEO/accessibility suites. Some scaffolding remains incomplete (e.g., `removeThisWhenYouNeedMe` markers), and the two rich-text editors (CKEditor and TipTap) introduce duplicate rendering paths. Overall, this is a strong, well-documented starter suitable for teams building content-rich websites with a modern stack.
This repository is a minimalist CV (resume) web application built with Next.js 16, React 19, TypeScript, and Tailwind CSS. It serves as a personal portfolio site that renders resume data from a single TypeScript file into a print-friendly layout. The architecture follows Next.js App Router conventions with server-side rendering and static generation. Key features include a command menu for quick navigation, responsive design, dark mode support, SEO-optimized structured data (JSON-LD), and a production-ready Docker setup. The codebase demonstrates strong engineering practices with clear separation of concerns, reusable UI components, and attention to accessibility and performance.
Kurrier is a self-hosted unified communication platform designed to aggregate email, calendars, contacts, and cloud storage into a single workspace. It functions as a multi-tenant SaaS application, supporting various protocols including IMAP/SMTP for email, CalDAV/CardDAV for scheduling and contacts, and WebDAV/S3 for file storage. The system emphasizes data ownership and privacy, allowing users to manage multiple email identities and storage volumes within isolated workspaces. The architecture follows a monorepo structure with a clear separation of concerns. The frontend (`apps/web`) is built on Next.js 16 with React 19, utilizing Server Actions for business logic and a Nitro-based worker (`apps/worker`) for background jobs like IMAP sync and email delivery. Data persistence is handled by PostgreSQL with Drizzle ORM, while Redis manages job queues and caching. The platform integrates with external providers via a strategy pattern, supporting services like Google Workspace, AWS SES, and various SMTP providers. Key components include a robust provider abstraction layer for pluggable email and storage backends, a centralized encryption vault for sensitive credentials, and a standardized Server Action wrapper for consistent error handling. The codebase demonstrates high craftsmanship in its sync logic and multi-tenancy implementation, though it carries some technical debt related to type safety and complex DAV/IMAP state management.
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.
This repository provides a comprehensive AI-assisted UI/UX design system toolkit, primarily packaged as a skill for AI coding assistants (Claude Code, Cursor, Windsurf, Copilot, etc.) and distributed via the 'ui-ux-pro-max-cli' npm package. Its core functionality includes a curated knowledge base of 79 UI styles, 192 product color palettes, 74 font pairings, 119 UX guidelines, 22 tech stacks, and 192 reasoning rules – all stored as structured CSV files. A BM25 search engine (implemented in Python) enables domain‑aware retrieval, while a design system generator aggregates search results and applies reasoning rules to output complete design system recommendations (colors, typography, style, layout patterns, motion, anti‑patterns). The gallery Next.js app provides a browsable, filterable interface for the style catalog. Architecturally, the project is a hybrid of data curation and application delivery. The canonical source of truth lives in `src/ui-ux-pro-max/`, which is synchronised to `cli/assets/` and `.claude/skills/` via a CI‑enforced sync script. It includes sub‑skills for brand management, slide/presentation generation, banner design, icon/logo generation, and UI styling (with shadcn/ui and Tailwind integration). The CLI tool installs these skills into the appropriate AI assistant configuration directories, with platform‑specific templates for 20+ assistants. Automated workflows refresh Google Fonts and Phosphor icon catalogs weekly, and a suite of Python tests validates data contracts, stack freshness, and search relevance. Despite its active maintenance and rich functionality, the codebase suffers from significant file duplication across three directory trees, hardcoded version pins for frameworks, and test brittleness tied to exact data row counts. The design system generator and search engine are well‑crafted and reusable, but the overall project is tightly coupled to its curated CSV schema and the ecosystem of AI coding assistants. It represents a mature, production‑grade toolkit for developers who want AI‑assisted design generation, but the heavy duplication and external API dependencies (Gemini, Atlas Cloud, MuAPI) introduce moderate technical drift risk.
Supermemory is a commercial-grade AI memory and context engine that provides persistent long-term memory for AI agents. The repository implements the client-side integration SDKs, an MCP (Model Context Protocol) server, a memory graph visualization component, and supporting infrastructure. In production, it connects to an external cloud API (api.supermemory.ai) that handles document ingestion, semantic search, user profiles, and knowledge graph construction. The codebase is organized as a monorepo with distinct packages for TypeScript/Python SDKs covering multiple AI frameworks (Vercel AI SDK, OpenAI, Mastra, Claude, etc.), a Cloudflare Workers-based MCP server with OAuth and widget UI, a ship-grade memory-graph React component with force-directed canvas rendering, and a comprehensive validation schema package. The architecture demonstrates strong engineering practices: strict Zod validation, middleware injection patterns, caching and deduplication logic, and thorough testing across languages. Notable skill is evident in the memory-graph canvas engine (viewport, simulation, spatial indexing, version chain visualization) and the shared memory-context injection utilities. The main downside is significant logic duplication across four Python SDK packages and their TypeScript counterparts, which increases maintenance risk. The repo is actively developed with CI/CD pipelines publishing to npm and PyPI.
KokonutUI is an open-source UI component library for modern React applications, specifically targeting Next.js projects with Tailwind CSS v4 and Motion (Framer Motion). The repository contains over 40 reusable, animated components distributed through a shadcn-style registry, allowing developers to copy-paste or install them via `npx shadcn@latest add @kokonutui/<name>`. The library covers backgrounds (beams, flow field, shape hero), buttons (attract, gradient, hold, particle, slide-text, social, switch, v0), cards (apple activity, bento grid, card flip, card stack, carousel, currency transfer, liquid glass, mouse effect, spotlight, tweet), inputs (avatar picker, file upload, loader, team selector), navigation (action search bar, morphic navbar, profile dropdown, smooth drawer, smooth tab, toolbar), AI-specific components (AI input search, AI loading, AI prompt, AI text loading, AI voice), and text effects (dynamic, glitch, matrix, scroll, shimmer, sliced, swoosh, type writer). The project also includes custom hooks (use-auto-resize-textarea, use-click-outside, use-copy-to-clipboard, use-debounce, use-file-input, use-intersection, use-mobile, use-tags) and a comprehensive documentation site powered by Fumadocs with MDX content. A build script generates registry JSON files and agent-facing resources (llms.txt, agent skills index). The codebase follows modern React patterns (compound components, asChild, controlled/uncontrolled state, composition over props) and includes extensive AI agent skills for component architecture, Next.js best practices, and React design patterns. While the library is functional and well-structured, it lacks tests and has a large dependency surface; it is also tightly coupled to Next.js and serves as a marketing funnel for a pro version.
This repository is a personal blog and portfolio website built with Astro, Tailwind CSS, and Markdoc. It features a home page with project showcases, a blog with individual posts, a projects page, and an RSS feed. The site includes a dark mode toggle, SEO metadata generation, and custom Markdoc components for embedding media. The architecture follows Astro's standard structure with pages, layouts, and components, and uses a custom Markdoc setup for content processing.
This is a Hugo theme for building personal digital gardens/static sites. It provides templates, styles, and scripts for a responsive multi-column layout with dark mode, newsletter integration, portfolio showcase, and social media links. The architecture follows Hugo's theme structure with layouts in /layouts, assets in /assets, and an example site for demonstration. Key entry points are the base template (_default/baseof.html) and section-specific templates (articles, portfolio, stack). Data flows involve rendering Hugo content (Markdown) via templates, consuming site config (menus, params), and optional data files (stack.json). External dependencies include Hugo (>=0.121.1), Tailwind CSS, and optional services like Google Analytics and newsletter providers (Buttondown, Substack, Revue).
Readme.so is a Next.js web application that provides an online editor for generating README.md files. Users can select from predefined sections, edit their content using a Monaco Editor (desktop) or textarea (mobile), reorder sections via drag-and-drop, and download the final markdown. The application state is managed in React and persisted to localStorage with debounced saving. The frontend uses TailwindCSS for styling and integrates libraries like dnd-kit for drag-and-drop and react-markdown for preview. The app is statically exported and deployed via GitHub Pages.
This is a modern Next.js 16 starter template using the App Router, designed to jumpstart full-stack web applications. It provides a production-ready monolith with authentication via NextAuth (GitHub provider), payment processing through Stripe subscriptions, and a PostgreSQL database layer using Drizzle ORM and Neon serverless. The application includes internationalization (i18n) with next-intl, dark mode theming, custom fonts, and standard SEO features like sitemap and robots.txt. The codebase demonstrates disciplined engineering with TypeScript, Zod environment validation, Biome linting, Husky git hooks, and both unit (Jest) and end-to-end (Playwright) testing. While functionally complete and well-structured, it is fundamentally a starter kit composed of framework boilerplate and standard integrations, without innovative or deeply reusable custom abstractions beyond what is typical for such templates.
Nextflux is a modern RSS reader client designed for the Miniflux server. It is a single-page application built with React 19, Vite 6, and TailwindCSS 4, featuring a three-pane layout for browsing feeds, articles, and reading content. The application emphasizes offline capabilities through IndexedDB storage via Dexie, allowing users to read feeds without an internet connection. The architecture employs a decentralized state management approach using Nanostores, with separate stores for authentication, settings, feeds, articles, and synchronization. Data persistence is handled through a repository pattern over Dexie, providing typed access to IndexedDB collections. The application synchronizes with the Miniflux server via a background sync service that handles incremental updates, conflict resolution, and optimistic UI updates. Additional features include a global audio player for media attachments, AI-powered article summarization, and extensive customization options through a settings panel. Notable reusable components include a utility library for class merging and helper functions, a dynamic font loading hook, and a custom hook for detecting reduced motion preferences. The UI is built upon a migrating component library (transitioning from HeroUI/Radix to @base-ui/react and then to a Luma/shadcn-based system), demonstrating a commitment to modern UI practices. The codebase exhibits strong modularity and separation of concerns, with clear boundaries between UI, state management, data access, and service layers.
Dante is a static site generator theme for Astro.js, designed for single-author blogs and portfolios. It provides a complete, production-ready setup with dark/light mode, responsive design, SEO metadata, RSS feed, sitemap, pagination, and a subscription form. The theme is built with Tailwind CSS v4 and uses Astro's content collections for Markdown-based blog posts, pages, and projects. Configuration is centralized in a single TypeScript file. The architecture follows Astro's SSG model with view transitions for a SPA-like experience. The codebase is well-structured, with reusable components and utility functions. It is a hybrid of a theme and a starter template, not a library or service.
This repository is a production-grade cross-platform mobile application scaffold built on uni-app x, Vue 3, and TypeScript. It provides a comprehensive UI component library (cool-ui) with over 50 components covering forms, layout, data display, feedback, navigation, and utilities, all designed for reuse across Web, Android, iOS, and mini-programs. The project includes a full demo app showcasing each component, template pages for e-commerce (shop, cart, address, product detail) and social features (posts, chat, user profile), as well as a settings and i18n system with 7 languages. Core architectural patterns include a reactive service layer with token-refresh support, a custom router with auth guards, a theme system (light/dark), a PassThrough prop pattern for deep component customization, and a plugin system for touch, locale, and device features. The code is well-structured with typed props, hooks, and clear separation of concerns, though it relies on a beta plugin (`@cool-vue/unix`) and extensive platform-specific conditionals (#ifdef) that may introduce future maintenance drift. The repository is primarily an application scaffold, not a data research project. It contains no notebooks, data pipelines, or ML components. Its value lies in being a ready-to-use starter for building multi-platform apps with a rich UI library and common business modules. While not groundbreaking, the code demonstrates solid engineering practices, good modularity, and attention to developer experience (auto-imports, TailwindCSS integration, AI-assisted translation scripts). The library's components are individually reusable and can be extracted with minimal effort, making it a practical resource for app developers targeting the uni-app ecosystem.
This repository contains a Tailwind CSS plugin that adds 3D transform capabilities. The plugin provides utility classes for 3D transformations (scale, rotate, translate on X, Y, Z axes) and 3D animations (bounce, spin, bounce-and-spin). It supports both modern CSS properties (rotate, scale, translate) and legacy transform syntax for backward compatibility. The architecture follows Tailwind's plugin pattern, with modular organization separating animations, utilities, and helper functions. The plugin integrates with Tailwind's configuration system to allow customization of values and works by registering utility classes and animations that generate appropriate CSS when processed by Tailwind.
Alumnet is a full-stack, AI-powered alumni exhibition and management system designed for school history museums. It consists of three workspaces: a touch-screen kiosk frontend (client) built with Vue 3, Three.js, and Tailwind CSS; an admin dashboard (admin) using Vue 3 and Element Plus; and a backend server (server) built with Express, TypeScript, PostgreSQL (with pgvector), and Qdrant for vector search. The system provides alumni CRUD, AI-powered natural language search via RAG, 3D galaxy visualization, timeline corridor, interactive message boards, video greetings, donation management, and comprehensive admin controls including content audit, backup/restore, and data import. It features JWT authentication with role-based access, privacy data masking, rate limiting, and a layered architecture (routes → services → repositories). The codebase includes extensive testing (unit, integration, property-based with fast-check) and is deployable via Docker Compose or PM2. While primarily an application, it incorporates data engineering patterns through its RAG pipeline and knowledge base management.
Papermark is an open-source document and data room sharing platform (DocSend alternative) built with Next.js, Prisma, and a modern SaaS stack. It provides secure document sharing with granular access controls (password, email verification, domain allow/deny lists, watermarking, screenshot protection), real-time analytics (page views, video playback, click tracking via Tinybird), and enterprise-grade features like virtual data rooms with folder hierarchies, group permissions, AI-powered document indexing and chat, signing agreements (Documenso integration), workflow automation, and Slack integration. The platform is monetized via Stripe subscriptions with tiered plans and includes a comprehensive billing/cancellation flow. The architecture is a full-stack Next.js application with a mix of Pages Router and App Router, using Prisma for PostgreSQL ORM, Redis for caching/rate limiting/job stores, Trigger.dev for background tasks, Tinybird for analytics pipes, and Vercel Blob/AWS S3 for file storage. Authentication supports NextAuth.js with passkeys, SAML SSO (via BoxyHQ Jackson), and OTP verification. The codebase is organized with a clear separation of enterprise features under an `ee/` directory, reusable UI components (shadcn/ui-based), and extensive SWR hooks for client-side data fetching. The repository demonstrates solid engineering practices with well-structured API routes, RBAC enforcement, and a rich set of utilities. However, it shows signs of technical drift: simultaneous use of Pages Router and App Router creates inconsistency, some API endpoints are large and monolithic, and there is duplication in folder management and export-visits logic. The rapid schema evolution (many Prisma migrations) indicates active development but also potential instability. Overall, it is a production-quality application with strong reusability in its UI components, i18n pattern, and utility libraries.
This repository is a static website for a Chinese-language educational course titled 'Deep Agents 实战' (Deep Agents in Action). It provides 16 chapters of technical content on building AI agents using LangChain and LangGraph, including text, video links, and downloadable PDFs. The site is built with Astro 6, Tailwind CSS 4, and TypeScript, and is deployed to GitHub Pages via GitHub Actions. The codebase is well-structured: content is authored in Markdown under `content/`, metadata is managed in `scripts/chapters.json`, and a preprocessing script injects frontmatter into the Astro content collection. Custom Astro components handle layout, navigation, theme toggling, and a responsive table of contents. The repository also includes CI/CD workflows for asset validation and cross-platform installation testing. While the primary purpose is educational content delivery, the build and content pipelines demonstrate reusable patterns for static site generation with Astro.
This repository contains the source code for a personal link-in-bio website (moure.dev) built with the Reflex Python web framework. It serves as both a live production site and a practical example for a 13-hour web development course. The application is a full-stack Python app with a static frontend (React/Reflex) and a Dockerized backend. It integrates multiple external APIs: Twitch (live status), Supabase (featured content), ConfigCat (feature flags), and Beehiiv (newsletter). The architecture follows a component-based design with reusable UI elements (link buttons, cards, navbar, footer) and a centralized state management pattern. The frontend is exported as static HTML/JS and hosted on Vercel, while the backend runs on Railway. The code is well-structured, uses modern Reflex with Radix UI, and includes deployment scripts and a GitHub Actions CI pipeline. It is primarily a learning resource and a functional personal site, not a generic library or framework.