Exosphere is a reliability runtime for AI agents, providing a state-based workflow orchestration platform. The system consists of three main components: a Python SDK (`exospherehost`) for defining nodes and execution graphs, a FastAPI state-manager backend that handles state transitions, retries, cron triggers, and secret encryption, and a Next.js dashboard for monitoring and managing workflows. The architecture follows a microservices-like pattern within a monorepo, with the SDK acting as a client library and the state-manager as the central orchestration engine. Key capabilities include dynamic graph execution, infinite parallel fanout/unite patterns, configurable retry policies (exponential, linear, fixed with jitter), signal-based state pruning and re-queuing, and a graph-level key-value store. The system relies on MongoDB for persistence and uses Beanie ODM. The codebase demonstrates solid engineering practices with well-structured controllers, middleware for request ID propagation and exception handling, and a comprehensive test suite, though some tests are incomplete or skipped. The project is in early beta (v0.0.3b1) with active development and monthly releases.
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.
Cursify is a Next.js application that serves as both a documentation site and a component library for custom cursor animations and background patterns. It provides over 30 cursor effects (e.g., fluid, neon, blob, fairy dust, glitch) and 12+ pattern animations (e.g., flowing dots, vertical bars, sliding ease), each with live previews, code snippets, and installation instructions. The architecture is a static Next.js site using the App Router, MDX for content, and a registry of reusable React components. The codebase is well-organized with separate directories for hooks, UI primitives, and registry components. It relies on several animation libraries (Framer Motion, react-spring, motion) and Radix UI for interactive elements. The primary data flows are static: MDX content is rendered server-side, and client-side interactivity is handled via React hooks and canvas/WebGL. There is no backend or API; the site is purely a documentation and showcase platform.
This repository is a Next.js static site that serves as the companion website for the 'Complete Intro to Web Dev v3' course by Brian Holt. It renders lesson content from Markdown files, provides interactive code editors via Klipse, and includes navigation between lessons. The architecture is a standard Next.js application with static generation at build time. The codebase is well-organized with clear separation of concerns: data loading logic in `data/lesson.js`, layout components in `components/`, and page routing in `pages/`. While the site is tailored to this specific course, the lesson loading module is a reusable pattern that could be extracted for other course sites. The project is actively maintained with recent commits and a CI/CD pipeline for deployment to GitHub Pages.
This is a production-oriented full-stack SaaS starter kit (not a data/research project). It is a monorepo template pairing a Next.js web app (landing page, auth flow, account dashboard, marketing sections) with a Flutter cross-platform app (iOS/Android/macOS/Windows/Linux/web) on top of a shared Supabase backend. The backend is a Postgres schema (users, customers, products, prices, subscriptions, invoices) protected by row-level security, plus Deno edge functions that orchestrate Stripe Checkout sessions and process Stripe webhooks. PostHog handles analytics on both frontends, Loops.so handles transactional email, and an optional Monero cryptocurrency payment variant can be toggled in via patch scripts, giving the template two billing backends.
SuperCoder is a local-first, open-source AI coding agent with a desktop application (Tauri + Rust + React) and a suite of backend services. The core agent (Rust crate) provides an LLM-driven loop with tool execution (file editing, bash, git, code search), subagent spawning, and an 'Auto' mode where an orchestrator LLM generates plans executed by worker agents. The desktop app offers a rich UI for agent interaction, diff review, file exploration, and permission management. A separate Go-based 'Context Engine' service indexes codebases into vector (Qdrant), graph (FalkorDB), and text stores, enabling semantic code search, dependency analysis, and automated PR review with risk scoring. The repository also includes a legacy v1 backend (Go) with workflow executors for Django/Flask/Next.js code generation and a workspace service for managing isolated development environments. While primarily an application, the context engine introduces data/research elements through its indexing pipelines, retrieval strategies, and code review analytics.
This repository implements an agentic crypto trading platform called AI Market Maker (AIMM). Despite the name, the code is not a low-latency market-making engine; it is a multi-agent hedge-fund-style trading stack that combines LLM-driven research agents with deterministic quant logic for backtesting, paper trading, and live trading. The core execution path is a LangGraph workflow: nine Tier-0 specialist agents (monetary, news, TA, on-chain, order flow, etc.) produce structured signals, a weighted arbitrator fuses them into trade intents, a Risk Guard vetoes dangerous proposals, and portfolio management routes execution through an OMS with an in-memory or SQLite ledger. The platform includes a FastAPI backend with REST and streaming endpoints, a Next.js/React dashboard, Docker deployment, Alembic migrations, CI, and a large test suite.
Materio is a free admin dashboard starter template built on Next.js 14 App Router, MUI v5, and Tailwind CSS, published by ThemeSelection. It ships as two parallel, functionally identical codebases: javascript-version/ and typescript-version/. Everything in the repo is static UI - hardcoded demo data, mock ApexCharts, placeholder auth forms - there is no API layer, database, or authentication logic. Its job is to be a polished starting point for admin applications, and it executes that role well: an extensive per-component MUI theme override system, a custom collapsible vertical menu subsystem, and a cookie-persisted settings context for dark/light mode. Architecturally it follows Next.js App Router conventions: root layout (app/layout.jsx), a dashboard layout that wraps the VerticalLayout shell (navigation, navbar, footer), and a blank layout for login/register/error pages. The most interesting engineering lives in src/@menu (a self-contained vertical navigation layer with context-driven collapse/expand and breakpoint behavior), src/@core/theme (dozens of isolated MUI component overrides), and a few genuinely reusable React hooks (useObjectCookie, useImageVariant). All dashboard data is fabricated; adopters must wire real data and backend logic themselves. The template is actively maintained (last commit March 2026, one open issue, automated issue triage workflows). Drift risks are version pinning to Next.js 14 / MUI v5.15 and the maintenance cost of keeping JS and TS variants in sync.
Elysia is an open-source agentic platform that uses a decision tree architecture to dynamically select and execute tools for searching and reasoning over vector databases (Weaviate). The core is a `Tree` class that maintains conversation history, an environment of retrieved objects, and a decision loop: at each step, an LLM (via DSPy) chooses which tool to call based on the current state and user goal. Built-in tools include hybrid/semantic query, aggregate, summarization, visualisation, and linear regression; custom tools can be added via a `@tool` decorator or by subclassing `Tool`. The system preprocesses Weaviate collections to generate LLM-created summaries, field mappings, and statistics, enabling adaptive query formulation. The platform includes a full-stack web application: a FastAPI backend with WebSocket endpoints for real-time query execution, and a built Next.js frontend (served as static files) offering a UI for conversations, collection management, tree visualisation (React Flow), and feedback collection. The backend manages multi-user and multi-conversation state via `UserManager`/`TreeManager`, persists trees to Weaviate, encrypts API keys, and supports feedback-driven few-shot learning. A CLI entry point (`elysia start`) launches the API server.
This repository is a Payload CMS authentication plugin (payload-auth-plugin) that provides OAuth2, OIDC, password, and passkey authentication strategies. It is designed to be used with Payload CMS v3+ and integrates deeply with Payload's admin panel and frontend via custom API endpoints, collection field injection, and a client-side library. The plugin supports multiple providers (Google, GitHub, Apple, etc.) via a clean provider factory pattern and manages its own session cookies, credential hashing (PBKDF2), and account linking. The architecture is a plugin that hooks into Payload's lifecycle, extending the CMS with authentication endpoints and database collections. The example application (examples/with-website/) demonstrates a full Payload CMS + Next.js website with admin and public authentication flows. Despite being pre-1.0, the codebase exhibits solid engineering patterns: strategy pattern for endpoint registration, collection helper functions that merge user-defined configs, and a reusable AuthClient class for browser-side authentication. However, it lacks automated tests, has several FIXME comments in passkey and password protocols, and is tightly coupled to Payload's internal DB and cookie mechanisms, which introduces technical drift risk as Payload evolves. The plugin is actively maintained with frequent releases and a changelog documenting 50+ versions.
This repository is a polyglot web converter application built with Next.js. It provides a large collection of code transformations (e.g., JSON to TypeScript, SVG to JSX, GraphQL to Resolvers, HTML to Pug, etc.) in a user-friendly two-pane editor interface. The architecture is a monolith with each transformation implemented as a separate page under `pages/`, all sharing a common `ConversionPanel` component that manages the input/output editors, web workers for heavy processing, and server-side API routes for a few transforms that require Node.js native modules. External dependencies include numerous npm libraries for the actual conversion logic (e.g., `json_typegen_wasm`, `@svgr/core`, `graphql-codegen`), the Monaco editor for code editing, and the evergreen-ui component library for the UI. The application uses web workers extensively (via a custom `workerWrapper` utility) to offload CPU-intensive conversions off the main thread, ensuring a responsive UI. Data flows from the user's input editor, through a transformer function (which may call a web worker or an API endpoint), and into the output editor, with results automatically formatted by Prettier. The codebase is well-structured with a consistent pattern for each converter, making it straightforward to add new transformations.
Llama Tutor is an open-source AI personal tutor built as a Next.js application. It allows users to enter a topic and select an education level (elementary to graduate), then uses Exa search to fetch relevant web content and Together AI (Qwen2.5-7B-Instruct-Turbo) to generate a personalized lesson in streaming markdown. The application features conversational follow-ups, source display, and rate limiting via Upstash Redis. It integrates Helicone for observability and Plausible for analytics. The codebase is a monolith with App Router, client-side state, and edge-deployed API routes. The architecture is straightforward: the main page orchestrates chat and source retrieval, relying on a custom streaming utility for Together AI responses. While the components are functional and well-structured for a demo, only the streaming utility stands out as a potentially reusable pattern for other AI-powered applications.
This repository is a production-grade Next.js application (v14 with App Router) that serves as the official web eco-design best practices reference (Référentiel d'écoconception web) by GreenIT.fr. It provides a multi-language (French, English, Spanish) content site with a headless CMS (TinaCMS) for editing, a REST API for programmatic access, and a client-side search (Pagefind). The core content is a structured collection of 115+ best practice sheets (fiches) with frontmatter metadata including lifecycle stages, environmental impact, validation rules, and version tracking. The site is deployed on Vercel and uses MongoDB for TinaCMS indexing. While the primary purpose is an application, the underlying content is a well-structured, versioned dataset that could be used independently for compliance checking or analytical purposes, giving the repo a hybrid character. The application code is well-organized with reusable patterns for MDX rendering, glossary tooltips, content validation, and multi-referential configuration.
This repository is a personal portfolio website built with Next.js 14, React, and TypeScript. It features a blog section with MDX-powered articles sourced via Contentlayer, a projects showcase, and a responsive UI built with Chakra UI. The application uses static site generation (SSG) for optimal performance and includes client-side search functionality for articles and projects. Key architectural elements include the Next.js app router, file-based routing, and a modular component structure separating layouts, UI components, and data utilities. The site implements modern web development practices such as dark/light theme support, image optimization with blur placeholders, analytics integration (Vercel and Google Analytics), and error monitoring via Highlight. Content is sourced from MDX files in the data/articles directory and static JSON files for projects and publications. The build process leverages Next.js's incremental static regeneration (ISR) capabilities through Contentlayer, ensuring content updates without full rebuilds. Notable reusable components include a custom BlurImage component that enhances perceived performance by showing a blurred placeholder during image loading, and a Callout component for styling informational, warning, and error messages in MDX content. Both components are decoupled from specific business logic and demonstrate solid encapsulation patterns suitable for extraction into other projects.
This repository is the full-stack personal website of Max Stoiber (mxstbr.com), built with Next.js 16, TailwindCSS, and TypeScript. It serves a dual role: a public-facing blog and digital garden, and a private family productivity suite called 'MaxOS' that simulates a Windows 98 desktop environment. The public side includes MDX blog posts, Hashnode-synced notes, an RSS feed, and an investing page. The private side is a full-featured operating system shell with iframe-based apps: a calendar (with events stored in Redis), a finance portfolio tracker (pulling from Tiingo), a reminder system, a todo list, and a sophisticated chore management system (Chores2) for tracking kids' chores, rewards, and completions. The Chores2 subsystem is the most architecturally rich part of the codebase. It uses a layered domain-driven design with types, domain logic, commands, a service layer, a repository (with both in-memory and Redis implementations using compare-and-set transactions), MCP tool definitions for AI integration, and a notification outbox pattern for reliable Telegram delivery. The system supports time-window-based chore scheduling, period bonuses, approval workflows, and undo. It was recently rebuilt from a legacy version, with all features documented and verified in design docs. The codebase also integrates AI heavily: a Clippy chat assistant (powered by OpenAI) accessible via web and Telegram, and an MCP server that exposes tools for calendar, chores, and finance, enabling ChatGPT and other AI agents to read and mutate family data. The architecture is modern, with server actions, streaming, and Redis-backed state. However, the repo shows signs of being a single-developer project with some duplication (two active chore board UIs) and hardcoded secrets (parental PIN).
EmailThing is a self-hosted email service providing web (PWA), CLI, and API interfaces for sending and receiving emails with custom domains. The system consists of a Bun-based backend API using PostgreSQL with Drizzle ORM, a React/Next.js PWA with Dexie IndexedDB for offline capabilities, and a CLI tool for management. It handles email storage via S3, authentication with JWT/sessions and passkeys, rate limiting with Redis, and integrates with external email services for sending while using Cloudflare Workers for reception. The architecture follows a monorepo pattern with clear separation: apps/api (backend server), apps/pwa (frontend interface), apps/cli (terminal tool), and shared packages for database, constants, and SDK. Key features include multi-user mailbox management, aliases, custom domain support, team collaboration, end-to-end encryption for sensitive data, and real-time synchronization between client and server. The system emphasizes user control over email infrastructure while providing modern web application experiences.
This repository is a comprehensive React workshop containing three main applications: a vacation search SPA, an e-commerce store using React Router's data APIs (loaders/actions), and a Next.js app demonstrating React Server Components. It also includes extensive course materials covering React fundamentals, advanced hooks, form abstractions, and performance optimization. The applications showcase modern React patterns including context API, custom hooks, component composition, and data fetching evolution from useEffect to React Query to loader functions.
This is a standalone web UI for Midjourney image generation, built as a Next.js 14 application. It provides a prompt editor, image preview with upscale/variant/reroll actions, a task history list, and settings to configure a midjourney-proxy service. The app can run standalone or be embedded as a LobeChat plugin via an iframe. It uses React with Zustand for state management, SWR for data fetching, Immer for immutable state updates, and antd-style for theming. The backend consists of two API routes: one proxies requests to the midjourney-proxy service, and another uploads images to Imgur. The codebase is well-structured with clean separation of concerns, i18n support, and responsive design. While the application is functionally straightforward, it demonstrates solid engineering practices including pure reducer functions with unit tests, typed state management, and a modular layout system.
This repository is a vast curated collection of over 100 open-source AI agent application templates and tutorials, spanning multiple frameworks (Agno, Google ADK, OpenAI SDK, LangGraph, CopilotKit, CrewAI) and deployment patterns (Streamlit, Next.js, FastAPI, CLI). It serves as a living portfolio of AI agent patterns: single-agent assistants, multi-agent teams, generative UI (CopilotKit + AG-UI), RAG pipelines with various vector stores (Qdrant, Chroma, LanceDB, FAISS), voice agents, always-on scheduled agents, and agent skills (code analysis, dependency health). The architecture is a monorepo of independent sub-projects, each with its own requirements, entry point, and often a README. External dependencies are heavy: nearly every app requires API keys for LLMs (OpenAI, Google, Groq, Together) and tools (Tavily, Firecrawl, SerpAPI, E2B), plus optional services (PostgreSQL, Qdrant, ElevenLabs). While the codebase is not a single integrated application, it provides a rich set of reference implementations for developers building AI agents.
PrimeReact is a comprehensive React UI component library providing over 80 components including forms, data tables, overlays, menus, charts, and more. The repository also contains its official documentation website built with Next.js, featuring live demos, code snippets, accessibility guides, and theming documentation for both styled and unstyled (Tailwind) modes. The library follows a consistent architecture: each component extends a shared ComponentBase that defines default props, CSS classes, and pass-through theming support. It includes a custom hooks library, SVG icon set, and utility modules. However, the project is no longer under active development; only security fixes are published, with all new features and bug fixes moving to the PrimeUI fork. This has led to a growing divergence and a backlog of unresolved issues. The codebase shows signs of technical drift such as aging dependencies (Next.js 12), deprecated patterns, and extensive duplication in documentation and style definitions.