Glossary

Project-specific vocabulary you will encounter in the codebase.

Core framework

• GPUI — Zed's homegrown UI framework. Provides windowing, rendering, input, and an entity/state model. Lives in crates/gpui and the per-platform gpui_* crates. See GPUI.
• App — root context type in GPUI (gpui::App). Provides access to globals, entities, and system services. Passed as cx: &mut App or cx: &App.
• Window — a top-level OS window. Passed as window: &mut Window. Holds focus, dispatches actions, draws.
• Entity — Entity<T> is a reference-counted handle to state of type T, similar to a "model" or "store" in other frameworks. Mutated via entity.update(cx, |this, cx| …).
• Context — typically cx. Context<T> is the cx provided when updating an Entity<T>; it dereferences to App.
• AsyncApp / AsyncWindowContext — context types that survive across .await points.
• Element — the GPUI counterpart to a "widget" or "view". Anything implementing IntoElement can be rendered as a child.
• View — informal term for an Entity<T> whose T implements Render.
• Action — a typed message dispatched via keyboard or code. Defined with the actions! macro or the Action derive.
• Notify — cx.notify() triggers a re-render of the current entity.
• Observe / Subscribe — cx.observe(other_entity, …) runs a callback whenever the other entity calls cx.notify(). cx.subscribe(other_entity, …) runs a callback on emitted events.
• Task — a future returned by cx.spawn / cx.background_spawn. Cancelled when dropped unless detached or stored.

Editor

• Buffer — a single text document (language::Buffer). Has text, language, syntax tree, diagnostics, and edit history.
• Rope — the data structure backing buffer text (crates/rope). Persistent B-tree of UTF-8 chunks.
• MultiBuffer — a virtual buffer composed of excerpts from multiple buffers (crates/multi_buffer). Powers Find-and-Replace, search results, diagnostics view, agent file edits, etc.
• Excerpt — a contiguous range from a single Buffer that appears inside a MultiBuffer.
• Editor — the editor view (crates/editor). Displays a MultiBuffer with cursors, selections, scrolling, and decorations.
• DisplayMap — translates buffer offsets to "display" rows/columns, accounting for soft wrap, folds, inline hints, blocks, and fold replacements.
• Anchor — a position in a buffer that survives concurrent edits (Buffer-side Anchor, MultiBuffer-side Anchor).
• Selection — a (start, end, head) range in display space; a buffer can have many selections (multi-cursor).
• Decoration — block, inline hint, highlight, fold placeholder — anything overlaid on the editor.

Project & filesystem

• Project — the model of an open project (crates/project). Owns worktrees, language servers, tasks, debug adapters, collaborators, and so on.
• Worktree — a single open root folder (crates/worktree). Watches files, scans entries, and computes diffs.
• Fs — a filesystem abstraction (crates/fs). RealFs (local), FakeFs (tests), SshFs (remote).
• NodeRuntime — managed Node sidecar (crates/node_runtime). Used by extensions and AI tools that need npm packages.

Languages & LSP

• LanguageRegistry — the global registry of languages and grammars (language::LanguageRegistry).
• Tree-sitter — incremental parsing library used for syntax highlighting, outlines, brackets, indentation. Grammars live as separate crates in extensions/ and are bundled via crates/grammars.
• LanguageServer — a process speaking LSP (crates/lsp). Started per-project per-language.
• Adapter — per-language LSP wrapper that knows how to install, configure, and translate a specific language server (e.g. rust-analyzer, gopls).

AI & agent

• Agent — autonomous coding agent (crates/agent). Has Threads, Tools, and a Session Store.
• Thread — a single agent conversation (agent::Thread).
• ACP — Agent Client Protocol (crates/acp_thread, acp_tools). Wire format for talking to external agent backends.
• MCP — Model Context Protocol. Used by context_server to plug in external tool servers.
• Tool — a callable the agent can invoke (read file, run command, search codebase, …).
• EditPrediction — inline AI completion (crates/edit_prediction). The model proposes a multi-line edit; the user accepts or rejects.
• Zeta — Zed's first-party edit-prediction model. The prompt is in crates/zeta_prompt.
• PromptStore / PromptBuilder — runtime templating of system prompts (crates/prompt_store).

Collaboration

• Channel — a persistent room with members, like a Slack channel (crates/channel).
• Call — a real-time multiplayer session with audio (crates/call, crates/livekit_client).
• Collab — the backend service (crates/collab). Postgres-backed.
• Replica ID — an identifier for a collaborator's CRDT-style edits; baked into text::Anchor.

Remote development

• Remote — local-side glue for remote development (crates/remote, crates/remote_connection).
• remote_server — headless server-side editor that runs on the remote host (crates/remote_server). Talks to the local Zed over an SSH-multiplexed RPC channel.

Extensions

• Extension — third-party WASM module that contributes themes, languages, snippets, slash commands, or context-server adapters (crates/extension).
• ExtensionHost — the runtime that loads and sandboxes extensions (crates/extension_host).

Settings & theming

• SettingsStore — global registry for typed settings (settings::SettingsStore). Stacks defaults, user, project, and local overrides.
• BaseKeymap — preset keymap schemes (Atom, JetBrains, VS Code, …) layered with per-user overrides.
• Theme — visual theme (crates/theme). Defines colors, syntax styles, and player colors.

Internal terms

• Channel (vs. agent channel) — also used for collab channels and for futures/streams. Disambiguate by file location.
• Hosting provider — git host abstraction (crates/git_hosting_providers) for GitHub/GitLab/Bitbucket-aware features.
• Hotfix — a patch shipped on the active stable channel between regular releases. Tracked by .github/workflows/hotfix-review-monitor.yml.
• Nightly / Preview / Stable — Zed's three release channels. See crates/release_channel.