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.Heavy editor operations run in the native process, not the WebView. The separation is structural: the IPC boundary exists in the source regardless of which features are enabled in a given build.
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.Installed extensions run unmodified through the active compatibility path. Coverage across the full marketplace depends on which vscode APIs each extension uses - the core surfaces are implemented; long-tail APIs are an ongoing integration effort.
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.Failure paths are typed and explicit at every layer. When something goes wrong, the error surface is in the type system rather than a runtime exception.
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 has active installer coverage; Windows and Linux builds are configured and in preparation.
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.The daemon and service code are active source. Public installer delivery and the release signing pipeline are in preparation.
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 checksPrometheus-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 gRPCEffect-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
• 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 moreThe 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
• LowEnsures 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
• Fine-grained capability gatesExtensions cannot access host APIs unless explicitly granted.Multiple transport strategies:
• gRPC
• IPC
• Direct WASM host function callsShares 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 build profiles across the Land ecosystem:
• Development
• Debug
• ReleaseType-safe editing of Cargo.toml and project configuration through scriptable resolvers.Release pipeline preparation - signing, artifact publication, and distribution - is in progress.
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.Security model:
• ECDSA DNSSEC signing verifies zone integrity
• Loopback binding only - no external port exposureProvides 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
• OS keychainHosts 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
• Optional Rust-native compiler path for faster TypeScript compilationPlugin-routed transforms handle:
• Module resolution remapping
• Define substitution
• CSS import interception
• Dead code eliminationEnvironment-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
• Parallel compilationSelectable as an alternative compiler to reduce reliance on Node-hosted compilation paths.Source map output and measured pipeline benchmarks are in active development.
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
• ElectronSmart 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 - editor-host IPC
• Spine.proto - extension coordination
• Grove.proto - WASM extension protocolsCentralized 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
• SearchEach with explicit typed error handling and compile-time dependency tracking.Composed into Layer stacks that target specific runtimes:
• Tauri (native)
• Electron (compatibility)
• 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.Caching strategy:
• Network-first for navigation requests
• Cache-first for static assetsIntercepts 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
