The Native Rust/WebAssembly Extension Host for Land 🏞️

VS Code extensions run with full Node.js capabilities in a shared process. A malicious or buggy extension can access any file, make any network request, and read another extension's state. The extension sandbox is a policy document, not a technical boundary.

"An extension can only touch what you explicitly grant. The sandbox is enforced by the hardware, not a policy."

Rust API Documentation 📖

Grove is the high-performance Rust/WebAssembly extension host for the Land Code Editor. It complements Cocoon (Node.js) by providing a native environment for running Rust and WASM-compiled VS Code extensions. Grove offers secure sandboxing through WASMtime, multiple transport strategies (gRPC, IPC, WASM), and full compatibility with the VS Code API surface.

VS Code extensions run with full Node.js capabilities in a shared process - a malicious or buggy extension can access any file, make any network request, and read another extension's state. Grove solves this by enforcing sandboxing at the hardware level: an extension can only touch what you explicitly grant.

Grove is engineered to:

1. Provide Native Extension Hosting - Execute Rust extensions with zero overhead through static linking or WASM sandboxing.
2. Enable Secure Sandboxing - Isolate untrusted extensions using WASMtime's capability-based security model with configurable memory limits and resource controls.
3. Support Multiple Transports - Communicate with Mountain via gRPC, IPC, or direct WASM host function calls for flexible deployment.
4. Maintain Cocoon Compatibility - Share the same VS Code API surface and activation semantics for seamless extension porting between the Node.js and native hosting environments.

WASM Runtime Integration - Full WebAssembly support through WASMtime, with capability-based security, configurable memory limits, CPU throttling, and explicit host-function grants. Extensions are sandboxed at the hardware level.

Multiple Transport Strategies - A strategy-pattern transport layer supporting gRPC (to Mountain's Vine server on port 50052), IPC (Unix socket for local communication), WASM (direct host function calls), and Mist (message-bus integration with the Mist pub/sub system).

Standalone Operation - Can run as an independent process with its own lifecycle, or connect to Mountain via gRPC for distributed deployment. The Transport/CommonAdapter unifies all transport backends behind a single interface.

Cross-Platform - Native support for macOS, Linux, and Windows with platform-specific optimizations. The Binary/Main/ entry point handles platform signal handling and daemon initialization.

VS Code API Compatibility - Implements vscode.d.ts type definitions through the APIBridge facade, with API/VSCode.rs providing typed wrappers for the full VS Code extension API surface including commands, windows, and notifications.

Secure by Default - #![deny(unsafe_code)] at the crate level, WASMtime capability-based isolation, configurable memory limits per extension, and explicit host-function grants ensure no extension can escape its sandbox.

graph LR
    classDef grove    fill:#d0d8ff,stroke:#4a6fa5,stroke-width:2px,color:#001050;
    classDef mountain fill:#f0d0ff,stroke:#9b59b6,stroke-width:2px,color:#2c0050;
    classDef wasm     fill:#d4f5d4,stroke:#27ae60,stroke-width:2px,color:#0a3a0a;
    classDef transport fill:#fff3c0,stroke:#f39c12,stroke-width:1px,stroke-dasharray:5 5,color:#5a3e00;
    classDef cocoon   fill:#cce8ff,stroke:#2980b9,stroke-width:1px,stroke-dasharray:5 5,color:#003050;

    subgraph GROVE["Grove 🌳 - Rust/WASM Extension Host"]
        direction TB
        subgraph HOST["Host/ - Extension Lifecycle"]
            ExtHost["ExtensionHost.rs 🏡 main controller"]:::grove
            ExtMgr["ExtensionManager.rs 🔍 discovery + loading"]:::grove
            Activation["Activation.rs ⚡ activation events"]:::grove
            Lifecycle["Lifecycle.rs"]:::grove
            APIBridge["APIBridge.rs 🌉 vscode.d.ts facade"]:::grove
            ExtHost --> ExtMgr --> Activation --> Lifecycle
            Activation --> APIBridge
        end
        subgraph API["API/ - VS Code API Surface"]
            VSCode["VSCode.rs 📋 typed API wrappers"]:::grove
            Types["Types.rs 🧱 shared type definitions"]:::grove
            APIBridge --> VSCode --> Types
        end
        subgraph WASM_RT["WASM/ - WASMtime Runtime"]
            WASMRuntime["Runtime/ 🚀 WASMtime engine + store"]:::wasm
            ModLoader["ModuleLoader/ 📦 compile + instantiate"]:::wasm
            MemMgr["MemoryManager/ 📏 allocation + limits"]:::wasm
            HostBridge["HostBridge/ 🔗 host↔WASM calls"]:::wasm
            WASMRuntime --> ModLoader
            ModLoader --> MemMgr
            WASMRuntime --> HostBridge
        end
        subgraph TRANSPORT["Transport/ - Strategy Pattern"]
            Strategy["Strategy.rs - trait"]:::transport
            CommonAdapter["CommonAdapter.rs 🔌 unified backend"]:::transport
            gRPC["gRPCTransport.rs"]:::transport
            IPC["IPCTransport.rs"]:::transport
            WASMTrans["WASMTransport.rs"]:::transport
            MistTrans["MistTransport.rs 💬 pub/sub bus"]:::transport
            Strategy --- CommonAdapter
            CommonAdapter --- gRPC
            CommonAdapter --- IPC
            CommonAdapter --- WASMTrans
            CommonAdapter --- MistTrans
        end
        subgraph PROTO["Protocol/"]
            SpineConn["SpineConnection.rs 🦴 Spine protocol"]:::grove
            SpineAction["SpineActionClient.rs 🎬 action dispatch"]:::grove
            SpineConn --> SpineAction
        end

        APIBridge --> WASMRuntime
        HostBridge --> Strategy
        SpineConn --> gRPC
    end

    subgraph MOUNTAIN["Mountain ⛰️"]
        VineGRPC["Vine gRPC Server 🌿"]:::mountain
    end

    subgraph COCOON["Cocoon 🦋 complementary host"]
        CocoonRef["Node.js extension host same vscode API surface"]:::cocoon
    end

    gRPC -- gRPC :50052 --> VineGRPC
    IPC -- Unix socket --> VineGRPC
    MistTrans -- message bus --> VineGRPC
    Grove -.shares API surface.-> CocoonRef

Connection paths:

Element/Grove/
├── Source/
│   ├── Library.rs                     # Library root (cdylib + rlib)
│   ├── main.rs                        # Binary entry point
│   ├── DevLog.rs                      # Development logging infrastructure
│   ├── API/                           # VS Code API surface
│   │   ├── mod.rs                     # Module re-exports
│   │   ├── VSCode.rs                  # Typed VS Code extension API wrappers
│   │   └── Types.rs                   # Shared API type definitions
│   ├── Binary/                        # Binary initialization
│   │   ├── mod.rs
│   │   ├── Build/                     # Build-time configuration
│   │   │   ├── mod.rs
│   │   │   ├── RuntimeBuild.rs        # Build-time runtime configuration
│   │   │   └── ServiceRegister.rs     # Service registration at build time
│   │   └── Main/                      # Main entry point + platform init
│   │       ├── mod.rs
│   │       └── Entry.rs               # Platform entry point and daemon init
│   ├── Common/                        # Shared traits and error types
│   │   ├── mod.rs
│   │   ├── Traits.rs                  # Core trait definitions
│   │   └── Error.rs                   # Unified error types
│   ├── Host/                          # Extension lifecycle management
│   │   ├── mod.rs
│   │   ├── ExtensionHost.rs           # Main host controller
│   │   ├── ExtensionManager.rs        # Discovery and loading
│   │   ├── Activation.rs              # Activation events
│   │   ├── Lifecycle.rs               # Lifecycle state machine
│   │   └── APIBridge.rs               # VS Code API facade
│   ├── Services/                      # Extension-level services
│   │   ├── mod.rs
│   │   └── ConfigurationService.rs    # Extension configuration management
│   ├── WASM/                          # WebAssembly runtime integration
│   │   ├── mod.rs
│   │   ├── Runtime.rs                 # WASMtime engine and store
│   │   ├── ModuleLoader.rs            # Module compilation + instantiation
│   │   ├── MemoryManager.rs           # Memory allocation and limits
│   │   ├── HostBridge.rs              # Host-to-WASM function calls
│   │   └── FunctionExport.rs          # Host function export to WASM
│   ├── Transport/                     # Communication strategies
│   │   ├── mod.rs
│   │   ├── Strategy.rs                # Transport strategy trait
│   │   ├── CommonAdapter.rs           # Unified transport backend
│   │   ├── gRPCTransport.rs           # gRPC to Mountain
│   │   ├── IPCTransport.rs            # Inter-process (Unix only)
│   │   ├── WASMTransport.rs           # Direct WASM communication
│   │   └── MistTransport.rs           # Mist message-bus integration
│   └── Protocol/                      # Protocol handling
│       ├── mod.rs
│       ├── SpineConnection.rs         # Spine protocol client
│       ├── SpineActionClient.rs       # Action dispatch
│       └── Generated/                 # Code-generated protocol types
│           └── grove.rs               # Generated gRPC service definitions
├── Documentation/
│   └── Rust/
│       └── doc/                       # Cargo doc output
├── Cargo.toml
└── LICENSE

Grove serves as the native Rust/WASM extension host alongside Cocoon (the Node.js host). Together they provide the two execution environments for the Land editor's extension model:

Grove communicates with Mountain via gRPC (port 50052), IPC (Unix socket), or the Mist message bus for event-driven workflows. It shares the same VS Code API surface as Cocoon, enabling seamless porting of extensions between the Node.js and native hosting environments.

The Transport/CommonAdapter abstracts all communication strategies behind a single interface, allowing deployment flexibility - standalone process, distributed via gRPC, or integrated with Mountain's Vine server.

• Rust 1.75 or later
• Protocol Buffer compiler (optional, for proto file modifications)
• For WASM builds: rustup target add wasm32-wasi

cd Element/Grove
cargo build --release

cd Element/Grove
cargo build --target wasm32-wasi --release

# All features enabled
cargo build --release --features all

# WASM only
cargo build --release --features wasm

# gRPC only
cargo build --release --features grpc

use grove::{ExtensionHost, Transport};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let Host = ExtensionHost::new(Transport::default()).await?;
    Host.load_extension("/path/to/extension").await?;
    Host.activate().await?;
    Ok(())
}

Grove enforces security at multiple layers:

Grove is designed to be compatible with:

• Rust API Documentation 📖

• Architecture Overview - Land system architecture
• Why WebAssembly - Why WASM for extension sandboxing
• CHANGELOG
  • Version history and release notes
• Mountain - Native desktop shell and gRPC backend
• Cocoon - Node.js/Effect-TS extension host
• Mist - Pub/sub message bus for event-driven workflows

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, under grant agreement No 101135429.

The project is operated by PlayForm, based in Sofia, Bulgaria. PlayForm acts as the open-source steward for Code Editor Land under the NGI0 Commons Fund grant.