Land
	Dependency 🖇️		Cargo 📦 Land 🏞️
	Dependency 🖇️ Land 🏞️		NPM 📦 Land 🏞️
	Echo 📣		Land 🏞️
	Editor 🏞️		Element 🌱
	Mountain ⛰️		River 🌊
	Sky 🌌		Sun ☀️
		Wind 🌬️

Welcome toLand! We are building a high-performance, resource-efficient, andcross-platform code editor inspired by the best of VS Code.Land isengineered with a modern stack –Rust for the backend (Mountain) andTauri for the native shell – to deliver a lightning-fast, memory-conscious,and deeply familiar editing experience for developers.

Our vision is to create a truly adaptable editor. It will not only match VSCode's core functionality but also offer a flexible foundation for runningextensions in various environments. This approach optimizes for performance,security, and specific use cases, giving developers the power and flexibilitythey need.

The Minimum Viable Product (MVP) aims to deliver a foundational yet functionaleditor demonstratingLand's core architecture and capabilities. Keydeliverables include:

1. Core Editor Functionality:
   • A runnableLand application where theSky frontend (UI) communicateswith theMountain backend (Rust) via theEcho interface andTrack dispatcher.
2. File System Operations:
   • Users will be able to browse directories, and open, edit, and save textfiles. This is powered by theNative Logic Flow inMountain, utilizingtheRiver (read) andSun (write) libraries.
3. WebSocket Communication:
   • Essential real-time communication pathways will be functional, handled bytheMist component (either native inMountain or as a sidecar).
4. OS Protocol Handling:
   • The application will handleOS-levelvscode:/ protocol invocations,allowingLand to be opened from external links or tools.
5. Basic Extension Support:
   • A foundationalExtension Host will be implemented (eitherCocoon forNode.js extensions or an initialGrove for nativeRust/WASMextensions). This will allow a limited subset of simpler extensions toload and operate, demonstrating the chosen pathway.
6. CustomRunner Integration:
   • A custom auxiliary process (namedRunner) will be reliably managed byMountain for specific background tasks.
7. Basic Build System:
   • A functional build process will compile all components and package arunnableTauri application for development and testing.

What this means for users at MVP: You'll be able to install and runLand, open and edit files, and see the groundwork for future extensionsupport and advanced features. The focus is on validating the core architectureand providing a stable base for future development.

Land's development is a phased journey towards its full vision:

1. MVP Path A (Current Focus -Cocoon Sidecar): Establish a functionalcore editor with aNode.js sidecar (Cocoon). This approach allows usto leverage the vast VS Code extension ecosystem quickly by running existingextensions, whileMountain andSky benefit fromTauri's nativeperformance.
2. MVP Path B (Future Goal -Grove Native Host): Develop aRust-native extension host (Grove). This aims to provide a highlyoptimized, secure, and performant environment for extensions, potentiallyenabling extensions written inRust or compiled toWASM.
3. Exploring Alternative Runtimes (Future Research): Investigate andpotentially support other lightweightJavaScript runtimes (e.g.,Deno,LLRT) as specialized extension sidecars where their uniquebenefits like security or startup speed are paramount.

This README primarily details the currentMVP Path A architecture and goals,with an eye towards these future evolutions.

No matter the extension host flavor,Land's core architecture (Mountain,Sky,Echo,Track,Vine,River,Sun,Mist,Runner) is designedfor modularity and performance:

Our immediate goal is to deliver a functionalLand editor by runningexisting VS Code extensions withinCocoon, a dedicatedNode.js sidecarprocess. This allows us to tap into the rich ecosystem of VS Code extensionsearly on.

Cocoon Architecture (Path A):

How it Works (Simplified for Path A):

1. Mountain (the mainRust application) launches theCocoonNode.jssidecar.
2. Cocoon initializes, loading the bundled VS Code platform code and theExtHostExtensionService.
3. An extension inCocoon calls avscode.*API (e.g.,vscode.workspace.fs.readFile).
4. AShim inCocoon intercepts this call.
5. TheShim sends a request viaVine (JSON over stdio) toMountain.
6. Mountain'sTrack dispatcher routes this request to the appropriateRust handler (e.g., usingRiver to read the file).
7. Mountain sends the result back toCocoon viaVine.
8. TheShim returns the result to the extension, completing theAPI call.

This approach aims for high compatibility with existingNode.js-based VSCode extensions by providing them with a familiar environment andAPIsurface.

WhileCocoon (Node.js sidecar) is our Path A for MVP,Land is designedwith future flexibility in mind to achieve greater performance, security, andpotentially support different classes of extensions.

Path B:Grove - The Native Rust Extension Host 🌳

Concept: A complete rewrite of the VS Code extension host logic inRust.Grove aims to run extensions (potentially those recompiled toWASM or newextensions written inRust/WASM) in a highly performant and securenative environment.

Goal: Drastically reduce the overhead of aNode.js runtime, improvesecurity throughRust's safety andWASM sandboxing, and enable deeperintegration withMountain.

Status: A longer-term vision. This involves reimplementing the entirevscode.*API surface inRust.

Alternative Runtimes (Conceptual Exploration) 🧪

Deno Sidecar: ExploreDeno for its security model andTypeScript-first approach.

LLRT Sidecar: InvestigateLLRT for ultra-lightweight, fast-startupextensions.

Achieving Feature Parity: Our long-term ambition is to achieve a high degreeof feature parity with VS Code. This will be an iterative process:

1. Core Editing & MVP Extensions (Path A): Ensuring basic text editing,file management (River/Sun), and core extensionAPIs functionreliably viaCocoon.
2. Expanding API Coverage (Path A/B): Incrementally implementing moreShims (Path A) or nativeAPI implementations (Path B -Grove) tosupport a wider range of extensions.
3. Native Feature Implementation: Re-implementing complex VS Code features(Debugging, SCM, Tasks, Rich UI Panels) natively inMountain andSky.
4. Performance & Stability: Continuously optimizing all components.

(Tracking feature parity is a manual process involving extensive testing andcomparison against VS Code.)

Our codebase is organized into "Elements," each with a distinct purpose. ManyElements that link to separate repositories are managed as Git submodules withinthe mainLand repository.

Follow these steps to getLand up and running on your system.

1. Clone the Repository:

   This command downloads theLand project files. The--recurse-submodules flag is crucial as it fetches all "Element"submodules and the VS Code source code dependency.

   git clone ssh://git@github.com/CodeEditorLand/Land.git --recurse-submodules

2. Install Dependencies:

   This command usespnpm (aNode.js package manager) to install allJavaScript dependencies required for building theSky frontend, theCocoon sidecar, and various development tools.

   pnpm install

3. Build the Application:

   The build process is multi-stage: it prepares VS Code dependencies (usingRest), bundlesJavaScript forCocoon, compiles theRust backend(Mountain and otherRust Elements), and finally builds theTauriapplication.

Build Variables Explained:

These variables control aspects of the build:

Development Build:

This command creates a development version ofLand, which usually includesmore debugging information and might build faster by skipping someoptimizations.

pnpm cross-env \Browser=true \Bundle=true \Clean=true \Dependency=Microsoft/VSCode \NODE_ENV=development \NODE_OPTIONS=--max-old-space-size=16384 \pnpm tauri build

Production Build (Release):

This command creates an optimized release version ofLand, suitable fordistribution.

pnpm cross-env \Browser=true \Bundle=true \Clean=true \Dependency=Microsoft/VSCode \NODE_ENV=production \NODE_OPTIONS=--max-old-space-size=16384 \pnpm tauri build --release

4. Run Land:

Development Mode:

This command startsLand in development mode. It typically enableshot-reloading for theSky frontend, allowing UI changes to be seen quicklywithout a full rebuild. This is the recommended way to runLand duringactive development.

pnpm run tauri dev

Production Build:

After a production build, the executable will be located inLand/Element/Mountain/target/release (or abundle subdirectory, depending onyourOS andTauri configuration). Run this executable to start theoptimized version ofLand.

When you runLand:

1. Mountain (theTauri app /Rust backend) starts up.
2. ForPath A (MVP),Mountain automatically launches theCocoonNode.js sidecar process.
3. TheSky UI loads in theTauri webview, presenting the editorinterface.
4. The MVP aims to demonstrate core functionality, such as opening files andloading a basic "Hello World" type extension viaCocoon, proving theTrack/Echo/Vine communication pathways are working.

(Refer to the detailed Mermaid diagram below or inARCHITECTURE.md for adeeper dive into component interactions!)

This diagram illustrates the build-time and runtime components for the MVPfocused on Path A (Cocoon sidecar).

 graph TD     %% Styling     classDef mountain fill:#f9f,stroke:#333,stroke-width:2px;     classDef cocoon fill:#ccf,stroke:#333,stroke-width:2px;     classDef sky fill:#9cf,stroke:#333,stroke-width:2px;     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;     classDef lib fill:#cfc,stroke:#333,stroke-width:1px;     subgraph "Build Time Process"         direction LR         VSCodeSource["VS Code Source (Submodule at Land/Dependency/.../Editor)"]:::build         RestBuild["JS Bundler (Rest Element)"]:::build         CocoonBundleJS(Cocoon JS Bundle):::data         SkyBuildProcess["Sky Build (Astro/Vite - 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 "Mountain (**Rust**/**Tauri** Backend - Mountain Element)"            TauriRuntime[**Tauri** Runtime]:::mountain;            TrackDispatcher[Track Dispatcher]:::mountain;            MountainHandlers["Native Handlers (FS: River/Sun, WS: Mist)"]:::mountain;            VineRustIPC["Vine (**Rust** IPC Layer)"]:::mountain;            ProcessMgmtSystem["Process Management (Cocoon, Auxiliary Runners)"]:::mountain;            RiverLib["River Lib"]:::lib;            SunLib["Sun Lib"]:::lib;            TauriRuntime -- Manages --> TrackDispatcher;            TrackDispatcher -- Routes to --> MountainHandlers;            MountainHandlers -- Uses --> RiverLib;            MountainHandlers -- Uses --> SunLib;            ProcessMgmtSystem -- Launches/Pipes --> CocoonSidecar;            ProcessMgmtSystem -- Manages --> RunnerProcess["Runner Process(es)"];            ProcessMgmtSystem -- Uses --> VineRustIPC;        end        subgraph "Sky (Frontend - **Tauri** Webview - Sky Element)"            SkyUI["Sky UI (**Astro**/**JS**/**TS**)"]:::sky            EchoFrontend["Echo **API** Client (**JS**)"]:::sky        end        subgraph "Cocoon (**Node.js** Sidecar - Cocoon Element)"            NodeJSProcess[**Node.js** Process]:::cocoon;            CocoonBootstrap["index.js (Bootstrap)"]:::cocoon;            CocoonVineIPC["cocoon-ipc.js (Vine **JS** Layer)"]:::cocoon;            CocoonShims[Shims/*.js]:::cocoon;            BundledVSCodeJS["Loaded VSCode Platform **JS** (from Rest)"]:::cocoon;            ExtHostServiceJS[ExtHostExtensionService]:::cocoon;            ExtensionCode[Extension Code]:::cocoon;            NodeJSProcess -- Runs --> CocoonBootstrap;            CocoonBootstrap -- Loads --> BundledVSCodeJS;            CocoonBootstrap -- Initializes --> CocoonShims;            CocoonBootstrap -- Initializes --> CocoonVineIPC;            CocoonBootstrap -- Initializes --> ExtHostServiceJS;            ExtHostServiceJS -- Uses --> CocoonShims;            ExtHostServiceJS -- Activates --> ExtensionCode;            CocoonShims -- Uses --> CocoonVineIPC;        end        SkyUI -- Uses --> EchoFrontend;        EchoFrontend -- **Tauri** `invoke` (Echo Action) --> TrackDispatcher;        VineRustIPC -- Vine Protocol (**JSON**/stdio) <--> CocoonVineIPC; class VineRustIPC,CocoonVineIPC ipc;        MountainHandlers -- Can send RPC via Vine --> CocoonVineIPC;        %% Extension making an **API** call implies CocoonShim intercepts and sends it out via Vine     end     CocoonBundleJS -- Packaged with --> CocoonSidecar;     SkyAssets -- Packaged into --> Mountain;

Stay updated with our progress! SeeCHANGELOG.md for a historyof changes.

Land is proud to be an open-source endeavor. Our journey is significantlysupported by:

This project is funded throughNGI0 Commons Fund, a fund established byNLnet with financial support from the European Commission'sNext Generation Internet program. Learn more at theNLnet project page.

Land	PlayForm	NLnet	NGI0 Commons Fund

Repositories