Land
	Common 🧑🏻‍🏭 + Land 🏞️		Echo 📣 + Land 🏞️
	Vine 🌿 + Land 🏞️		Mountain ⛰️ + Land 🏞️
	Rest ⛱️ + Land 🏞️		Output ⚫ + Land 🏞️
	Cocoon 🦋 + Land 🏞️		Wind 🍃 + Land 🏞️
	Worker 🍩 + Land 🏞️		Sky 🌌 + Land 🏞️
	Mist 🌫️ + Land 🏞️		Maintain 💪🏻 + Land 🏞️
	Grove 🌳 + Land 🏞️		Land 🏞️
	Editor 💻 + Land 🏞️		Element 🌱

Welcome to Land! We are building a high-performance, resource-efficient, and cross-platform code editor inspired by the architecture of VS Code, but re-imagined with a native Rust backend and a typed TypeScript service layer. Land is engineered with Rust and Tauri for the native backend (Mountain) and TypeScript for all application logic (Wind, Sky, and Cocoon). The product name is FIDDEE; Land is the repository and build system name.

Our vision is to deliver a lightning-fast and deeply reliable editing experience with ~88% VS Code API compatibility, so existing extensions run unmodified while the editor itself stays lean, auditable, and open-source.

• ~88% VS Code API Coverage: Cocoon implements the full vscode.* namespace shim — TextEditor, Workspace, SCM, Window, Language Server Protocol, Debug, Tasks, Authentication, TreeView, and more — so the majority of existing VS Code extensions run unmodified.
• High-Performance Native Backend: Mountain is written in Rust with Tauri, providing native speed for file I/O, search, process management, and a Tokio-based async runtime. IPC uses a custom ActionEffect system for structured error handling and composable side effects.
• Node.js Extension Host with Full vscode Shim: Cocoon runs standard VS Code extensions in a Node.js sidecar. It communicates with Mountain via gRPC (Vine protocol) for all privileged operations and with Sky via Tauri events for UI interactions.
• Effect-TS Service Layer: ~36 Wind services wire the VS Code workbench to Land's native backend. Each service is a typed Effect layer; dependencies are injected at startup rather than imported as globals.
• OSC 633 Terminal Shell Integration: Integrated terminals emit OSC 633 sequences for command zone detection, prompt anchoring, and shell-integration features. ShellIntegration.rs injects a per-terminal .zshrc shim at launch and restores ZDOTDIR cleanly on exit.
• AES-256-GCM Extension Credential Encryption: encryption:encrypt / encryption:decrypt IPC handlers use a machine-stable key derived from the hardware UUID (SHA-256). Extension secrets stored via context.secrets are encrypted at rest and never leave the local machine.
• Strongly-Typed gRPC IPC: All Mountain ↔ Cocoon communication is defined in Vine.proto and generated via prost-build. The contract is versioned in the Vine element and shared by both sides.
• Tier-Gated Implementation Selection: Every subsystem (file system, IPC routing, extension activation, telemetry) is switchable via PascalCase env vars baked into the build. TierIPC=NodeDeferred routes calls Mountain-first with a Cocoon fallback; no rebuild required to switch at runtime.

Land's architecture is composed of several key components that work in concert to deliver a modern editing experience.

To understand how these components interact, please refer to the detailed workflow descriptions in Documentation/GitHub/Workflow.md. The following provides a table of contents for these essential processes.

1. Application Startup & Handshake

   • Describes the complete end-to-end process of launching Mountain, spawning Cocoon, and establishing a stable, initialized state for both the UI and the extension host.

2. Opening a File from the UI

   • Details the flow from a user clicking a file in the explorer to the content being read from disk by Mountain and rendered in an editor by Wind.

3. Invoking a Language Feature (Hover Provider)

   • A key example of bi-directional communication, showing how an extension in Cocoon registers a feature, Mountain orchestrates the request, and the result is displayed in the Wind UI.

4. Saving a File with Save Participants

   • Explains the advanced process of intercepting a save event, allowing an extension in Cocoon to modify a file (e.g., for formatting) before Mountain writes it to disk.

5. Executing a Command from the Command Palette

   • Illustrates the unified command system, showing how Mountain's command registry can seamlessly dispatch execution to either a native Rust handler or a proxied command in Cocoon.

6. Creating and Interacting with a Webview Panel

   • Details the full lifecycle of extension-contributed UI, from Cocoon requesting a panel to Mountain managing the native webview window and proxying messages back and forth.

7. Creating and Interacting with an Integrated Terminal

   • A deep dive into native process management, showing how Mountain spawns a PTY process and streams its I/O to both the Wind frontend and the Cocoon extension host.

8. Source Control Management (SCM)

   • Outlines how the built-in Git extension in Cocoon uses Mountain as a service to run native git commands and then populates the SCM view in the UI with the results.

9. User Data Synchronization

   • Describes the end-to-end process of syncing user settings. It covers user authentication, fetching data from a remote store, performing a three-way merge, applying changes locally, and notifying all parts of the application.

10. Running Extension Tests

    • Explains the "Extension Development Host" model, where a second, isolated instance of the application is launched to run tests, with the test Cocoon instance remote-controlling the main UI.

The following workflows are implemented in the codebase but are pending detailed documentation.

• Tree View Data Flow
• Custom Editor Lifecycle
• Debugging Session Lifecycle
• Task Execution

While Cocoon provides high compatibility with the existing VS Code ecosystem, our long-term vision includes Grove, a native Rust extension host. Grove aims to provide a highly optimized, secure, and performant environment for extensions written in Rust or compiled to WASM, drastically reducing the overhead of a Node.js runtime and enabling deeper integration with Mountain.

Our codebase is organized into "Elements", each representing a distinct component or library with a clear purpose. Most Elements are managed as Git submodules within the main Land repository, allowing for independent development and versioning.

This diagram illustrates the build-time and runtime interactions between the primary components of the Land application.

graph LR
    classDef mountain fill:#f9f,stroke:#333,stroke-width:2px;
    classDef cocoon fill:#ccf,stroke:#333,stroke-width:2px;
    classDef wind fill:#9cf,stroke:#333,stroke-width:2px;
    classDef common fill:#cfc,stroke:#333,stroke-width:1px,stroke-dasharray: 5 5;
    classDef ipc fill:#ff9,stroke:#333,stroke-width:1px,stroke-dasharray: 5 5;
    classDef build fill:#ddd,stroke:#666;
    classDef data fill:#eee,stroke:#666;

    subgraph "Build Time Process"
        direction LR
        VSCodeSource["VS Code Source (Dependency/Editor)"]:::build
        RestBuild["JS Bundler (Rest Element)"]:::build
        CocoonBundleJS(Cocoon Runtime JS):::data
        SkyBuildProcess["Sky Build (Sky Element)"]:::build
        SkyAssets(Sky Frontend Assets):::data

        VSCodeSource --> RestBuild;
        VSCodeSource -- Uses 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]:::mountain
            NativeHandlers["Native Logic Handlers"]:::mountain
            ProcessMgmt["Process Management"]:::mountain

            Mountain -- Uses --> TrackDispatcher
            TrackDispatcher -- Routes to --> NativeHandlers
            Mountain -- Implements traits from --> CommonCrate
            Mountain -- Contains --> VineGRPCServer
            Mountain -- Contains --> ProcessMgmt
        end

        subgraph "UI Frontend (Tauri Webview)"
            WindServices["**Wind (Effect-TS Services)**"]:::wind
            SkyUI["**Sky (UI Components)**"]:::wind
            WindServices -- Drives state of --> SkyUI
        end

        subgraph "Extension Host (Node.js Sidecar)"
            Cocoon[**Cocoon Process**]:::cocoon
            VineGRPCClient[Vine gRPC Client]:::cocoon
            VSCodeAPI[vscode API Shim]:::cocoon
            Extension["Extension Code"]:::cocoon

            Cocoon -- Contains --> VineGRPCClient
            Cocoon -- Provides --> VSCodeAPI
            VSCodeAPI -- Used by --> Extension
        end

        ProcessMgmt -- Spawns & Manages --> Cocoon

        WindServices -- Tauri IPC (Commands & Events) --> TrackDispatcher
        VineGRPCClient -- gRPC (Vine Protocol) <--> VineGRPCServer; class VineGRPCClient,VineGRPCServer ipc;

    end

    CocoonBundleJS -- Loaded by --> Cocoon;
    SkyAssets -- Loaded by --> WindServices;

cd Dependency/Microsoft/Dependency/Editor
nvm use 24
git fetch --all
git reset --hard Parent/main
git clean -dfx
pnpm install
pnpm run compile
pnpm run compile-extensions-build

cd Land # back to repository root
export Trace=all Record=1 Disable=false
./Maintain/Debug/Build.sh --profile debug-electron-bundled

Clone each submodule individually on its target branch. Do NOT use git clone --recurse-submodules.

Run the build from the Land repository root after completing Step 1.

This project is released into the public domain under the Creative Commons CC0 Universal license. You are free to use, modify, distribute, and build upon this work for any purpose, without any restrictions. For the full legal text, see the LICENSE file.

Stay updated with our progress! See CHANGELOG.md for a history of changes.

Land 🏞️ is proud to be an open-source endeavor. Our journey is significantly supported by the organizations and projects 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

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

• Tauri: For providing a secure, performant, and resource-efficient framework for building our native desktop application with a web frontend.
• Microsoft Visual Studio Code: For open-sourcing their workbench UI and platform code, which provides the foundation for our user interface and extension host compatibility.
• Effect-TS: For enabling us to build a robust, type-safe, and declarative application with a powerful structured concurrency and dependency management system in TypeScript.
• Rust: For the performance, safety, and modern tooling that powers our entire native backend.
• Tokio & Tonic: For providing the asynchronous runtime and gRPC framework that are the backbone of our high-performance IPC.
• Astro: For its content-driven approach that allows us to build a fast and modern user interface for the Sky component.
• PNPM: For efficient and reliable management of our JavaScript dependencies.
• and many many more...

We extend our sincere gratitude to the maintainers and contributors of these and all the other dependencies we use. ❤️

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