dyad

Dyad abstracts multiple AI providers (OpenAI, Anthropic, Google Gemini, DeepSeek, Qwen, local Ollama) through a unified Language Model Provider System that handles authentication, request formatting, and streaming response parsing. The system uses provider-specific API clients and normalizes outputs to a common message format, enabling users to switch models mid-project without code changes. Chat streaming is implemented via IPC channels that pipe token-by-token responses from the main process to the renderer, maintaining real-time UI updates while keeping API credentials isolated in the secure main process.

Dyad implements a Codebase Context Extraction system that parses the user's project structure, identifies relevant files, and injects them into the LLM prompt as context. The system uses file tree traversal, language-specific AST parsing (via tree-sitter or regex patterns), and semantic relevance scoring to select the most important code snippets. This context is managed through a token-counting mechanism that respects model context windows, automatically truncating or summarizing files when approaching limits. The generated code is then parsed via a custom Markdown Parser that extracts code blocks and applies them via Search and Replace Processing, which uses fuzzy matching to handle indentation and formatting variations.

Dyad implements a Search and Replace Processing system that applies AI-generated code changes to files using fuzzy matching and intelligent fallback strategies. The system first attempts exact-match replacement (matching whitespace and indentation precisely), then falls back to fuzzy matching (ignoring minor whitespace differences), and finally falls back to appending the code to the file if no match is found. This multi-stage approach handles variations in indentation, line endings, and formatting that are common when AI generates code. The system also tracks which replacements succeeded and which failed, providing feedback to the user. For complex changes, the system can fall back to full-file replacement, replacing the entire file with the AI-generated version.

Dyad is implemented as an Electron desktop application using a three-process security model: Main Process (handles app lifecycle, IPC routing, file I/O, API credentials), Preload Process (security bridge with whitelisted IPC channels), and Renderer Process (UI, chat interface, code editor). All cross-process communication flows through a secure IPC channel registry defined in the Preload script, preventing the renderer from directly accessing sensitive operations. The Main Process runs with full system access and handles all API calls, file operations, and external integrations, while the Renderer Process is sandboxed and can only communicate via whitelisted IPC channels. This architecture ensures that API credentials, file system access, and external service integrations are isolated from the renderer, preventing malicious code in generated applications from accessing sensitive data.

Dyad implements a Data Persistence system using SQLite to store application state, chat history, project metadata, and snapshots. The system uses Jotai for in-memory global state management and persists changes to SQLite on disk, enabling recovery after application crashes or restarts. Snapshots are created at key points (after AI generation, before major changes) and include the full application state (files, settings, chat history). The system also implements a backup mechanism that periodically saves the SQLite database to a backup location, protecting against data loss. State is organized into tables (projects, chats, snapshots, settings) with relationships that enable querying and filtering.

Dyad implements integrations with Supabase (PostgreSQL + authentication + real-time) and Neon (serverless PostgreSQL) to enable AI-generated applications to connect to production databases. The system stores database credentials securely in the Main Process (never exposed to the Renderer), provides UI for configuring database connections, and generates boilerplate code for database access (SQL queries, ORM setup). The integration includes schema introspection, allowing the AI to understand the database structure and generate appropriate queries. For Supabase, the system also handles authentication setup (JWT tokens, session management) and real-time subscriptions. Generated applications can immediately connect to the database without additional configuration.

Dyad includes a Preview System and Development Environment that runs generated React/Next.js applications in an embedded Electron BrowserView. The system spawns a local development server (Vite or Next.js dev server) as a child process, watches for file changes, and triggers hot-module-reload (HMR) updates without full page refresh. The preview is isolated from the main Dyad UI via IPC, allowing the generated app to run with full access to DOM APIs while keeping the builder secure. Console output from the preview is captured and displayed in a Console and Logging panel, enabling developers to debug generated code in real-time.

Dyad implements a Version Control and Time-Travel system that automatically commits generated code to a local Git repository after each AI-generated change. The system uses Git Integration to track diffs, enable rollback to previous versions, and display a visual history timeline. Additionally, Database Snapshots and Time-Travel functionality stores application state snapshots at each commit, allowing users to revert not just code but also the entire project state (settings, chat history, file structure). The Git workflow is abstracted behind a simple UI that hides complexity — users see a timeline of changes with diffs, and can click to restore any previous version without manual git commands.

Dyad implements a Chat Modes and Agent System that supports multiple interaction patterns: direct code generation (single-turn), iterative refinement (multi-turn conversation), and autonomous agent mode (where the AI breaks down complex tasks into subtasks and executes them sequentially). The agent system uses chain-of-thought reasoning to decompose user requests into smaller steps, generates code for each step, applies it to the project, and reports results back to the user. The system maintains conversation context across turns using Jotai-based Global State, allowing the AI to reference previous messages and understand the cumulative intent. Different chat modes are exposed via UI toggles, and the system prompt is adjusted per-mode to guide the AI's behavior (e.g., agent mode includes instructions for task decomposition).

Dyad implements an MCP (Model Context Protocol) and Tool System that allows the AI to call external tools and services through a schema-based function registry. Tools are defined as JSON schemas with input/output types, and the system supports both built-in tools (file operations, git commands, search-replace) and user-defined tools via MCP servers. The Local Agent System executes tool calls in the main process (for security-critical operations like file I/O) or spawns child processes for isolated execution. Tool results are streamed back to the AI, enabling it to take actions, observe outcomes, and refine its approach. The system includes native bindings for common operations (file read/write, directory traversal, git status) and can invoke external MCP servers for specialized tasks.

Dyad implements GitHub Integration that allows users to clone repositories directly into Dyad, work on them with AI assistance, and push changes back to GitHub. The system uses the GitHub API to authenticate (via OAuth or personal access tokens), list user repositories, and perform git operations (clone, push, pull). Generated code is committed to a local branch, and users can create pull requests directly from Dyad's UI. The system also integrates with Vercel and other deployment platforms, enabling one-click deployment of generated applications. Repository metadata (owner, branch, remote URL) is stored in project settings, allowing users to switch between local and remote workflows seamlessly.

Dyad implements a Token Counting and Context Management system that estimates token usage for each message and respects model context window limits. The system uses provider-specific tokenizers (OpenAI's tiktoken, Anthropic's tokenizer, etc.) to count tokens in prompts, context, and responses. When approaching context limits, the system automatically summarizes or truncates older messages, removes low-relevance context, or prompts the user to start a new conversation. Token counts are displayed in the UI, allowing users to understand cost implications and make informed decisions about context inclusion. The system also tracks cumulative token usage across a session, enabling users to monitor API costs.

Dyad implements a custom Markdown Parser that extends standard markdown to support AI-specific syntax for code proposals. The parser recognizes custom tags like `<proposal>`, `<file>`, `<search>`, `<replace>` that structure AI-generated code changes in a machine-readable format. Code blocks within proposals are tagged with language identifiers and file paths, enabling the system to apply changes programmatically. The parser also handles nested structures (e.g., multiple replacements within a single file) and validates syntax before applying changes. This allows the AI to generate complex multi-file changes in a single response, which are then applied atomically via the Search and Replace Processing system.

Dyad implements a System Prompts and AI Rules system that allows fine-grained control over AI behavior through configurable prompts and rule files. System prompts are stored as markdown files (e.g., `rules/git-workflow.md`) that define guidelines for code generation, naming conventions, architectural patterns, and project-specific rules. These rules are injected into the LLM prompt before each generation, ensuring the AI adheres to project standards. The system supports multiple rule sets (e.g., frontend rules, backend rules, testing rules) that can be selectively applied based on context. Rules are version-controlled and can be updated without modifying the application code, enabling teams to evolve AI behavior over time.