Land 🏞️

+

---

Land 🏞️

The Code Editor built on Tauri + Rust + Effect-TS - replacing Electron piece by piece.

VS Code runs on Electron. That means a bundled Chromium browser, a Node.js runtime, and a single-threaded extension host. Open a medium project: 500 MB to 1.5 GB of RAM. Extensions compete on one thread. Updates kill your terminals. The RAM is never returned.

Land replaces VS Code's Electron stack piece by piece with fifteen independent elements. Rust and Tauri replace Chromium and Node.js. Effect-TS fibers replace Promise chains. Typed Tauri IPC replaces Node's untyped JSON pipe. The result: the same VS Code extension API surface on a leaner native substrate - less RAM, faster cold start, and structured concurrency that VS Code's single-threaded extension host cannot offer.

📖 Documentation 📦 Download 🔧 Rust API

---

Why Land Exists 📊

Pain	VS Code (Electron)	Land (Tauri + Effect-TS)
RAM per window	300–400 MB idle	Substantially less - no bundled Chromium, uses OS WebView
Cold start	2–4 s	Faster - no Chromium init; target <200 ms, not yet benchmarked
Extension blocking	One hung Promise freezes all	Each fiber is independently interruptible
IPC	Untyped JSON pipe	Typed Tauri IPC → Rust handlers; gRPC (Vine) for Cocoon
Extension isolation	Shared process, no boundary	Supervised fiber scopes (Grove: WASM sandbox, in progress)
Updates	Full restart, kills terminals	Pre-staged by Air between sessions
Telemetry	Config toggle, code paths remain	Compile flag: code paths do not exist when off
Distributable size	90–150 MB	~3–8 MB - no bundled browser
License	MIT (with restrictions)	CC0 public domain, no restrictions

---

What It Does 🔐

• VS Code extension API compatibility. Cocoon intercepts require/import and routes VS Code API calls through Effect-TS fibers. Core APIs are implemented; the full surface is an ongoing target as the extension host matures.
• No bundled browser. Mountain replaces Chromium with the OS's own WebView (WebView2 on Windows, WKWebView on macOS, WebKitGTK on Linux). No 300 MB base footprint.
• Structured concurrency, not just async. Effect-TS fibers can be interrupted, raced, and supervised. Extensions that block in VS Code can run concurrently in Land.
• Typed at the wire. Wind uses Tauri IPC to communicate with Mountain's Rust handlers. Vine starts every gRPC interface as a .proto file - change a message field and every consumer breaks at compile time, not in production.
• Always up to date, never interrupted. Air pre-downloads and PGP-verifies the next version between sessions. No "Restart to Update" prompt.
• CC0, no restrictions. Fork it. Ship it. Build commercial products on it. No attribution required.

---

Architecture 🏗️

Element	Role	Technology
Common	Abstract traits, ActionEffect system, DTOs	Rust
Mountain	Native backend: windows, files, processes, gRPC server	Rust, Tauri 2.0
Cocoon	Extension host: VS Code API on Effect-TS fibers	TypeScript, Node.js
Wind	Workbench services: Effect-TS Layers over Tauri IPC	TypeScript, Effect-TS
Sky	UI components: Astro, instant hot-reload in Tauri	TypeScript, Astro
Air	Background daemon: pre-staged updates, PGP verification	Rust
Echo	Work-stealing scheduler across all CPU cores	Rust
Vine	gRPC protocol: typed contracts from .proto files	Protobuf, Rust
Grove	WASM sandbox: capability-based extension isolation	Rust, WASMtime
Mist	DNS sandbox: local *.editor.land resolution	Rust
Rest	OXC-powered TypeScript compiler, 2–3× faster than esbuild	Rust, OXC
Output	Deterministic build artifacts with checksum verification	JavaScript
SideCar	Node.js binary distribution per target triple	Rust
Worker	Service Worker: auth encryption, offline support	TypeScript
Maintain	Build orchestrator: Rhai scripting, deterministic output	Rust, Rhai

---

System Architecture 🗺️

graph LR
    classDef mountain fill:#f0d0ff,stroke:#9b59b6,stroke-width:2px,color:#2c0050;
    classDef cocoon   fill:#d0d8ff,stroke:#4a6fa5,stroke-width:2px,color:#001050;
    classDef wind     fill:#cce8ff,stroke:#2980b9,stroke-width:2px,color:#00304a;
    classDef common   fill:#d4f5d4,stroke:#27ae60,stroke-width:1px,stroke-dasharray:5 5,color:#0a3a0a;
    classDef ipc      fill:#fff3c0,stroke:#f39c12,stroke-width:1px,stroke-dasharray:5 5,color:#5a3e00;
    classDef build    fill:#ebebeb,stroke:#888,color:#333;
    classDef data     fill:#f7f7f7,stroke:#aaa,color:#555;

    subgraph "🔨 Build Time"
        direction LR
        VSCodeSource["📦 VS Code Source"]:::build
        RestBuild["⚡ Rest - JS Bundler"]:::build
        CocoonBundleJS("📄 Cocoon Runtime JS"):::data
        SkyBuildProcess["🌌 Sky Build"]:::build
        SkyAssets("🖼️ Sky Frontend Assets"):::data

        VSCodeSource --> RestBuild
        VSCodeSource -- UI code --> SkyBuildProcess
        RestBuild --> CocoonBundleJS
        SkyBuildProcess --> SkyAssets
    end

    subgraph "🚀 Runtime - Land Application"
        subgraph "🦀 Native Backend - Rust"
            Mountain["⛰️ Mountain - Tauri App"]:::mountain
            CommonCrate["📐 Common Crate"]:::common
            TrackDispatcher["🔀 Track Dispatcher"]:::mountain
            VineGRPCServer["🌿 Vine - gRPC Server"]:::ipc
            NativeHandlers["⚙️ Native Handlers"]:::mountain
            ProcessMgmt["🔧 Process Management"]:::mountain

            Mountain --> TrackDispatcher
            TrackDispatcher --> NativeHandlers
            Mountain -. traits .-> CommonCrate
            Mountain --> VineGRPCServer
            Mountain --> ProcessMgmt
        end

        subgraph "🖥️ UI Frontend - Tauri WebView"
            WindServices["🍃 Wind - Effect-TS Services"]:::wind
            SkyUI["🌌 Sky - UI Components"]:::wind
            WindServices -- drives --> SkyUI
        end

        subgraph "🧩 Extension Host - Node.js Sidecar"
            Cocoon["🦋 Cocoon Process"]:::cocoon
            VineGRPCClient["🌿 Vine - gRPC Client"]:::ipc
            VSCodeAPI["🔌 vscode API Shim"]:::cocoon
            Extension["📦 Extension Code"]:::cocoon

            Cocoon --> VineGRPCClient
            Cocoon --> VSCodeAPI
            VSCodeAPI --> Extension
        end

        ProcessMgmt -- spawns --> Cocoon
        WindServices -- Tauri IPC --> TrackDispatcher
        VineGRPCClient <-- gRPC --> VineGRPCServer
    end

    CocoonBundleJS -- loaded by --> Cocoon
    SkyAssets -- loaded by --> WindServices

Loading

---

Architectural Workflows 📄

Detailed Mermaid-diagrammed workflows live in Documentation/GitHub/Workflow.md:

1. Application Startup & Handshake - Mountain launches, spawns Cocoon, establishes gRPC connection
2. Opening a File - UI click through Wind → Mountain → disk and back
3. Language Features - Bidirectional: Cocoon registers provider, Mountain proxies requests
4. Save Participants - Extensions modify files via gRPC before Mountain writes to disk
5. Command Palette - Unified dispatch to native Rust handlers or proxied extension commands
6. Webview Panels - Full lifecycle of extension-contributed UI
7. Integrated Terminal - Native PTY via portable-pty, xterm.js wired and working
8. SCM / Git - Cocoon's Git extension uses Mountain to spawn native git processes
9. User Data Sync - Auth, fetch, three-way merge, apply, notify
10. Extension Tests - Isolated "Extension Development Host" for test execution

---

Getting Started 🚀

# Clone with submodules
git clone --depth 2 ssh://git@github.com/CodeEditorLand/Land.git

# 1. In ./Land/ - initialize Element submodule
git submodule update --init Element

# 2. In ./Land/Element - initialize all Element submodules
git submodule update --init

# 3. In ./Land/ - initialize Dependency submodule
git submodule update --init Dependency

# 4. In ./Land/Dependency/ - initialize Microsoft dependencies
git submodule update --init Microsoft

# 5. In ./Land/Dependency/Microsoft - initialize Dependency
git submodule update --init Dependency

# 6. In ./Land/Dependency/Microsoft/Dependency - initialize VS Code source
git submodule update --init --depth 2 Editor

Build & Run 🔨

# Install JavaScript dependencies
pnpm install

# Build all TypeScript/JS packages
pnpm run prepublishOnly

# Build Rust workspace
cargo build

# Run the application
pnpm run Run

---

Live Deployments 🌐

Service	URL
Website	editor.land
Status	Status.Editor.Land
Rust API: Mountain	Rust.Documentation.Mountain.Editor.Land
Rust API: Common	Rust.Documentation.Common.Editor.Land
Rust API: Echo	Rust.Documentation.Echo.Editor.Land
Rust API: Air	Rust.Documentation.Air.Editor.Land
Rust API: SideCar	Rust.Documentation.SideCar.Editor.Land
Rust API: Rest	Rust.Documentation.Rest.Editor.Land
Rust API: Maintain	Rust.Documentation.Maintain.Editor.Land
Rust API: Workspace	Rust.Documentation.Land.Editor.Land
Knowledge Base	Knowledge.Editor.Land
Auth Worker	codeeditorland-auth.playform.workers.dev
Download Worker	codeeditorland-download.playform.workers.dev
Status Worker	codeeditorland-status.playform.workers.dev
Analytics Worker	codeeditorland-analytics.playform.workers.dev

---

License ⚖️

CC0 1.0 Universal. Public domain. No restrictions. LICENSE

---

Changelog 📜

See CHANGELOG.md for a history of changes.

---

Funding & Acknowledgements 🙏🏻

Land 🏞️ is proud to be an open-source endeavor, significantly supported by organizations that believe in the future of open-source software.

This project is funded through NGI0 Commons Fund, a fund established by NLnet with financial support from the European Commission's Next Generation Internet program. Learn more at the NLnet project page.

Land	PlayForm	NLnet	NGI0 Commons Fund

Technology Acknowledgements 🙌🏻

This project would not be possible without the incredible work of the open-source community. We are especially grateful for:

• Tauri - secure, performant, resource-efficient framework for native desktop apps with a web frontend.
• Microsoft Visual Studio Code - open-sourced workbench UI and platform code that provides the foundation for our UI and extension host compatibility.
• Effect-TS - robust, type-safe structured concurrency and dependency management in TypeScript.
• Rust - performance, safety, and modern tooling powering the entire native backend.
• Tokio & Tonic - async runtime and gRPC framework backbone of high-performance IPC.
• Astro - content-driven approach for the fast, modern Sky UI.
• xterm.js - terminal emulator powering the integrated terminal, with fixes contributed upstream from Land.
• portable-pty - cross-platform PTY backend driving the integrated terminal in Mountain.
• PNPM - efficient, reliable JavaScript dependency management.
• and many more…

We extend our sincere gratitude to all maintainers and contributors. ❤️

---

Project Maintainers: Source Open (Source/Open@Editor.Land) | GitHub Repository | Report an Issue | Security Policy