Land
	Common 🧑🏻‍🏭 + Land 🏞️		Echo 📣 + Land 🏞️
	River 🌊 + Land 🏞️		Sun ☀️ + 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 🌱

---

Land

🏞️

+

---

Welcome toLand! We are building a high-performance, resource-efficient, andcross-platform code editor inspired by the architecture of VS Code, butre-imagined with a modern, declarative, and type-safe stack.Land isengineered withRust andTauri for the native backend (Mountain) andTypeScript withEffect-TS for all application logic (Wind andCocoon).

Our vision is to deliver a lightning-fast and deeply reliable editing experienceby leveraging declarative, effects-based programming across the entireapplication. This architecture ensures that all side effects—from filesystemoperations to UI updates and network requests—are handled in a structured,testable, and composable way.

• Declarative Effect System: The entire application, from the Rust backendto the TypeScript frontend, is built on an effects-based architecture. We usea customActionEffect system in Rust andEffect-TS in TypeScript. Thisprovides compile-time guarantees for error handling, resource management, andasynchronicity, leading to exceptional stability.
• High-Performance Backend: TheMountain backend is written in Rust,providing native speed for all core operations like file I/O, search, andprocess management.
• High-Fidelity Extension Host: TheCocoon sidecar is a Node.js processdesigned to run existing VS Code extensions with high compatibility. Itprovides a sandboxedvscode API, built with Effect-TS, that communicateswithMountain for all native operations.
• Modern UI Services: TheWind project is a from-scratch, Effect-TS nativere-implementation of the VS Code workbench services, providing a clean,functional, and testable foundation for the UI.
• Strongly-Typed IPC: All communication between theMountain backend andtheCocoon extension host is handled viagRPC, ensuring a robust,performant, and strongly-typed API contract defined in a.proto file.

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

To understand how these components interact, please refer to the detailedworkflow descriptions indocs/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 launchingMountain,spawningCocoon, and establishing a stable, initialized state for boththe 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 thecontent being read from disk byMountain and rendered in an editor byWind.

3. Invoking a Language Feature (Hover Provider)

   • A key example of bi-directional communication, showing how an extensioninCocoon registers a feature,Mountain orchestrates the request, andthe result is displayed in theWind UI.

4. Saving a File with Save Participants

   • Explains the advanced process of intercepting a save event, allowing anextension inCocoon to modify a file (e.g., for formatting) beforeMountain writes it to disk.

5. Executing a Command from the Command Palette

   • Illustrates the unified command system, showing howMountain's commandregistry can seamlessly dispatch execution to either a native Rust handleror a proxied command inCocoon.

6. Creating and Interacting with a Webview Panel

   • Details the full lifecycle of extension-contributed UI, fromCocoonrequesting a panel toMountain managing the native webview window andproxying messages back and forth.

7. Creating and Interacting with an Integrated Terminal

   • A deep dive into native process management, showing howMountain spawnsa PTY process and streams its I/O to both theWind frontend and theCocoon extension host.

8. Source Control Management (SCM)

   • Outlines how the built-in Git extension inCocoon usesMountain as aservice to run nativegit commands and then populates the SCM view inthe UI with the results.

9. User Data Synchronization

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

10. Running Extension Tests

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

The following workflows are implemented in the codebase but are pending detaileddocumentation.

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

WhileCocoon provides high compatibility with the existing VS Code ecosystem,our long-term vision includesGrove, a native Rust extension host.Groveaims to provide a highly optimized, secure, and performant environment forextensions written in Rust or compiled to WASM, drastically reducing theoverhead of a Node.js runtime and enabling deeper integration withMountain.

Our codebase is organized into "Elements", each representing a distinctcomponent or library with a clear purpose. Most Elements are managed as Gitsubmodules within the mainLand repository, allowing for independentdevelopment and versioning.

This diagram illustrates the build-time and runtime interactions between theprimary 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;

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

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

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

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

pnpm install

The build process is multi-stage. It uses a set of environment variables tocontrol the output, allowing you to create either an optimized production buildor a flexible development build.

Build Variables Explained:

These variables are passed to our build scripts to configure their behavior:

Development Build:

This command creates a full development build of the application. The output isnot as optimized as a release build but is ideal for debugging.

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

Production Build (Release):

This command creates a fully optimized, minified, and production-ready versionofLand, suitable for packaging and distribution.

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

This is the primary command you will use during active development. It startsLand with hot-reloading enabled for the frontend, allowing UI changes to beseen instantly without a full application rebuild.

Notice thatBundle andCompile are set tofalse. This is becausetauri dev uses Vite (or a similar dev server) which handles module bundlingon-the-fly, providing a much faster development experience.

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

This project is released into the public domain under theCreative Commons CC0Universal license. You are free to use, modify, distribute, and build uponthis work for any purpose, without any restrictions. For the full legal text,see theLICENSEfile.

Stay updated with our progress! SeeCHANGELOG.mdfor a history of changes.

Land 🏞️ is proud to be an open-source endeavor. Our journey is significantlysupported by the organizations and projects that believe in the future ofopen-source software.

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

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

• Tauri: For providing a secure, performant, andresource-efficient framework for building our native desktop application witha web frontend.
• Microsoft Visual Studio Code: Foropen-sourcing their workbench UI and platform code, which provides thefoundation for our user interface and extension host compatibility.
• Effect-TS: For enabling us to build arobust, type-safe, and declarative application with a powerful structuredconcurrency and dependency management system in TypeScript.
• Rust: For the performance, safety, andmodern tooling that powers our entire native backend.
• Tokio &Tonic: For providing the asynchronousruntime and gRPC framework that are the backbone of our high-performance IPC.
• Astro: For its content-driven approach that allowsus to build a fast and modern user interface for theSky component.
• PNPM: For efficient and reliable management of ourJavaScript dependencies.
• and many many more...

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

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

Repositories