# Explain It Simply

> Imagine a terminal combined with a smart helper robot. Warp is an agentic development environment where you can use a built-in AI companion or connect other AI coding agents (like Claude Code or Codex) to perform tasks for you. The most important things to remember are: Warp is built with a custom GPU-accelerated UI framework (WarpUI) in Rust, interacts with AI agents using isolated "skills", and serves as a unified workspace for terminal sessions, drive configurations, and code files.

- Repository: warpdotdev/warp
- GitHub: https://github.com/warpdotdev/warp
- Human wiki: https://grok-wiki.com/public/wiki/warpdotdev-warp-a2a3b9202160
- Complete Markdown: https://grok-wiki.com/public/wiki/warpdotdev-warp-a2a3b9202160/llms-full.txt

## Source Files

- `README.md`
- `WARP.md`
- `CONTRIBUTING.md`
- `Cargo.toml`
- `FAQ.md`

---

<details>
<summary>Relevant source files</summary>
The following files were used as context for generating this wiki page:
- [README.md](README.md)
- [WARP.md](WARP.md)
- [FAQ.md](FAQ.md)
- [Cargo.toml](Cargo.toml)
- [crates/ai/src/skills/skill_provider.rs](crates/ai/src/skills/skill_provider.rs)
- [crates/ai/src/skills/parse_skill.rs](crates/ai/src/skills/parse_skill.rs)
- [app/src/ai/skills/listed_skill.rs](app/src/ai/skills/listed_skill.rs)
- [app/src/ai/skills/mod.rs](app/src/ai/skills/mod.rs)
</details>

# Explain It Simply

Imagine a standard developer terminal combined with a highly intelligent, proactive helper robot. Warp is an agentic development environment where you can seamlessly collaborate with a built-in AI companion or connect other third-party AI coding agents (such as Claude Code, Codex, or Gemini CLI) to execute tasks, triage issues, and automate your development workflows right from the command line.

Rather than acting as a simple passive text interface, Warp is built from the ground up to serve as a unified workspace for managing terminal sessions, file configurations, and cloud-synchronized drives. This is made possible through three major architectural pillars: a custom GPU-accelerated UI framework (WarpUI) written in Rust, a file-system-driven "skills" engine to interface with AI models, and an integrated workspace mapping terminal history and cloud drive synchronization.

---

## 1. What is Warp? The Terminal with a Brain

Traditional terminal emulators are passive windows that merely display stdout and receive stdin. Warp transforms the terminal into a pair-programming partner. At its heart, Warp is an agentic development environment designed to run alongside you or orchestrate complex developer actions autonomously.

Whether you are using Warp’s built-in assistant or bringing your own local agent (like Claude Code, Codex, or Cursor), the environment exposes rich contextual information. The repository ships with agent-readable schemas, product/technical specifications, and execution instructions. These allow autonomous agents to help you spec out features, write code, run presubmit checks, and review incoming pull requests.

Sources: [README.md:32-35](README.md#L32-L35), [FAQ.md:59-70](FAQ.md#L59-L70)

---

## 2. WarpUI: The Custom GPU-Accelerated Rust UI Framework

To achieve high-performance rendering and a fluid user interface, Warp bypasses standard web views or heavy electron layers. It utilizes **WarpUI** (`crates/warpui/` and `crates/warpui_core/`), a custom, hardware-accelerated user interface framework written entirely in Rust.

WarpUI operates on an **Entity-Component-Handle** pattern:
- **Entity & Ownership:** A global `App` object owns all active views and models (entities).
- **Handles:** Views never reference other views via direct pointers or cyclic ownership. Instead, they reference each other through smart pointer `ViewHandle<T>` wrappers.
- **Context:** Temporary access to handles during event cycles or rendering passes is managed via `AppContext`, `ViewContext`, or `ModelContext` parameters (customarily named `ctx` and placed last in signatures).
- **Layout:** The layout employs a Flutter-inspired composable Element hierarchy.
- **Input Tracking:** Interactive inputs require careful management of a `MouseStateHandle`. It must be instantiated once during a view's construction and then cloned/referenced. Initializing an inline `MouseStateHandle::default()` during rendering will prevent mouse interaction from functioning.

WarpUI is licensed under the permissive **MIT License** to encourage ecosystem-wide reuse and external development. The client-side application layer (`app/`), on the other hand, is licensed under **AGPL v3** to ensure that derivative terminal modifications remain open-source.

Sources: [WARP.md:57-68](WARP.md#L57-L68), [WARP.md:105-107](WARP.md#L105-L107), [FAQ.md:91-97](FAQ.md#L91-L97), [FAQ.md:110-120](FAQ.md#L110-L120)

---

## 3. Isolated "Skills": How Warp Communicates with AI Agents

To maintain a secure, modular, and portable architecture, Warp communicates with AI agents using isolated "**skills**". A skill is represented as a structured markdown file (`SKILL.md`) featuring YAML front-matter that lists the skill's name and description, followed by comprehensive system prompts and tool constraints that guide the agent's behavior.

The AI dispatch engine parses these markdown files and represents them internally using a `ParsedSkill` struct:

```rust
// crates/ai/src/skills/parse_skill.rs
pub struct ParsedSkill {
    pub path: PathBuf,
    pub name: String,
    pub description: String,
    pub content: String,
    pub line_range: Option<Range<usize>>,
    pub provider: SkillProvider,
    pub scope: SkillScope,
}
```

### Skill Scopes & Precedence
Warp organizes skills into three distinct categories defined by the `SkillScope` enum:
1. **Bundled:** Built-in agent skills shipped directly with the Warp terminal distribution.
2. **Project:** Skills checked into a specific repository directory (e.g., `repo/.agents/skills/`), which let you configure project-specific commands and guidelines.
3. **Home:** Global user-specific skills located in your home directory (e.g., `~/.agents/skills/`).

### Provider Neutrality (BYOC / BYOK)
Warp’s skill system is completely **Bring Your Own Co-pilot (BYOC)** and **Bring Your Own Key (BYOK)** friendly. The terminal interacts with models via a provider-neutral interface. It maps skills to directories based on the `SkillProvider` definition, allowing any portable model adapter (Anthropic's Claude, OpenAI's Codex, Google's Gemini, or local models) to read and execute the instructions without vendor lock-in.

```rust
// crates/ai/src/skills/skill_provider.rs
pub enum SkillProvider {
    Warp,
    Agents,
    Claude,
    Codex,
    Cursor,
    Gemini,
    Copilot,
    Droid,
    Github,
    OpenCode,
}
```

The matching skills directory structure is illustrated below:

```mermaid
flowchart TD
    subgraph UI ["Warp UI Layer (crates/warpui)"]
        A["GPU-Accelerated Terminal UI"] --> B["Entity-Handle App System"]
        B --> C["MouseStateHandle (Input Tracking)"]
    end

    subgraph App ["Main Application (app/src)"]
        D["Workspace Configuration"] --> E["Agent Mode / Conversations"]
        F["Warp Drive (SQLite/GraphQL)"] --> D
    end

    subgraph AI ["AI & Skill Dispatch Engine (crates/ai)"]
        G["SkillManager"] --> H["SkillProvider & Scope Resolver"]
        H --> I["SKILL.md Parser (ParsedSkill)"]
    end

    subgraph Skills ["Skills Catalog (File-Based & Portable)"]
        J["Bundled Skills (.warp/skills)"]
        K["Project Skills (.agents/skills)"]
        L["Home Skills (~/.agents/skills)"]
    end

    subgraph External ["External Coding Companions (BYOC / BYOK)"]
        M["Claude Code / Claude API"]
        N["Codex / OpenAI API"]
        O["Gemini CLI / Gemini API"]
    end

    UI --> App
    App --> AI
    AI --> Skills
    Skills --> External
    External --> App
```

### Skill Providers and Paths
Every provider is mapped to a specific relative directory:

| Provider | Enum Variant | Scope Focus | Target Directory |
| :--- | :--- | :--- | :--- |
| **Agents** | `SkillProvider::Agents` | Workspace / Shared Agents | `.agents/skills/` |
| **Warp** | `SkillProvider::Warp` | Default Terminal Skills | `.warp/skills/` |
| **Claude** | `SkillProvider::Claude` | Anthropic Claude Code | `.claude/skills/` |
| **Codex** | `SkillProvider::Codex` | OpenAI Codex / GPTs | `.codex/skills/` |
| **Cursor** | `SkillProvider::Cursor` | Cursor Editor Integration | `.cursor/skills/` |
| **Gemini** | `SkillProvider::Gemini` | Google Gemini CLI | `.gemini/skills/` |
| **Copilot**| `SkillProvider::Copilot` | GitHub Copilot / Chat | `.copilot/skills/` |
| **Droid**  | `SkillProvider::Droid` | Autonomous Factory | `.factory/skills/` |
| **Github** | `SkillProvider::Github` | GitHub Actions / Workflows | `.github/skills/` |
| **OpenCode**| `SkillProvider::OpenCode`| Open-Source Community | `.opencode/skills/` |

Sources: [crates/ai/src/skills/skill_provider.rs:30-41](crates/ai/src/skills/skill_provider.rs#L30-L41), [crates/ai/src/skills/skill_provider.rs:58-66](crates/ai/src/skills/skill_provider.rs#L58-L66), [crates/ai/src/skills/skill_provider.rs:103-147](crates/ai/src/skills/skill_provider.rs#L103-L147), [crates/ai/src/skills/parse_skill.rs:30-45](crates/ai/src/skills/parse_skill.rs#L30-L45), [app/src/ai/skills/listed_skill.rs:5-19](app/src/ai/skills/listed_skill.rs#L5-L19), [WARP.md:40-53](WARP.md#L40-L53)

---

## 4. The Unified Workspace & Warp Drive

Warp integrates your active development artifacts into a single cohesive layout. Instead of separating your text editor, terminal tabs, and cloud workflows, Warp organizes them into a **Unified Workspace**.

Key architectural concepts include:
- **Modular Session Configurations:** A single workspace layout can orchestrate multiple active terminal sessions, documentation notebooks, and active agent conversations.
- **Warp Drive Integration:** Collaborative sharing and persistent sessions are managed via **Warp Drive**. Configurations, shared scripts, and active session environments are synced across devices.
- **Local Persistence & SQLite:** The client uses Diesel ORM with a local SQLite database to cache configurations, command history, and local settings. It communicates with backend endpoints using a generated GraphQL schema client.
- **Backend Isolation:** Warp guarantees that core terminal operations remain purely local and offline-first. Heavy operations—such as multi-device drive sync, team features, and cloud-hosted model orchestration—are directed to Warp’s proprietary server endpoints.

Sources: [WARP.md:85-92](WARP.md#L85-L92), [WARP.md:147-155](WARP.md#L147-L155), [FAQ.md:94-103](FAQ.md#L94-L103)

---

## 5. Unified Architecture & Portable Agentic Workflows

Warp's documentation-driven design is built on structured product workflows. These workflows enable agents and engineers to collaborate seamlessly across boundaries without relying on proprietary platform adapters.

The conceptual framework groups agent tasks into three main portable workflows:
1. **Plan (Ideas, Blueprint, Plan):** Translates an incoming developer request into a scoped blueprint, listing impacted crates, architectural risks, and concrete test scenarios before modifications begin.
2. **Page Shape:** Structures information into reusable modules, architecture patterns, standard developer conventions, or documented failure modes.
3. **QA Review:** Checks requirements and code structures for coherence, API completeness, and security properties.

> [!NOTE]
> This documentation synthesis was generated using a bundled skill snapshot of Every's Compound Engineering plugin (`EveryInc/compound-engineering-plugin @ fd88fd8fd71c`) as a conceptual framework for structuring agent plans, blueprint generation, and quality review. No active local installation of the Every plugin was used.

Sources: [.grok-wiki-antigravity-prompt-742c18bc.md:48-60](.grok-wiki-antigravity-prompt-742c18bc.md#L48-L60), [.grok-wiki-antigravity-prompt-742c18bc.md:65-71](.grok-wiki-antigravity-prompt-742c18bc.md#L65-L71)

---

## Summary

Warp reimagines the terminal as an agentic development environment where high-performance engineering meets context-aware AI collaboration. By constructing a custom, GPU-accelerated rendering engine (WarpUI), defining portable and isolated command "skills" for third-party AI agents, and wrapping everything inside a cloud-synchronized unified workspace, Warp establishes a solid, provider-neutral foundation for the future of development.

Sources: [README.md:54-59](README.md#L54-L59)