GitHub 트렌딩 딥다이브 · 2026-06-23

Zed 딥다이브
— Rust로 밑바닥부터 GPU에 직접 그린, "사람과 AI가 같은 속도로 함께 코딩하는" 에디터

zed-industries/zed. AtomTree-sitter를 만든 팀이 다시 만든 고성능·멀티플레이어 코드 에디터다. 약 280개의 Rust 크레이트로 짜인 하나의 거대한 작업공간(모노레포)이며, 화면은 브라우저 엔진을 거치지 않고 자체 UI 프레임워크 GPUI가 매 프레임을 GPU에 직접 그린다. 2026년 들어 1.0 정식 출시(2026-04-29)와 함께 AI 에이전트를 에디터 안에 정식으로 들였다. (저장소: zed-industries/zed · 언어 Rust(edition 2024) · 라이선스 GPL-3.0(일부 Apache-2.0) · macOS·Linux·Windows · TrendShift 주간 라이브 멘션 등재)

목차
  1. 프로젝트 한줄 요약
  2. 왜 주목받는가
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석 (키 입력이 픽셀이 되기까지)
  5. 디렉토리 구조 해부
  6. 학습 포인트 (기술별)
  7. 하드웨어 / 시스템 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한줄 요약

"텍스트 편집의 모든 층을 Rust로 새로 짜서, '느려서 답답한 순간'을 구조적으로 없앤 에디터."

한 줄로

Zed는 글자를 저장하는 자료구조부터 화면에 픽셀을 찍는 일, 언어 분석, 실시간 공동편집, AI 에이전트까지 전부 Rust로 새로 만든 코드 에디터다.

대부분의 인기 에디터(VS Code·Cursor 등)는 웹 브라우저 엔진(Electron) 위에서 돈다. 화면이 사실은 "웹페이지"라서, 큰 파일을 열거나 타이핑이 몰리면 미세하게 버벅인다. Zed는 그 층을 통째로 걷어내고 운영체제의 그래픽 카드(GPU)에 글자를 직접 그린다. 게임이 60·120프레임으로 부드럽게 도는 것과 같은 방식이다. 그래서 "에디터가 입력을 못 따라온다"는 느낌이 잘 들지 않는다.

핵심은 "빠름을 기능이 아니라 토대로 삼았다"는 점이다. 만든 사람들은 2010년대 초 Atom(GitHub의 해킹 가능한 에디터, Electron의 출발점)과 Tree-sitter(지금 거의 모든 에디터가 쓰는 코드 구문 분석기)를 만든 팀이다. 그들이 "Atom이 느렸던 이유"를 10년간 곱씹은 끝에, 처음부터 성능을 노리고 Rust로 다시 쓴 결과물이 Zed다.

용어
크레이트(crate) / 워크스페이스(workspace)
크레이트는 Rust에서 "하나의 패키지·라이브러리 단위"다(다른 언어의 모듈·패키지에 해당). 워크스페이스는 그런 크레이트 여러 개를 한 저장소에서 같이 빌드·관리하는 묶음이다. Zed는 crates/ 폴더 아래 약 280개의 크레이트를 하나의 워크스페이스로 묶은 모노레포(하나의 저장소에 모든 걸 담는 방식)다. "거대한 레고 박스 하나에 작은 부품 280개"라고 보면 된다.
용어
Electron vs 네이티브(native)
Electron은 "웹 기술(HTML·CSS·JS)로 데스크톱 앱을 만드는 틀"이다. 안에 작은 크롬 브라우저가 통째로 들어 있어 편하지만 무겁다. 네이티브는 브라우저를 끼지 않고 운영체제·그래픽 카드와 직접 대화하는 방식. Zed는 네이티브다 — 그래서 가볍고 빠른 대신, 화면 그리는 일을 스스로 다 만들어야 했다(그게 바로 GPUI다).

그리고 2026년의 Zed는 단순한 "빠른 에디터"를 넘어, 사람과 AI 에이전트가 같은 화면에서 함께 일하는 작업대로 방향을 잡았다. 실시간 공동편집(멀티플레이어)이 기본으로 들어 있고, 거기에 AI 에이전트를 표준 규약으로 꽂아 "사람 옆에서 같이 타이핑하는 동료"처럼 쓰게 만들었다. 이 문서는 그 구조를 한 층씩 뜯어본다.

2왜 주목받는가

"빠른 에디터" 자리에 안주하지 않고, 2026년 AI 코딩 흐름의 한복판으로 들어갔다.

Zed는 5년간 매주 빌드를 내놓다가 2026년 4월 29일 1.0을 찍었다. 그런데 화제가 된 건 버전 숫자가 아니라, "네이티브 속도" + "AI 에이전트"를 한 몸에 합친 첫 사례라는 점이다. 핵심 차별점을 하나씩 보자.

① 속도 — 브라우저를 들어내고 GPU에 직접 그린다

경쟁작 대부분은 Electron(브라우저 엔진) 위에 있다. Zed는 자체 UI 프레임워크 GPUIMetal(macOS)·DirectWrite/Direct3D(Windows)·wgpu/Vulkan(Linux)에 글자를 직접 올린다. 입력 지연과 프레임 시간을 줄이는 게 설계의 1순위라, 코드에는 아예 ZED_MEASUREMENTS 같은 프레임 시간 측정 스위치가 내장돼 있다.

② AI 에이전트를 "표준 규약"으로 들였다 (ACP)

Zed는 특정 AI 회사에 묶이는 대신, ACP(Agent Client Protocol)라는 공개 규약을 직접 만들어 1.0의 간판 기능으로 내세웠다. 덕분에 Claude 계열 에이전트, Codex, OpenCode 같은 여러 에이전트를 같은 방식으로 에디터에 꽂을 수 있다.

용어
ACP (Agent Client Protocol, 에이전트-클라이언트 규약)
"AI 에이전트와 에디터가 서로 대화하는 공용 언어"를 정해 둔 공개 표준. 콘센트 규격을 표준화하면 어느 회사 충전기든 꽂히는 것처럼, ACP를 지키는 에이전트는 ACP를 지원하는 어느 에디터에든 붙는다. Zed가 만들어 공개했고, 저장소의 acp_thread·acp_tools·agent_servers 크레이트가 이 규약을 구현한다.

③ 병렬 에이전트 · 터미널 스레드

2026년 4월 22일 Zed는 Parallel Agents(병렬 에이전트)를 내놨다 — 여러 AI 에이전트를 한 창에서 동시에 돌려 각자 코드의 다른 부분을 손보게 하는 기능으로, "네이티브로 병렬 에이전트를 지원한 첫 에디터"로 소개됐다. 이어 5월 20일에는 Terminal Threads가 추가돼, Claude Code 같은 CLI 에이전트를 에디터 사이드바에서 함께 굴릴 수 있게 됐다.

④ 멀티플레이어가 기본 — "구글 문서처럼 같이 코딩"

Zed는 처음부터 실시간 공동편집을 핵심으로 깔았다. 같은 파일에 여러 명이 동시에 커서를 두고 편집하고, 음성·화면 공유까지 붙는다(livekit_client·collab 크레이트). 에디터를 "혼자 쓰는 도구"가 아니라 "팀이 같이 들어오는 공간"으로 본 셈이다.

⑤ 자체 편집 예측 모델 — Zeta2

다음에 칠 코드를 미리 제안하는 edit prediction에 Zed는 Zeta2라는 공개 가중치(open-weight) 모델을 쓴다. 범용 추론보다 "코드 자동완성 속도"에 맞춰 튜닝된 모델이다. 관련 코드는 edit_prediction*·zeta_prompt 크레이트에 모여 있다.

경쟁 구도 한눈에

항목ZedVS Code / CursorJetBrains
토대네이티브 Rust + 자체 GPU 렌더(GPUI)Electron(브라우저 엔진) + TypeScriptJVM(자바 가상머신)
속도 느낌매우 가볍고 빠름보통(큰 파일·확장 많으면 둔해짐)무거움(메모리 많이 씀)
공동편집기본 내장확장(Live Share 등)제한적
AI 에이전트ACP 표준 + 병렬 에이전트 내장Cursor는 강함 / VS Code는 확장플러그인 위주
확장WebAssembly 확장방대한 마켓플레이스(가장 큼)풍부함
비유

VS Code가 "잘 만든 웹앱을 데스크톱에 담은 것"이라면, Zed는 "게임 엔진으로 만든 코드 에디터"에 가깝다. 같은 글자를 보여줘도, 하나는 웹페이지를 다시 그리는 방식이고 다른 하나는 GPU에 프레임을 쏘는 방식이다 — 그 차이가 "버벅임이 있나 없나"로 나타난다.

균형 잡기
장밋빛만은 아니다

네이티브를 택한 대가로 확장 생태계는 VS Code보다 작다(마켓플레이스 규모·플러그인 수에서 한참 뒤). GPL-3.0 라이선스라 사내 포크·재배포에 제약이 있고, 공동편집·일부 AI 기능은 Zed의 클라우드 서버를 거친다(완전한 오프라인·자체호스팅은 아님). "무조건 우월"이 아니라 트레이드오프가 분명한 선택이다.

3기술 스택 전체 지도

"에디터 하나에 OS·그래픽·언어·네트워크·AI가 다 들어간다 — 그걸 전부 Rust로."

Zed의 스택은 "프론트엔드/백엔드"라는 웹 구분이 잘 안 맞는다. 데스크톱 앱이라 UI 층 · 편집 엔진 · 언어 지능 · 협업/네트워크 · AI · 확장으로 나누는 게 자연스럽다. 루트 Cargo.toml(워크스페이스 설정)에서 실제로 끌어다 쓰는 부품들로 지도를 그려 보자.

언어와 UI 층 (화면을 그리는 쪽)

구성무엇한 줄 설명
Rust 2024전체 언어메모리 안전 + C++급 속도. edition = "2024" 최신 판 사용
GPUI자체 UI 프레임워크즉시+보존 혼합 모드의 GPU 가속 UI(crates/gpui)
wgpu / Metal그래픽 백엔드리눅스·윈도우는 wgpu, macOS는 Metal로 픽셀을 쏨
DirectWrite·Win32 / Wayland·X11OS 창·글자플랫폼별 창 띄우기·글꼴 래스터화(gpui_windows·gpui_linux·gpui_macos)
taffy레이아웃 엔진웹의 Flexbox식 배치를 네이티브로 계산

편집 엔진 (글자를 다루는 쪽)

구성무엇한 줄 설명
rope / sum_tree텍스트 자료구조거대한 파일도 빠르게 편집하는 균형 트리(아래 4절 핵심)
text / multi_buffer버퍼 모델편집 이력·여러 파일 조각을 한 화면에 모으는 멀티버퍼
Tree-sitter구문 분석코드를 문법 트리로 파싱(색칠·접기·구조 파악). Zed 팀의 또 다른 작품
vim입력 모드Vim 키 조작을 1급 기능으로 내장(crates/vim)

언어 지능 · 디버그 (똑똑함을 붙이는 쪽)

구성무엇한 줄 설명
LSP언어 서버 규약자동완성·정의로 이동·오류 표시를 언어별 서버에서 받아옴
DAP디버그 어댑터 규약중단점·변수 검사 등 디버거 연동(dap·debugger_ui)
tree-sitter-* 문법언어별 문법Rust·TS·Python·Go·C++ 등 수십 개 문법을 기본 동봉

협업 · AI · 확장 (사람·모델·플러그인을 잇는 쪽)

구성무엇한 줄 설명
collab / rpc / proto실시간 협업자체 RPC(원격 호출)로 편집을 실시간 동기화. 서버는 collab 크레이트
LiveKit음성·화면 공유공동 작업 중 통화·화면 스트리밍(livekit_client)
agent-client-protocolACP 구현외부 AI 에이전트를 표준 방식으로 연결(acp_thread·agent_servers)
provider 크레이트들여러 LLM 연결anthropic·open_ai·google_ai·ollama·mistral·deepseek·bedrock·x_ai 등 모델별 어댑터
wasmtime확장 실행확장(extension)을 WebAssembly로 안전하게 격리 실행
sqlez (SQLite)로컬 저장설정·상태를 로컬 SQLite에 보관하는 얇은 래퍼
용어
LSP (Language Server Protocol, 언어 서버 규약)
"자동완성·오류표시·정의로 이동" 같은 언어별 똑똑한 기능을, 에디터가 직접 구현하지 않고 '언어 서버'라는 별도 프로그램에 물어보는 공용 규약. 식당에 비유하면, 에디터는 손님 주문을 받는 '홀', 언어 서버는 요리하는 '주방'이다. 규약이 표준이라 Rust·Python 등 어떤 언어든 같은 방식으로 붙는다. (참고로 LSP도 원래 VS Code 진영이 표준화했다.)

4아키텍처 심화 분석 — 키 입력이 픽셀이 되기까지

"내가 'a'를 누르면, 그 글자가 화면에 찍히기까지 Zed 안에서 무슨 일이 벌어지나."

Zed의 구조를 한 장으로 그리면 이렇게 층층이 쌓인 탑이다. 아래일수록 "원초적인 글자·자료구조", 위일수록 "사람이 보는 화면·협업·AI"다.

┌──────────────────────────────────────────────────────────────┐ │ 사용자 / 다른 협업자 / AI 에이전트 │ └───────────────┬───────────────┬───────────────┬──────────────┘ │ 키 입력 │ 원격 편집 │ ACP(표준 규약) ▼ ▼ ▼ ┌──────────────────────────────────────────────────────────────┐ │ workspace ─ 창·패널·탭의 최상위 뼈대 │ │ ├── editor 편집 화면(커서·선택·스크롤) │ │ ├── agent_ui AI 에이전트 패널 / 병렬 에이전트 │ │ ├── collab_ui 실시간 공동편집 UI │ │ └── project_panel·terminal·debugger_ui ... │ └───────────────┬──────────────────────────────────────────────┘ │ "무엇을 그릴지"를 GPUI에 넘김 ▼ ┌──────────────────────────────────────────────────────────────┐ │ GPUI ─ 자체 UI 프레임워크 (매 프레임 render → GPU) │ │ Entity(상태) → View(Render) → Element(배치) → wgpu/Metal │ └───────────────┬──────────────────────────────────────────────┘ │ 글자 데이터는 어디서? ▼ ┌──────────────────────────────────────────────────────────────┐ │ 편집 엔진 │ │ multi_buffer → buffer(text) → rope → sum_tree(균형 트리) │ │ language + Tree-sitter(구문 트리) + LSP(언어 서버) │ └───────────────┬──────────────────────────────────────────────┘ │ 파일·프로세스·네트워크 ▼ ┌──────────────────────────────────────────────────────────────┐ │ project / worktree / fs ─ 폴더·파일 감시 │ │ rpc·proto (협업 동기화) · wasmtime (확장) · sqlez (저장) │ └──────────────────────────────────────────────────────────────┘

핵심 설계 1 — Rope + SumTree: "긴 글을 통째로 들고 있지 않는다"

10만 줄짜리 파일에서 맨 앞에 한 글자를 넣는다고 해 보자. 글 전체가 하나의 긴 문자열이라면, 그 한 글자 때문에 뒤의 모든 글자를 한 칸씩 밀어야 한다 — 끔찍하게 느리다. Zed는 텍스트를 작은 조각으로 쪼개 균형 트리에 담는다. 이게 Rope(로프)이고, 그 밑을 받치는 범용 트리가 SumTree다.

비유

긴 글을 한 줄로 이어 붙인 두루마리로 들면, 중간을 고치려고 매번 두루마리 전체를 펼쳐야 한다. Rope는 글을 여러 장의 카드로 쪼개 트리에 꽂아둔 것이라, 고칠 카드 한 장만 갈아끼우면 된다. "어느 카드에 몇 번째 글자가 있나"는 트리가 빠르게 알려준다.

용어
SumTree (합계 트리)
Zed의 만능 자료구조(crates/sum_tree). 항목들을 균형 트리로 들고 있으면서, 각 가지마다 '요약 값(합계)'을 미리 계산해 둔다 — 예: 이 가지 아래 글자 수, 줄 수. 덕분에 "5만 번째 글자가 어디?"를 트리 전체를 훑지 않고 로그 시간에 찾는다. 텍스트(rope)뿐 아니라 파일 목록·편집 이력에도 같은 트리를 재사용한다.

핵심 설계 2 — GPUI: Entity → View → Element

GPUI는 "상태를 담는 그릇(Entity)", "그 상태를 화면으로 바꾸는 규칙(View)", "실제 배치·렌더 단위(Element)" 세 층으로 UI를 만든다. 매 프레임마다 최상위 View의 render()가 호출돼 화면을 다시 구성하고, 결과를 GPU에 넘긴다(즉시 모드). 동시에 상태는 Entity가 오래 들고 있는다(보존 모드) — 그래서 "하이브리드"다.

// GPUI 앱의 가장 작은 뼈대 — README 예시를 단순화
use gpui::*;

fn main() {
    // OS에 맞는 창·글꼴 백엔드를 자동으로 고른다
    gpui_platform::application().run(|cx: &mut App| {
        cx.open_window(WindowOptions::default(), |_, cx| {
            // 여기서 루트 View(화면)를 만들어 돌려준다
            cx.new(|_| HelloWorld)
        });
    });
}
// HelloWorld 가 Render 트레잇을 구현하면, GPUI가 매 프레임 render()를 부른다

위 코드가 말하는 건 딱 하나다 — "앱을 켜고(application), 창을 열고(open_window), 그릴 화면(View)을 하나 등록한다." 복잡한 렌더링·GPU 호출은 전부 GPUI 안에 숨어 있고, 개발자는 "무엇을 그릴지"만 적는다. 배치는 div()에 Tailwind 비슷한 메서드(.flex().p_4() 식)를 붙여 표현한다.

용어
즉시 모드(immediate) vs 보존 모드(retained)
즉시 모드는 매 프레임 화면을 "처음부터 다시" 그리는 방식(게임이 그렇다 — 단순하고 빠르게 반응). 보존 모드는 화면 요소를 객체로 오래 들고 있다가 바뀐 데만 갱신하는 방식(웹의 DOM이 그렇다 — 상태 관리가 쉽다). GPUI는 둘을 섞어 "반응은 즉시 모드처럼 빠르게, 상태는 보존 모드처럼 안정적으로"를 노린다.

핵심 설계 3 — 단일 async 실행기 + Entity 소유 모델

Zed는 스레드를 마구 띄우는 대신, OS 이벤트 루프와 통합된 비동기 실행기(async executor) 하나 위에서 작업을 돌린다(smol 런타임 계열). 그리고 모든 앱 상태는 GPUI가 소유하는 Entity로 관리되어, Rc(참조 카운트 스마트 포인터) 비슷한 핸들로만 접근한다. 이 두 가지가 합쳐져 "데이터 경쟁(race) 없이도 빠른" 단일 모델을 만든다 — Rust의 소유권 규칙이 컴파일 시점에 사고를 막아준다.

핵심 설계 4 — 협업과 AI는 "같은 편집 스트림"으로

실시간 공동편집(다른 사람)과 AI 에이전트(모델)는 사실 Zed 입장에서 비슷한 일이다 — "내가 아닌 누군가가 버퍼를 고친다". 그래서 둘 다 편집 연산(operation)을 주고받는 같은 길을 탄다. 사람 편집은 rpc/proto로, AI 편집은 acp_thread·action_log로 흐르지만, 끝에서 만나는 곳은 같은 버퍼다. 그래서 "AI가 고친 걸 사람이 이어서 고치고, 그걸 또 다른 협업자가 보는" 일이 자연스럽다.

5디렉토리 구조 해부

"크레이트가 280개라 무섭지만, 사실 6~7개 그룹으로 묶인다."

저장소 루트는 단순하다. 거의 모든 코드는 crates/ 안에 있고, 나머지는 확장·도구·문서다.

zed/ ├── crates/ ← 코드의 99% (약 280개 크레이트) │ ├── zed/ 🚪 진입점. 실제 실행되는 메인 바이너리 │ ├── gpui/ 🎨 자체 UI 프레임워크 (+ gpui_wgpu·gpui_macos·gpui_linux·gpui_windows) │ ├── editor/ ✏️ 편집 화면의 심장 (커서·선택·스크롤) │ ├── text·rope·sum_tree·multi_buffer/ 📦 텍스트 자료구조·버퍼 │ ├── language·languages·lsp/ 🧠 구문 분석·언어 서버 │ ├── project·worktree·fs/ 📁 폴더·파일 감시 모델 │ ├── collab·rpc·proto·call·channel/ 👥 실시간 협업·네트워크 │ ├── livekit_client/ 🎙️ 음성·화면 공유 │ ├── agent·agent_ui·agent_servers/ 🤖 AI 에이전트 (+ acp_thread·acp_tools) │ ├── language_model·language_models/ 🔌 LLM 추상화 층 │ ├── anthropic·open_ai·google_ai·ollama·mistral·... 📡 모델별 어댑터 │ ├── edit_prediction*·zeta_prompt/ ⌨️ 다음 코드 예측(Zeta2) │ ├── extension·extension_host/ 🧩 WebAssembly 확장 실행 │ ├── vim/ terminal/ dap·debugger_ui/ ⚙️ Vim·터미널·디버거 │ ├── settings·theme·ui·icons/ 🎚️ 설정·테마·UI 컴포넌트 │ └── remote·remote_server·dev_container/ 🌐 원격 개발 ├── extensions/ 🧩 기본 동봉 확장 예시 (glsl·html·proto·test) ├── tooling/ 🛠️ 빌드·성능·라이선스 점검 도구 (perf·xtask·compliance) ├── docs/ 📚 공식 문서 소스 (zed.dev/docs 의 원본) ├── assets/ 🖼️ 아이콘·테마·키맵 기본값 ├── script/ 🧰 빌드·릴리스 셸 스크립트 └── Cargo.toml 🗺️ 워크스페이스 지도 (280개 크레이트 + 의존성 버전)

읽는 순서를 추천하면 이렇다. 처음 길을 잡을 땐 crates/zed(진입점) → crates/workspace(창 뼈대) → crates/editor(편집 화면) 순으로 따라가면 "앱이 켜지고 화면이 뜨는 흐름"이 잡힌다. UI 자체가 궁금하면 crates/gpui/README.md가 친절한 출발점이다.

용어
왜 크레이트를 이렇게 잘게 쪼갰나?
크레이트를 작게 나누면 ① 빌드가 병렬·증분으로 빨라지고(바뀐 크레이트만 다시 컴파일), ② 경계가 분명해져 "editor는 gpui를 쓰지만 gpui는 editor를 모른다" 같은 의존 방향이 강제된다. 루트 Cargo.toml은 단일 소스 파일 크레이트를 codegen-units = 1로 빌드하는 등, 빌드 속도 자체도 세밀하게 튜닝해 둔 게 인상적이다.

6학습 포인트 (기술별)

"Zed 한 채에 현대 시스템 프로그래밍의 거의 모든 주제가 들어 있다 — 보물창고처럼 골라 배우자."

Zed는 "큰 Rust 코드베이스"의 모범 사례라, 읽기만 해도 배울 게 많다. 분야별로 무엇을 배울지 + 작게 실습할 아이디어를 정리했다.

기술 ①

Rust — 대규모 실전 코드

배울 것: 소유권/빌림(borrow), 트레잇(trait) 설계, Rc/스마트 포인터로 상태 공유, 거대한 워크스페이스를 크레이트로 가르는 법, 빌드 프로파일 튜닝(Cargo.toml[profile.*]).

실습: crates/sum_treecrates/rope 같은 의존성 적고 자기완결적인 크레이트 하나를 골라 테스트부터 읽어보기. "이 자료구조가 무엇을 보장하나"를 테스트가 말해준다.

기술 ②

GPUI — GPU UI 프레임워크

배울 것: 즉시+보존 하이브리드 렌더, Entity-View-Element 모델, Tailwind식 선언적 배치, 이벤트→액션 변환(키맵), 통합 async 실행기.

실습: gpui_platform::application()으로 "버튼 누르면 숫자 올라가는 카운터" 만들기. GPUI 저장소의 examples/를 베끼며 시작하면 빠르다.

기술 ③

Tree-sitter — 구문 분석

배울 것: 소스코드를 문법 트리(AST 비슷)로 파싱하는 법, 그 트리로 색칠·코드 접기·구조 점프를 구현하는 원리. Zed가 만든 도구라 통합이 깊다.

실습: 작은 언어(예: 가짜 설정 언어)의 tree-sitter 문법을 직접 써 보고, Zed 확장으로 색칠이 먹는지 확인.

기술 ④

LSP / DAP — 언어 지능과 디버깅

배울 것: 에디터와 언어 서버가 JSON-RPC로 주고받는 메시지(자동완성·정의 이동·진단). DAP로 중단점·변수 검사를 붙이는 구조.

실습: crates/lsp가 서버 프로세스를 띄우고 메시지를 주고받는 부분을 따라 읽기. 로그를 켜고 실제 오가는 JSON을 관찰.

기술 ⑤

WebAssembly 확장 — 안전한 플러그인

배울 것: 왜 확장을 WASM으로 격리하나(악성·버그 확장이 에디터를 못 망가뜨리게), wasmtime으로 게스트 코드를 실행하고 host 함수를 노출하는 법.

실습: extensions/html·glsl 예시를 본떠 언어 하나 추가하는 최소 확장 만들기.

기술 ⑥

실시간 협업 · 분산 상태

배울 것: 여러 사람이 같은 글을 동시에 고칠 때 충돌 없이 합치는 방법(편집 연산 동기화), 자체 RPC(rpc·proto) 설계, 서버(collab)와 클라이언트의 역할 분담.

실습: 친구와 Zed 프로젝트를 공유해 같은 파일을 동시에 편집해 보고, "내 커서/상대 커서"가 어떻게 표시되는지 관찰 → crates/text의 연산 합치기 코드로 거슬러 올라가기.

기술 ⑦

AI 에이전트 통합 (ACP)

배울 것: 에이전트와 에디터를 잇는 표준 규약을 어떻게 설계하나, 에이전트의 "도구 호출"을 에디터 동작(파일 열기·편집)으로 안전하게 매핑하는 법(action_log로 추적·되돌리기).

실습: Zed의 Agent 패널에 ACP 에이전트를 붙여 보고, MCP 서버를 연결해 에이전트에게 도구를 추가해 주기.

7하드웨어 / 시스템 요구사항

"쓰는 건 가볍지만, 소스에서 빌드하는 건 묵직한 작업이다."

그냥 쓰기 (설치본)

일반 사용은 가볍다. macOS·Linux·Windows용 빌드를 zed.dev/download에서 받거나 패키지 매니저로 설치한다. 단, GPU 렌더가 핵심이라 그래픽 가속이 되는 환경이 필요하다(아주 오래된 가상머신·헤드리스 환경에선 렌더가 제한될 수 있다). 웹 버전은 아직 없다.

소스에서 빌드하기 (개발자)

플랫폼필요한 것
공통최신 stable Rust(rustup), 넉넉한 디스크·메모리(약 280개 크레이트 + 무거운 의존성 wasmtime·tree-sitter·livekit 등 → 첫 빌드는 길고 무겁다)
macOSXcode + command line tools(Metal 렌더·글꼴). xcode-select --switch로 정식 Xcode 지정
Linux / FreeBSD창 백엔드 최소 1개(Wayland 또는 X11), Vulkan 드라이버(wgpu)
WindowsWin32 + DirectWrite(별도 폰트 설정 불필요)
# 소스에서 Zed 빌드·실행 (개발 빌드)
git clone https://github.com/zed-industries/zed
cd zed
cargo run            # 첫 실행은 수백 개 크레이트를 컴파일 → 시간 걸림(커피 한 잔)

# 프레임 렌더 시간을 stderr로 출력 (성능 비교용 — 코드에 내장된 스위치)
export ZED_MEASUREMENTS=1
cargo run --release

복사해서 그대로 쳐도 된다. 핵심은 cargo run 한 줄이면 Zed가 통째로 빌드돼 뜬다는 것 — 다만 첫 빌드는 부품이 많아 오래 걸린다는 점만 각오하면 된다. ZED_MEASUREMENTS=1은 "한 프레임 그리는 데 몇 ms 걸렸나"를 찍어주는, 성능을 1순위로 여기는 이 프로젝트의 성격이 드러나는 스위치다.

8직접 해볼 수 있는 실습 과제

"읽기만 하면 안 남는다 — 난이도별로 손을 움직여 보자."

난이도 ★☆☆ — 입문

1. 테마·키맵 만지고 프레임 시간 보기

Zed를 설치하고 설정(JSON)·테마·키맵을 직접 바꿔본다. 그 다음 ZED_MEASUREMENTS=1로 켜서 "타이핑할 때 프레임이 몇 ms인지" 관찰. "내 입력이 몇 밀리초 만에 화면에 닿나"를 숫자로 느끼는 게 목표.

난이도 ★☆☆ — 입문

2. 공동편집 한 번 돌려보기

친구(또는 다른 계정)와 프로젝트를 공유해 같은 파일을 동시에 편집. 상대 커서·선택 영역이 실시간으로 보이는 걸 체험하고, "충돌이 왜 안 나는지" 궁금증을 메모해 둔다(→ 6절 기술⑥로 연결).

난이도 ★★☆ — 초중급

3. GPUI로 미니 앱 만들기

gpui 크레이트를 의존성에 넣고 application().run(...)으로 창 하나 + 버튼 + 카운터를 띄운다. div().flex().p_4() 식 배치 메서드를 익히는 게 핵심. GPUI examples/가 좋은 베이스.

난이도 ★★☆ — 초중급

4. 최소 확장(Extension) 하나 만들기

extensions/의 예시를 본떠 언어 하나를 추가하는 WASM 확장을 만든다. tree-sitter 문법을 연결해 색칠이 먹는지 확인. "확장이 왜 WASM으로 격리되나"를 몸으로 이해하게 된다.

난이도 ★★★ — 고급

5. 코드 한 흐름 추적 + 작은 기여(PR)

crates/zed(진입점)부터 workspaceeditor로 "앱이 켜지는 길"을 디버거/로그로 따라간다. 그 뒤 CONTRIBUTING.md를 읽고 문서 오타 수정·작은 버그 같은 첫 PR을 시도. 큰 모노레포에 기여하는 흐름(이슈→브랜치→CI→리뷰)을 경험.

9관련 기술 심화 학습 로드맵

"Rust를 모르는 상태에서 Zed에 기여하기까지 — 7주 코스 예시."

아래는 "Rust 입문자가 Zed 코드를 읽고 작게 기여할 수 있는 수준"까지의 한 가지 길이다. 본인 속도에 맞춰 늘리거나 줄여도 된다.

주차주제무엇을 / 왜
1주Rust 기초 + 소유권The Book으로 소유권·빌림·트레잇까지. Zed 코드의 90%는 이 개념 위에 있다
2주비동기 Rustasync/await와 실행기(executor) 개념. Zed의 smol 기반 단일 실행기를 이해하는 토대
3주GPUI로 작은 앱카운터·할 일 목록을 GPUI로. Entity-View-Element와 선언적 배치를 손에 익힘
4주Tree-sitter & LSP구문 트리로 색칠이 되는 원리, 언어 서버와 주고받는 메시지 관찰
5주WASM 확장wasmtime·확장 API. 최소 확장을 만들어 마켓 흐름까지 체험
6주자료구조 깊이 읽기sum_tree·rope 테스트부터 구현까지. "왜 빠른가"의 핵심
7주협업·기여편집 연산 동기화(text·rpc) 훑기 → CONTRIBUTING.md 보고 첫 PR
비유

Zed 코드베이스는 거대한 종합병원 같다. 처음부터 모든 과를 돌 필요는 없다. "응급실(진입점 crates/zed) → 내과(편집 엔진) → 영상의학과(GPUI 렌더)" 식으로 관심 가는 과 하나씩 깊이 보는 게, 280개 크레이트를 한 번에 삼키려다 체하는 것보다 낫다.

10핵심 키워드 사전

"이 문서와 Zed 코드에서 거듭 나오는 용어들 — 한 곳에 모아 풀었다."

용어
GPUI
Zed가 직접 만든 GPU 가속 UI 프레임워크(Rust). 즉시 모드와 보존 모드를 섞어, 매 프레임을 그래픽 카드에 직접 그린다. Zed가 빠른 근본 이유.
용어
Rope (로프)
긴 텍스트를 작은 조각으로 쪼개 트리에 담아둔 자료구조. 거대한 파일도 중간 편집을 빠르게 만든다. Zed에서는 SumTree 위에 구현된다.
용어
SumTree (합계 트리)
각 가지에 '요약 값'을 미리 계산해 둔 균형 트리. "N번째 글자 위치" 같은 질의를 로그 시간에 답한다. 텍스트·파일목록·이력에 두루 재사용되는 Zed의 만능 부품.
용어
Tree-sitter
소스코드를 문법 트리로 빠르게 파싱하는 라이브러리(Zed 팀 작품). 구문 색칠·코드 접기·구조 점프의 토대.
용어
LSP / DAP
LSP(언어 서버 규약)는 자동완성·오류표시 같은 언어 지능을, DAP(디버그 어댑터 규약)는 중단점·변수 검사 같은 디버깅을 — 둘 다 별도 프로그램에 표준 메시지로 위임하는 방식.
용어
ACP (Agent Client Protocol)
Zed가 만들어 공개한 "에이전트↔에디터" 표준 규약. 여러 AI 에이전트를 같은 방식으로 에디터에 꽂게 해준다. 1.0의 간판 기능.
용어
MCP (Model Context Protocol)
AI 모델/에이전트에 외부 도구·지식을 표준 방식으로 연결하는 규약. Zed에서는 ACP 에이전트에 MCP 서버를 붙여 능력을 확장한다(ACP가 '에이전트를 에디터에', MCP가 '도구를 에이전트에').
용어
Edit Prediction / Zeta2
다음에 칠 코드를 미리 제안하는 기능과, 그걸 구동하는 Zed의 공개 가중치 모델 Zeta2. 범용 추론이 아니라 "자동완성 속도"에 맞춰 튜닝됐다.
용어
wgpu / Metal
화면에 픽셀을 쏘는 그래픽 백엔드. wgpu는 크로스플랫폼(리눅스·윈도우), Metal은 애플 전용. GPUI가 이들 위에서 돈다.
용어
WebAssembly (WASM) / wasmtime
확장 코드를 안전하게 격리 실행하기 위한 휴대용 바이트코드와 그 실행기(wasmtime). 확장이 에디터 본체를 망가뜨리지 못하게 모래상자에 가둔다.
용어
멀티버퍼 (multi-buffer)
여러 파일의 일부 조각들을 한 편집 화면에 모아 보여주는 Zed 고유 개념. 검색 결과·AI 편집 묶음을 한 곳에서 손볼 때 쓰인다.
용어
크레이트 / 워크스페이스 / 모노레포
크레이트=Rust 패키지 단위, 워크스페이스=여러 크레이트를 함께 빌드하는 묶음, 모노레포=하나의 저장소에 모든 코드를 담는 방식. Zed는 약 280개 크레이트의 단일 워크스페이스 모노레포.

11참고 링크

공식 저장소·문서·개념 출처.

GitHub 저장소 · github.com/zed-industries/zed — 본체. crates/zed(진입점)와 crates/gpui/README.md부터 보면 좋다.

공식 사이트 · zed.dev — 다운로드·소개. AI 기능은 zed.dev/ai.

문서 · zed.dev/docs — 설치·개발·확장·AI 가이드(저장소 docs/가 원본).

Agent 패널 · zed.dev/docs/ai/agent-panel — AI 에이전트(ACP·MCP) 사용법.

블로그 · zed.dev/blog — 1.0·병렬 에이전트·Zeta2 등 발표 글.

TrendShift · trendshift.io/repositories/7272 — 트렌딩 추이.