Skip to content
Zephyr

Docs · v1.1.11

How Zephyr works, end to end.

Eight sections. The MCP server is the part most people care about, so it comes second. Everything here runs on your machine, and the source is the same code these pages describe.

01

Quickstart

Windows 10 or 11 is the primary supported platform, so this quickstart assumes it. Install, open a folder, and know where your settings live. The Linux AppImage and .deb builds follow the same steps, but they are experimental community builds rather than the tested target.

1

Install on Windows 10 or 11

Windows 10 or 11 is the primary supported platform. Take the x86_64 NSIS installer, or the MSI for managed deployments. WebView2 already ships with Windows 11, so on a fresh machine the installer is usually the only step. A Linux AppImage and .deb are also published, but those are experimental community builds, not the tested target.

2

Open a folder

File, then Open Folder, loads a workspace. Quick Open searches every file in it from the keyboard, and the project tree on the left fills in as soon as the folder is indexed.

3

Register your CLI

Settings has a one-click registration for Claude Code, Codex, Gemini CLI, and opencode. It writes the config for you and tells you which file it touched.

Where settings live

Settings, keys, extensions, and logs are plain files in one folder. No database, no migration step. On Windows that folder is %APPDATA%\zephyr\.

%APPDATA%\zephyr\

Delete that folder and Zephyr starts clean on the next launch.

Register from the shell

Settings has a one-click registration for each supported CLI. This is the equivalent command if you would rather run it yourself.

claude mcp add zephyr --transport http http://127.0.0.1:9222/mcp
02

The MCP server on port 9222

Any AI CLI that speaks MCP can read your buffers, open files, and drive the window. The server is HTTP JSON-RPC on loopback, guarded by a bearer token, and you can switch it off.

Transport

HTTP JSON-RPC

Bind

127.0.0.1 only

Auth

Bearer token

Methods

More than 20

A request and a reply

editor_write takes a path and text. It writes to the buffer, not straight to disk, so unsaved changes and formatting stay intact. That is the one behavior worth knowing: nothing the CLI does bypasses what you see in the editor.

POST http://127.0.0.1:9222/mcp
Authorization: Bearer $ZEPHYR_TOKEN

{"jsonrpc":"2.0","id":7,"method":"editor_write",
 "params":{"path":"src/main.rs","text":"fn main() {}\n"}}
{"jsonrpc":"2.0","id":7,
 "result":{"ok":true,"bytes":13,"buffer":true}}

Health, and turning it off

/health is the one route that needs no token and does no UI work, so a CLI can check whether the editor is up before it tries anything else.

GET http://127.0.0.1:9222/health

{"status":"ok","version":"1.1.11","pid":18422}

A single switch in Settings stops the listener. The token is written next to the settings, and a startup call that arrives before the window is ready waits briefly and retries rather than failing outright.

The methods

Grouped by what they touch. The full list is longer than this; the editor, terminal, and git groups cover most sessions.

editor_read, editor_write, editor_insert, editor_replace
editor_search, editor_open, editor_active_file
terminal_create, terminal_send, terminal_read, terminal_close
git_status, git_diff, git_stage, git_commit, git_branch
git_log, git_blame, git_stash, git_conflicts
window_focus, panel_open, command_run, settings_read

One-click registration

Settings has a registration row for each supported CLI. It writes the config, keeps the token in sync, and tells you the exact file it changed.

  • Claude Code
  • Codex
  • Gemini CLI
  • opencode
{
  "mcpServers": {
    "zephyr": {
      "type": "http",
      "url": "http://127.0.0.1:9222/mcp",
      "headers": { "Authorization": "Bearer <token>" }
    }
  }
}
03

Chat, agent, and the local option

Two modes, three adapter formats, and no key ever crossing into the UI. The provider you pick in Settings is the provider the agent uses.

Streaming chat

Tokens arrive as they are produced, in the panel beside the editor. The conversation is plain text in your app data, so you can read it, edit it, or delete it without a tool.

Agent

The same panel, but the model can call editor, terminal, and git tools. Each turn shows a status block with the plan, the step number, the recent tool results, and anything that failed. A failed call comes back with guidance instead of a silent retry.

Three adapter formats

Pick OpenAI, Anthropic, or Gemini and the request shape, the tool-call encoding, and the streaming parser all follow that provider. Inline XML tool calls from a local model work too: DSML, tool_calls, and antml invoke are all parsed, and the tags never reach the visible reply.

  • Bring your own key, or point at a local endpoint and keep everything on the machine.
  • Keys are held on the Rust side. Settings only ever renders a masked preview.
  • The model is reconciled from settings at boot and before every send, so a stale <Code>custom-model</Code> placeholder never reaches the provider.

Local endpoints

Anything that speaks the OpenAI format works. Ollama is the common case: set the base URL and the model name, leave the key blank.

provider:  ollama
base_url: http://127.0.0.1:11434/v1
model:     qwen2.5-coder:14b
api_key:   (leave blank)

Parallel subagents run against whichever provider is configured, and an optional local RAG index can be built over the workspace without anything leaving the disk.

04

Terminal

Real PTYs over ConPTY, not a shell wrapper. Up to six panes per tab, each with its own working directory and its own process.

What you get

  • Up to six panes per tab, each with its own cwd and process.
  • PowerShell, cmd, pwsh, bash, and WSL in the same tab, chosen per pane.
  • A private terminal that wipes its scrollback when the pane closes.
  • A dedicated agent pane, so agent output never lands in your own shell history.
  • Split With Browser reads the real page over the network instead of embedding an iframe, so nothing is silently blocked.

Driving it from a CLI

The MCP terminal methods write to a pane and read it back, which is how an agent runs a build, reads the output, and reacts to it. A pane is addressed by id, so a long-running process is not tied to a tab you might close.

{"method":"terminal_create","params":{"shell":"pwsh","cwd":"src-tauri"}}
{"result":{"pane":1}}

{"method":"terminal_send","params":{"pane":1,"text":"cargo test --lib\n"}}
{"result":{"ok":true}}

Output lands in the pane, and the agent reads the same text you see.

05

Git

The workflow that lives inside the window: status, diff, stage, commit, branch, log, then the remote side with one deliberate prompt before you overwrite local work.

Local

  • Status, diff, stage, commit, branch, and log, all in the sidebar.
  • Inline blame in the gutter, with author and date per line.
  • Stash: save, list, pop, and drop.
  • Rebase onto a branch without leaving the editor.
  • Write a commit message from the diff in one click, then edit it before it lands.

Remote and conflicts

  • Push, pull, fetch, and sync from the same panel.
  • Sync pulls first and asks before it discards anything, so local commits are never dropped quietly.
  • Merge conflicts resolve per file with take-ours and take-theirs.
  • Binary diffs are labelled with the size instead of rendered as broken text.
  • GitHub sign-in uses the OAuth device flow, or a personal access token if you would rather not.

Cloning and remotes

Open Folder on a repository you already have works with no setup. To start from a remote, clone it first, then open the result.

git clone https://github.com/you/project
cd project

Then File, Open Folder on the clone. Nothing else is needed before you commit.

06

Building from source

Tauri 2, Rust, and React, on the Windows 10 or 11 toolchain that the primary builds target. Three prerequisites, then the same three commands a contributor runs. Linux builds work on a best-effort basis.

Prerequisites

  • Rust stable, with the default toolchain.
  • Node 20 or newer, for the front end toolchain.
  • The WebView2 Runtime on Windows 10. It is already present on Windows 11, and it is required to build or run the Windows target.

Run it

git clone https://github.com/ShinRyu04/Zephyr
cd Zephyr
npm install
npm run tauri dev

Dev mode hot-reloads the front end and restarts the Rust side when it changes.

Build a release

npm run tauri build

Installers land in the Tauri bundle output directory, one per target you enabled. The Windows target is the one that gets built and tested; Linux bundles are best-effort.

Before you push

Three checks, in the order that fails fastest.

npx tsc --noEmit
cd src-tauri && cargo test --lib
npm run verify
07

Settings, themes, and keys

One folder of plain files. Delete it for a full reset, or edit it by hand while the app is closed. The path below is the Windows one.

The app data folder

On Windows 10 or 11:

%APPDATA%\zephyr\
  • Settings, provider keys, installed extensions, and logs all live here.
  • Writes are atomic: a temp file, then a rename, so a crash cannot leave a half-written settings file.
  • Files with a UTF-8 BOM are read correctly, and a patch is cancelled rather than applied if the current file cannot be read.
  • Delete the folder to reset everything. Nothing else is stored on the machine.

Appearance and input

  • Nineteen themes, with a background image and an opacity slider if you want one.
  • Customize Layout, so you can show, hide, and resize each pane and keep that arrangement.
  • Remappable shortcuts with conflict detection: a binding that clashes is flagged before it is saved.
  • Ten languages, English by default, switchable without a restart.

Provider keys are masked in the UI and held in Rust. Copying one out is the only way to read it, which is the point.