This repository is the frontend client suite for daily.dev, a developer-focused content and community platform. It is structured as a monorepo using pnpm workspaces, containing three primary packages: `packages/webapp` (Next.js application), `packages/extension` (browser extension), and `packages/shared` (shared UI components, hooks, and GraphQL logic). The system aggregates developer content, manages user profiles and communities (Squads), handles monetization (Plus subscriptions, Cores), and provides career opportunities. Key entry points include the Next.js pages router in `packages/webapp/pages` and the extension background/content scripts in `packages/extension/src`. Data flows primarily through GraphQL queries to an external `daily-api` service, with client-side state managed via TanStack Query and Jotai. External dependencies include Paddle for payments, GrowthBook for feature flags, and Cloudinary for media. The architecture emphasizes code sharing and consistency across platforms, with `packages/shared` serving as the core library for UI primitives, business logic, and API abstractions. The webapp utilizes Next.js for server-side rendering and static generation, while the extension leverages web extension APIs for browser integration. The codebase demonstrates strong engineering practices with strict TypeScript typing, comprehensive testing (Jest, Playwright), and a robust design system. However, the heavy reliance on feature flags and the use of a non-LTS Node version (v24.18) introduce some technical debt and potential compatibility risks. The platform supports multiple user journeys including content consumption, community engagement, and monetization. It features a sophisticated feed system with infinite scrolling, personalized recommendations, and content preferences. The extension provides companion features like new tab pages and frame embedding, requiring careful synchronization with the web app's authentication and permission models. The codebase is well-structured but complex, with deep nesting of contexts and modals that could impact maintainability if not carefully managed.
This repository is a production-grade React calendar component library (`@ilamy/calendar`) designed as a lightweight (~13 KB gzipped) replacement for FullCalendar. It provides month, week, day, year, and agenda views with drag-and-drop, resource scheduling, RFC 5545 recurring events, iCal export, and internationalization. The core ships no CSS and relies on Tailwind CSS v4 with shadcn/ui tokens, making it themeable and tree-shakeable. Architecturally, the library follows a plugin-first pattern: the core implements a pluggable kernel (`IlamyPlugin` interface) that accepts opt-in plugins for recurrence, agenda, and drag-to-create. Each plugin contributes views, event transformations, mutation scopes, and UI slots through a runtime composer. The state management uses a single `CalendarProvider` context that composes four engine slices (config, navigation, data, interaction). The view system is built on two grid primitives (vertical-grid for time-based layouts, horizontal-grid for date-based layouts) that are shared across all views and test harnesses. The codebase demonstrates strong engineering discipline: a huge unit test suite (995+ tests) with regression pinning against issue numbers, deterministic Playwright E2E tests, a CI pipeline with lint/build/type-check/test gates, and agent-driven code review skills. However, there is some duplication of UI primitives between packages, and the dependency on a custom dayjs wrapper for timezone handling introduces fragility. The library is actively maintained with frequent releases and detailed changelogs.
This is the monorepo for Supabase, the open-source Firebase alternative built on PostgreSQL. The repository contains the complete Supabase platform including: (1) Studio - a Next.js-based management dashboard for database, auth, storage, and edge functions, (2) Docs - a Next.js documentation site with MDX content and search, (3) WWW - the main marketing website, (4) UI packages - shared React component libraries built on Radix UI and Tailwind CSS, (5) pg-meta - a TypeScript library for PostgreSQL metadata introspection, (6) ai-commands - AI/LLM integration tools, (7) Docker configurations for self-hosted deployments, and (8) numerous example applications demonstrating Supabase integrations. The architecture is a pnpm monorepo using Turbo for build orchestration. The codebase demonstrates sophisticated engineering patterns including: a custom SQL query builder with branded types for safe SQL composition (pg-meta), a comprehensive component library with design system tokens, real-time features via WebSockets, row-level security policy management, and a multi-tenant organization/project structure. The repository is actively maintained with recent commits and has strong community engagement (105k+ stars).
This repository implements a self-hosted deployment platform alternative to services like Vercel or Netlify. It enables users to deploy GitHub repositories with zero-downtime updates, instant rollback, and preview deployments for branches. The platform provides team-based access control, custom domain support with automatic Let's Encrypt SSL, storage provisioning (databases/volumes), and real-time log aggregation via Loki. Built with FastAPI, SQLAlchemy, and ARQ for background jobs, the architecture separates concerns into routers, services, models, utilities, and workers. Infrastructure is orchestrated via Docker Compose, including Traefik for routing, PostgreSQL for primary data, Redis for caching/job queue, and Loki/Alloy for logs. Key entry points include the main FastAPI app, API routers for auth/project/team/admin, and worker entrypoints for ARQ jobs and deployment monitoring.
SyntaxUI is a comprehensive documentation and showcase application built with Next.js 15, designed to display a library of pre-built React UI components. The application serves as both a marketing site and a functional reference for developers, allowing them to browse components, view live previews, and copy source code directly. It leverages the Next.js App Router for routing and server-side rendering, with MDX files used extensively for documentation content. The architecture is monolithic, centered around a static site generation approach with client-side interactivity for features like search and component previews. The core functionality revolves around displaying UI components categorized into buttons, loaders, text effects, and layout blocks. It integrates Tailwind CSS for styling, Framer Motion for animations, and Lucide React for iconography. The site includes a custom client-side search implementation using FlexSearch, which indexes the MDX documentation at build time. It also features dynamic elements like a GitHub stars counter and a Pro banner, managed via Zustand stores. The codebase is structured to separate the showcase components (in `src/showcase`) from the documentation pages (in `src/app/(docs)`), facilitating easy addition of new components. From a code quality perspective, the repository demonstrates strong engineering practices. It uses TypeScript throughout, ensuring type safety for components and utilities. The project utilizes modern Next.js features, including server actions for file reading and custom webpack loaders for search indexing. The separation of concerns is clear, with reusable UI primitives (like `ComponentPreview`) abstracted away from the specific component showcases. The documentation is generated from MDX, allowing for rich content embedding alongside code examples. The repository is actively maintained, evidenced by recent commits and a low number of open issues. It keeps pace with the ecosystem, utilizing the latest stable versions of Next.js and Tailwind CSS. There is minimal technical debt, with no deprecated APIs or outdated dependencies visible in the manifest. The code is clean, well-organized, and follows a consistent pattern, making it a valuable resource for engineers looking to build documentation sites or component libraries.
Dillinger is a cloud-enabled, online Markdown editor with live preview, export to Markdown, HTML, and PDF, and synchronization with cloud storage services including GitHub, Dropbox, Google Drive, OneDrive, and Bitbucket. Built with Next.js 14 (App Router), the application uses Monaco Editor for editing, Zustand for client-side state management with localStorage persistence, and markdown-it with a rich plugin chain for rendering. It features a modular architecture with API routes for OAuth flows and file operations per cloud provider, a versioned public REST API (v1) for rendering and export, and separate packages for a CLI tool and an MCP server for LLM integration. The codebase is well-organized with clear component separation (editor, preview, sidebar, modals, UI primitives), custom hooks per integration, and comprehensive unit and E2E test coverage. Auxiliary agent/skill files and design system CSVs exist in the repository but are development tools, not part of the application runtime.
Fuwari is a static blog template built with Astro and Tailwind CSS. It generates static HTML from Markdown content with features like light/dark mode, Pagefind-based search, responsive design, and customizable themes. The architecture uses Astro's component-based system with Svelte for interactive elements, Swup for page transitions, and Expressive Code for enhanced code blocks. Content is sourced from Markdown files in src/content/ and processed at build time to generate static assets. Key entry points include page routing files (.astro) and API routes for RSS/robots.txt. The template demonstrates strong engineering practices in its modular component design, effective use of Astro's content collections, and thoughtful implementation of UI interactions.
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.
Epicenter is a monorepo platform for building local-first, privacy-focused productivity applications with optional cloud sync. It encompasses a suite of apps including Honeycrisp (notes with Yjs CRDT sync), Whispering (voice transcription/dictation with local and cloud providers), Matter (typed markdown vaults with SQLite projection), Local Mail (Gmail mirror with offline triage), Local Books (QuickBooks mirror with CLI tools), Vocab (AI language tutor), Skills (agent instruction management), and the Epicenter desktop host (Tauri + Bun sidecar). The shared platform provides a CRDT-based data layer (Yjs with Durable Object authority), portable blob storage (IndexedDB, OPFS, S3), an OAuth/infrastructure-agnostic auth system, an agent loop framework with tool catalogs, and a server framework built on Hono for Cloudflare Workers or Bun. The architecture emphasizes offline-first, typed error handling (Result/defineErrors pattern), compile-time platform seams (browser/Tauri/desktop-host), and rigorous ADR-driven design with evidence benchmarks.
Intent UI is a copy-paste accessible React component library built on React Aria Components and styled with Tailwind CSS v4. It follows the shadcn/ui distribution model: components are installed via CLI (`npx shadcn@latest add @intentui/<component>`) from a registry served by the included Next.js documentation site. The repository contains over 80 UI components (buttons, forms, overlays, charts, navigation, layouts, etc.), each with multiple usage examples and comprehensive MDX documentation. The architecture is a Next.js App Router application that also functions as the component registry host, with custom build scripts generating registry JSON, icon metadata, and LLM-friendly documentation exports. External dependencies include React Aria Components for accessibility, Recharts for charts, motion for animations, sonner for toasts, and tailwind-variants for styling variants. The library is monetized through sponsor tiers and premium design assets, but the core components are MIT-licensed.
Cal.diy is a fully open-source, MIT-licensed fork of Cal.com, providing a self-hostable scheduling platform. It is a large monorepo containing a Next.js web application (apps/web) for booking pages, settings, and admin, a NestJS API (apps/api/v2) for platform REST endpoints, and extensive packages for business logic (packages/features), integrations (packages/app-store with 50+ apps), embeddable booking widgets (packages/embeds), and reusable React atoms (packages/platform/atoms). The architecture uses tRPC for client-server communication, Prisma ORM with PostgreSQL, Redis caching, and a custom dependency injection system (ioctopus) alongside NestJS DI. Key patterns include a tasker abstraction for async/sync background jobs (webhooks, emails, calendar sync), a versioned webhook payload builder factory, repository pattern over Prisma, and a consistent app-store integration structure. The platform exposes a public API with OAuth2, webhooks, and embeddable components for third-party developers. The codebase is actively maintained with frequent schema migrations and CI/CD pipelines, but exhibits some technical drift due to dual API surfaces (tRPC vs REST), stub implementations for enterprise features, and generated files that require regeneration.
Onlook is a browser-based visual editor for building and modifying Next.js + Tailwind CSS websites. It provides a Figma-like canvas where users can directly manipulate React components, with changes written back to source code via AST-based transformation. The application integrates an AI chat assistant that can generate code, edit files, and run terminal commands through a set of well-defined tools (e.g., search-replace, file edit, bash). The monorepo architecture separates concerns into packages for AI agents, code parsing, font management, UI components, database access (Drizzle + Supabase), git operations, and sandbox management (CodeSandbox). It also includes a complete billing system (Stripe), GitHub integration for project import, custom domain management, and a publish/deployment pipeline. The codebase demonstrates strong engineering practices with type-safe tRPC APIs, MobX state management in the editor, extensive use of Radix UI primitives, and a consistent monorepo toolchain (Bun workspaces, ESLint, Prettier). While the editor engine is somewhat monolithic, individual packages like the AST parser, font helpers, and utility library are well-isolated and testable.
BlazorBlueprint is a comprehensive Blazor UI component library inspired by shadcn/ui, providing over 112 styled components and 28 headless primitives. It targets .NET 8 across Server, WebAssembly, and Auto render modes, with full accessibility (ARIA, keyboard navigation), theming via CSS custom properties (compatible with shadcn CSS variables), and zero Tailwind/Node setup. The library is split into two layers: Primitives (headless, behavioral components with focus management, positioning, and portal services) and Components (styled, ready-to-use widgets like DataGrid, charts, forms, dialogs, and navigation). It ships with four icon libraries (5,200+ icons) and 11 chart types via Apache ECharts. The architecture emphasizes composability through cascading contexts, a consistent form-field pattern, and a utility-first approach with the ClassNames.cn helper for Tailwind class merging. The codebase demonstrates strong engineering practices: extensive use of generics, expression trees for filtering, JS interop with guarded disposal, and a localization system with 200+ string keys. However, the large API surface, heavy JS interop, and limited test coverage (only a few unit tests for DataGrid and hierarchy utilities) present maintenance risks.
WhatsApp Contact Sync is a web application that synchronizes profile pictures from WhatsApp to Google Contacts. The system uses a client-server architecture with a Vue.js 3 frontend and Node.js/Express.js backend. Users authenticate with WhatsApp via QR code scanning and with Google via OAuth, then the backend matches contacts by phone number (handling international format variations) and transfers profile pictures while respecting Google's API rate limits. The application features real-time progress updates via WebSocket, configurable sync options (manual/automatic), and a contribution-based access model to support server costs.
Another Graph Editor is an interactive web application for visualizing and manipulating graphs, designed with competitive programming in mind. Built with React, TypeScript, Tailwind CSS, and HTML Canvas, it allows users to input graphs in various formats (edge lists, parent-child arrays, Leetcode-style) and visualize them with multiple layout options (force-directed, tree, bipartite, grid). The application implements numerous graph algorithms for visualization including connected components, bridges and cut vertices, biconnected components, and minimum spanning trees. Users can interact with the graph through drawing, coloring, and node/edge manipulation, with support for multiple test cases and export to PNG/SVG formats.
Flowbite is a production-grade UI component library built on top of Tailwind CSS. It provides a comprehensive set of interactive, accessible components (modals, dropdowns, tooltips, carousels, datepickers, etc.) that are initialized via HTML data attributes and backed by a lightweight JavaScript runtime. The library is distributed as an npm package with multiple entry points (ESM, CJS, UMD, Turbo, Phoenix) and includes a Tailwind CSS plugin that injects base styles for forms, tooltips, charts, and third-party integrations. The repository also hosts an extensive Hugo-based documentation site with live examples, framework integration guides (React, Vue, Angular, Laravel, Django, etc.), and a theming system with five pre-built themes (default, minimal, enterprise, playful, mono). The architecture follows a consistent component pattern: each component is a class with `init()`, `destroy()`, and static `init*()` methods that scan the DOM for data attributes. A global `Instances` singleton manages all component instances by ID, supporting override and random ID generation. The library uses Popper.js for positioning dropdowns, tooltips, and popovers, and relies on an external `flowbite-datepicker` for datepicker functionality. The Tailwind plugin (`plugin.js`) uses `plugin.withOptions` to conditionally add base styles and component classes, and the CSS theming system leverages CSS custom properties for colors, fonts, radii, and shadows with dark mode support. While the library is well-structured and actively maintained, its large surface area (30+ components) and extensive documentation create maintenance overhead. The integration guides for 20+ frameworks are prone to drift, and the inline SVG icons and hardcoded Tailwind classes in documentation examples require careful version alignment. The codebase demonstrates solid engineering practices with TypeScript, Webpack builds, and consistent patterns, making it a reliable choice for projects needing a Tailwind CSS component library with JavaScript interactivity.
Pterodactyl Panel is a production game-server management control panel. It manages a fleet of game servers (Minecraft, Source Engine, Rust, voice servers, etc.) running in Docker on remote nodes, coordinated by the companion Wings daemon. The PHP/Laravel backend provides a session-based admin UI, a JSON:API-style application API for provisioning, a permission-scoped client API for end users, and a remote API used by Wings for server installation, transfer, backup status, and SFTP authentication. The React/TypeScript frontend handles the modern client experience—console, file manager, databases, backups, schedules, network allocations, account management, and 2FA—while the admin area remains classic Blade/jQuery views. Data flows from MySQL/MariaDB through Eloquent repositories and service classes, then to Wings over HTTP via Guzzle; Redis is used for queues, cache, and sessions, and optional anonymous telemetry is collected. Architecturally this is a Laravel monolith with a clean layered separation: FormRequest validation, service classes, Eloquent repositories behind interfaces, Fractal transformers, event/observer hooks, and a sophisticated activity-logging subsystem. The frontend is organized into reusable components, custom hooks, and pure utility functions, many of which are isolated enough to lift into other projects. The codebase is mature and actively maintained with CI, integration tests, and security patch releases, but it carries visible technical debt: a dual UI stack (Blade plus React), older React 16 tooling (easy-peasy v4, react-hot-loader), 190+ migrations spanning a decade, and a few deprecated models/fields. The repository is clearly an application, not a data/research project; although it stores substantial operational data, its purpose is real-time system control rather than analysis.
Bot Studio is a Next.js-based web application designed for testing and managing OpenAI models through an interactive chat interface. The application allows users to configure API credentials, manage files for fine-tuning, create and monitor fine-tuning jobs, list and delete custom models, and interact with multiple chat windows to test model responses with configurable parameters. The architecture follows a modular approach with React contexts for global state (OpenAI configuration), Zustand stores for domain-specific state (chats, files, fine-tunes, models), and React Query for data fetching and synchronization with the OpenAI API. The user interface is built using Tailwind CSS and Headless UI, with a collection of custom, reusable components for forms, buttons, modals, and toast notifications. Key features include streaming responses from the OpenAI API via a custom hook, file upload/download utilities, and a responsive layout with a persistent navigation sidebar. The application demonstrates strong engineering practices through its use of TypeScript, strict linting, and well-encapsulated components. Several components, such as the toast notification system, the OpenAI streaming hook, and the form input components, are designed with reusability in mind and could be extracted for use in other projects with minimal modification. The codebase is actively maintained and shows no significant signs of technical debt or dependency decay.
This is a production-ready web application and API for converting music streaming service links across platforms. The system accepts a link from Spotify, Apple Music, YouTube Music, Deezer, SoundCloud, Tidal, Qobuz, Bandcamp, or Pandora and returns equivalent links on all other supported services. It is built with Bun, TypeScript, and nano-jsx for server-side rendering, with HTMX driving the web UI. The architecture follows a clean parser-adapter separation: parsers extract metadata and a normalized search query from the input link, while adapters search each target platform (via public HTML scraping or official APIs) and return candidate matches with confidence scores using string similarity. A notable implementation detail is the Spotify adapter, which circumvents API restrictions by extracting a TOTP-based anonymous access token from the Spotify web player JavaScript bundle—a clever workaround that avoids requiring a premium developer account. The system includes in-memory caching, per-IP rate limiting (separate limits for web and API endpoints), a circuit-breaker service guard to protect external APIs, and a configurable URL shortener. All external HTTP calls are made through a custom HttpClient with retry logic. Tests cover integration scenarios with mocked snapshots.
EasyInvoicePDF is a free, open-source, browser-based invoice generator that creates PDF invoices with live preview, no sign-up required, and no ads. Built with Next.js (App Router), React 19, TypeScript, Tailwind CSS, and shadcn/ui, it runs entirely client-side for the public editor—invoice data stays in localStorage and is never uploaded to a server. The application supports 10 languages, 120+ currencies, two PDF templates (default and Stripe-inspired), QR codes, multi-page PDFs, and shareable compressed URLs. A private server-side API (Bearer token + Upstash rate-limited) handles monthly recurring invoice generation via Trigger.dev cron, uploading PDFs to Google Drive, emailing via Resend, and sending Telegram notifications. The codebase also includes extensive SEO landing pages, a changelog, a founder page, and comprehensive testing (Vitest unit tests, Playwright e2e with PDF screenshot baselines). Architecture: The app uses two root layouts—unprefixed English-only routes (/) and locale-prefixed routes (/[locale]) for i18n via next-intl. The main invoice form is a large client component with react-hook-form and Zod validation, debounced autosave, and template/language switching. PDF rendering uses @react-pdf/renderer on the client for live preview and on the server for automation. External dependencies include Upstash Redis (rate limiting, queue), Resend (email), Google Drive (archive), Telegram (notifications), Sentry (error tracking), Umami (analytics), and Trigger.dev (scheduled tasks). The repository also contains a rich ecosystem of agent skills (Vercel React best practices, composition patterns, SEO audit, etc.) used in development workflows. Key data flows: User fills form → state stored in localStorage and optionally shared via compressed URL → PDF preview rendered client-side via @react-pdf/renderer → download or share. For monthly automation: Trigger.dev cron triggers server-side PDF generation → upload to Google Drive → email via Resend → Telegram notification. The backend API also supports a preview endpoint for sample PDFs and a Telegram webhook for on-demand generation.