Tech Stack
Mountain handles window management, file I/O, child processes, terminal IPC, and extension communication through Tauri - using the ActionEffect system for declarative, dispatchable operations. Echo provides work-stealing scheduler primitives for bounded background work.That gives Land a native path to move heavy editor work out of the WebView without claiming benchmark numbers before a reproducible suite exists.
Cocoon hosts existing VS Code extensions using Effect-TS through a dual-track architecture: Track A loads unmodified extHost sources for maximum compatibility, Track B routes I/O-heavy operations to Mountain through gRPC. The vscode API shim covers commands, workspace, terminals, webviews, language providers, and diagnostics.Extensions run unmodified through the active compatibility path. Marketplace-wide coverage still depends on each extension API usage and on services still being filled in.
Effect-TS gives Cocoon and Wind typed errors, scoped resources, explicit cancellability, and supervised concurrency for extension-host and workbench services. Wind composes services into Layer stacks that target specific runtimes - native, compatibility, or test - with compile-time dependency tracking.That does not remove every runtime bug, but it does make failure paths explicit and traceable through the services Land controls.
Tauri uses the OS WebView on each platform instead of a bundled Chromium instance. Mountain's desktop path has no embedded browser engine. Per-platform binary management keeps cross-compilation paths explicit and reproducible.The repository includes macOS, Windows, and Linux build configuration. macOS is the primary path, with Windows and Linux installer coverage still being completed.
Air provides persistent background services for update downloads and verification, file indexing, cryptographic signing, and health monitoring. Runs as an independent daemon - persists when the main window closes.Those services are real source today. The public updater flow, signing story, and release distribution path are still being finished.
Most open source editors have license clauses that restrict commercial use, require attribution, or forbid forking the UI.The entire Land codebase is CC0 public domain. Use it, fork it, ship it, build commercial products on top of it. No attribution required. No compliance headaches.
Elements
Roadmap
Elements
Roadmap
Persistent background daemon that offloads heavy operations from Mountain: update downloads with staged atomic rollback, file indexing and symbol extraction, cryptographic signing and authentication, health monitoring with multi-level checks.
Prometheus-compatible metrics and distributed tracing with sampling.
Runs independently - persists when the main window closes.
Release signing and public installer delivery are still being completed
Background Services - Downloader - Workspace Indexer
Node.js sidecar that hosts and executes VS Code extensions. Dual-track architecture: Track A loads unmodified extHost sources for maximum compatibility, Track B routes I/O-heavy operations to Mountain through gRPC.
Effect-TS provides typed errors, scoped resources, and supervised concurrency across all services.
Codegen pipeline walks VS Code extHost source to emit type schemas.
Core API surfaces: commands, workspace, window, terminal, webview, language providers, and diagnostics.
Extension Host - Unmodified VS Code Extensions - Effect-TS Services
Pure abstract library - defines the contracts that all Rust components implement, not the implementations themselves.
Async traits for every service domain: FileSystem, Terminal, Clipboard, Window, Configuration, Storage, Search, and more.
The ActionEffect system treats every operation as declarative data - commands, events, and queries share a single type hierarchy across all layers.
Transport-agnostic: supports gRPC, IPC, and WASM strategies. Dual-pipe telemetry (PostHog + OTLP).
Shared Foundation - Traits - Cross-Element Types
Work-stealing task scheduler with lock-free queues for bounded background execution.
Priority tiers (High/Normal/Low) ensure UI responsiveness stays predictable under I/O load.
Workers consume from local queues and steal from peers when idle. Integrates with the ActionEffect system for cancelable, supervised tasks.
Graceful shutdown paths keep resources from leaking when services terminate.
Work-Stealing Scheduler - crossbeam-deque - Supervised Worker Pool
WebAssembly sandbox for running extensions in capability-isolated environments.
WASMtime provides memory limits, resource controls, and fine-grained capability gates - extensions cannot access host APIs unless explicitly granted.
Multiple transport strategies: gRPC, IPC, or direct WASM host function calls. Shares the same VS Code API surface as Cocoon.
Complements Cocoon's Node.js path with a sandboxed execution alternative.
WASM Sandbox - Wasmtime Runtime - Capability-Based Isolation
Build system using an embedded Rhai scripting engine for flexible cross-element orchestration.
Manages development, debug, and release build profiles across the Land ecosystem.
Type-safe editing of Cargo.toml and project configuration through scriptable resolvers.
Deterministic release claims are held until the public release pipeline is fully published.
Build Orchestrator - Configuration - Release Profiles
Local DNS server authoritative for the land.playform.cloud zone - all subdomains resolve to loopback, keeping internal services off the network.
Forward allowlisting controls which external domains sidecar processes can reach; everything else is blocked at the DNS layer.
ECDSA DNSSEC signing verifies zone integrity. Loopback binding only - no external port exposure.
Provides network isolation for Cocoon and Air processes so they cannot leak data to arbitrary hosts.
Local DNS Sandbox - *.land.playform.cloud Resolution - Network Boundary
Primary native backend and Tauri application shell - replaces the Electron main process entirely.
Implements all service traits from Common through the declarative ActionEffect system: windows, files, terminals, clipboard, dialogs, process control, and OS keychain.
Hosts the gRPC server for cross-process communication with Cocoon, Air, and Grove.
Orchestrates sidecar lifecycle and manages application state across all connected processes.
Native Rust Backend - Tauri - Replaces Electron Main Process
Build orchestration for VS Code platform source code. Dual-compiler pipeline: primary ESBuild with an optional Rust-native compiler path for faster TypeScript compilation.
Plugin-routed transforms handle module resolution remapping, define substitution, CSS import interception, and dead code elimination.
Environment-variable-driven compiler selection. Platform code markers separate platform-specific and cross-platform code at the source level.
Consumed by Cocoon, Sky, and Wind as the shared compilation output.
Compilation Pipeline - Plugin-Routed - Deterministic Checksum
Rust-native TypeScript compilation pipeline built on the OXC toolchain - parser, transformer, and codegen in one process.
Handles decorator metadata emission, legacy class field semantics, JSX, and parallel compilation.
Selectable as an alternative compiler to reduce reliance on Node-hosted compilation paths.
Source maps and public benchmark claims remain integration work.
TypeScript Transform Pipeline - OXC - Rust-Native
Manages pre-compiled platform-specific Node.js binaries for each target platform.
Compile-time binary selection ensures the right runtime is available without runtime detection or download delays.
Integrity verification and cache management keep sidecar deployments deterministic and reproducible across build environments.
Binary Distributor - Compile-Time Target Triple Selection - Per-Platform Node.js
Renders the editor interface in the OS WebView using Astro component islands for efficient rendering.
SkyBridge routes Tauri events to VS Code workbench APIs, translating runtime channels into workbench calls.
Supports multiple workbench layouts that adapt the UI layer to different runtimes: browser proxy, Mountain-native, or Electron.
Smart variant selection with conditional imports and tree-shaking keeps the bundle size target-specific.
Visual UI Layer - Astro Components - Three Workbench Layouts
Protocol definitions for gRPC communication between Mountain, Cocoon, Air, and Grove.
Current proto contracts live in Mountain/Proto/ and Cocoon: Vine.proto for editor-host IPC, Spine.proto for extension coordination, and Grove.proto for WASM extension protocols.
Centralized consolidation into the Vine element is planned as the protocol surface stabilizes.
gRPC Backbone - Contract-First - .proto Definitions
UI service layer that recreates the VS Code workbench environment inside the Tauri WebView.
Effect-TS services cover IPC, Configuration, Editor, Terminal, Clipboard, Dialog, FileSystem, Window, and Search - each with explicit typed error handling and compile-time dependency tracking.
Composed into Layer stacks that target specific runtimes: Tauri (native), Electron (compatibility), and Test (isolated).
Preload shim establishes the bridge between VS Code workbench expectations and the Tauri runtime environment.
Workbench Services - Effect-TS Layers - Native Bridges
Service worker that provides offline caching and dynamic CSS import handling for the web shell.
Network-first strategy for navigation requests, cache-first for static assets.
Intercepts JavaScript imports of CSS files and injects them as <link> tags - handles VS Code's pattern of importing stylesheets as JS modules.
Automatic update detection with client reload when a new version is available.
Service Worker - Offline Cache - CSS Import Support
Universal Binary: Apple Silicon and Intel
64-bit (x64)
DEB, RPM, AppImage
