Mountain ⛰️

+

Land 🏞️

+

---

Mountain ⛰️

The Bedrock of Land: Native Backend & Service Host.

The RAM tax is not optional. VS Code with a medium project: 500 MB to 1.5 GB of RAM. Three open windows means three Chromium renderer processes, each carrying a full heap. Every OS interaction crosses a serialized JSON IPC pipe.

"Where Electron takes 200 ms to open a dialog, Mountain takes 2."

   

📖 Rust API Documentation

Mountain⛰️ is the native Rust backend and Tauri application shell for the Land Code Editor. It serves as the foundational bedrock for the entire system, managing the application lifecycle, orchestrating native OS operations, and providing high-performance services to the Wind frontend and the Cocoon extension host.

Mountain⛰️ is engineered to:

1. Be the Native Core: Act as the primary Rust application, leveraging Tauri to create a lightweight, cross-platform windowing and WebView host.
2. Provide High-Performance Services: Implement the abstract service traits defined in the Common crate, offering native-speed implementations for filesystem I/O, process management, secure storage, and more.
3. Orchestrate Sidecars: Reliably launch, manage, and communicate with the Cocoon (Node.js) extension host sidecar via a robust gRPC interface.
4. Power the User Interface: Serve as the backend for the Wind layer, responding to requests via Tauri commands and pushing state updates via Tauri events.

---

Key Features 🔐

• Declarative Effect System: Built on a Rust ActionEffect system defined in the Common crate. Business logic is described as declarative, composable effects, executed by a central ApplicationRunTime.
• gRPC-Powered IPC: Hosts a tonic-based gRPC server (Vine) to provide a strongly-typed, high-performance communication channel for the Cocoon extension host.
• Centralized State Management: Utilizes a thread-safe, Tauri-managed ApplicationState as the single source of truth for the entire application's state, from open documents to provider registrations.
• Native PTY Management: Implements a full-featured integrated terminal service by spawning and managing native pseudo-terminals (PTY) using the portable-pty crate.
• Secure Storage Integration: Leverages the native OS keychain via the keyring crate to securely store sensitive data like authentication tokens.
• Robust Command Dispatching: A central Track dispatcher intelligently routes all incoming requests from Wind and Cocoon to the appropriate native Environment provider or ActionEffect.

---

Core Architecture Principles 🏗️

Principle	Description	Key Components
Implementation of Contracts	Implement the abstract service traits from Common, providing concrete logic for the application's architecture.	Environment/* providers
Separation of Concerns	Isolate service logic into distinct Environment provider modules, each responsible for a specific domain (e.g., FileSystem, Documents).	Environment/*, Command/*
Declarative Logic	Express complex operations as ActionEffects, executed by ApplicationRunTime - composable, testable, and robust.	RunTime/*, Track/EffectCreation.rs, Common
Centralized State	Maintain a single, thread-safe ApplicationState struct managed by Tauri for data consistency across the entire application.	ApplicationState/*
Secure & Performant IPC	Use gRPC for all communication with the Cocoon sidecar, ensuring a well-defined and high-performance API boundary.	Vine/*
UI-Backend Decoupling	Interact with Wind exclusively through asynchronous Tauri commands and events, keeping the backend UI-agnostic.	Binary/* (invoke handler), Command/*

---

Deep Dive & Component Breakdown 🔬

To understand how Mountain's internal components are structured and how they implement the application's core logic, see Documentation/GitHub/DeepDive.md. This document explains the roles of ApplicationRunTime, ApplicationState, Handler, Environment, and the Vine gRPC layer.

---

Mountain ⛰️ in the Land 🏞️ Ecosystem ⛰️ + 🏞️

This diagram illustrates Mountain's central role as the native orchestrator for the entire Land application.

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

    subgraph "⛰️ Mountain - Native Rust/Tauri Backend"
        TauriRuntime["🚀 Tauri App & Window"]:::mountain
        ApplicationRunTime["⚡ ApplicationRunTime Engine"]:::mountain
        ApplicationState["🗄️ ApplicationState - Shared State"]:::mountain
        TrackDispatcher["🔀 Track Dispatcher"]:::mountain
        VinegRPC["🌿 Vine - gRPC Server"]:::ipc
        EnvironmentProviders["⚙️ Environment Providers"]:::mountain
        CommonCrate["📐 Common Crate - Traits & DTOs"]:::common
    end

    subgraph "🖥️ Clients"
        WindUI["🍃 Wind / Sky - UI WebView"]:::wind
        CocoonSideCar["🦋 Cocoon - Extension Host (Node.js)"]:::cocoon
    end

    TauriRuntime -- hosts --> WindUI
    WindUI -- Tauri Command --> TrackDispatcher
    TrackDispatcher -- Tauri Events --> WindUI
    VinegRPC <-- gRPC --> CocoonSideCar
    VinegRPC -- forwards --> TrackDispatcher
    EnvironmentProviders -. implements traits .-> CommonCrate

Loading

---

Project Structure 🗺️

The Mountain repository is organized to clearly separate concerns, following the architectural patterns defined in Common.

Mountain/
├── Source/
│   ├── Library.rs                     # Library entry point, Tauri setup.
│   ├── LandFixTier.rs                 # Compile-time tier variable boot banner.
│   ├── Air/                           # gRPC client for the Air daemon (updates, auth, indexing, search, metrics).
│   ├── ApplicationState/              # Thread-safe state machine with DTOs, persistence, recovery, and feature state.
│   ├── Binary/                        # Application lifecycle, Tauri command registration, initialization, shutdown.
│   ├── Cache/                         # Asset memory-mapped cache and process-wide path canonicalization cache.
│   ├── Command/                       # Tauri command handlers grouped by domain (Keybinding, LanguageFeature, TreeView, etc.).
│   ├── Environment/                   # Concrete implementations of Common provider traits (filesystem, documents, terminal, etc.).
│   ├── Error/                         # Local error taxonomy (currently superseded by Common::CommonError).
│   ├── ExtensionManagement/           # Extension discovery, manifest parsing, and VSIX installation.
│   ├── FileSystem/                    # Native file-explorer tree-view provider for the workspace sidebar.
│   ├── IPC/                           # Inter-process communication: Tauri IPC server, Wind service handlers, encryption, permissions, status reporting.
│   ├── ProcessManagement/             # Sidecar process lifecycle, Node.js binary resolution (nvm, fnm, asdf, volta, homebrew, shipped).
│   ├── RPC/                           # gRPC service implementations (CocoonService) and scaffolding for multi-extension-host roadmap.
│   ├── RunTime/                       # Effect execution engine (ApplicationRunTime, Execute, graceful Shutdown).
│   ├── Telemetry/                     # Feature-gated observability: tracing, metrics, feature flags, and runtime gates.
│   ├── Track/                         # Central request dispatcher routing frontend and sidecar commands into ActionEffects.
│   ├── Update/                        # Application self-updating via Tauri bundled updater and optional Air gRPC delegation.
│   ├── Vine/                          # gRPC IPC layer: server, client, multiplexer, and generated protobuf bindings.
│   └── Workspace/                     # Workspace file (.code-workspace) parsing and multi-root folder resolution.
├── Proto/
│   └── Vine.proto                     # The gRPC contract definition file.
├── Documentation/
│   ├── GitHub/                        # DeepDive.md, NamingConventions.md
│   └── Rust/                          # Generated rustdoc output.
├── build.rs                           # Build script: proto compilation and tier propagation.
└── Cargo.toml

---

Development Setup 🛠️

Mountain is a Rust crate and a core component of the Land repository. It is built as part of the monorepo. For detailed build instructions, see Documentation/GitHub/Building.md.

Key Dependencies:

Crate / Package	Purpose
Common	Local path dependency - abstract traits & DTOs
Echo	Local path dependency - work-stealing scheduler
keyring	Secure OS keychain access
log & env_logger	Structured logging
portable-pty	Cross-platform native PTY for integrated terminal
serde & serde_json	Serialization / deserialization
tauri	^2.x - windowing, WebView, command dispatch
tokio	Async runtime
tonic	gRPC server implementation

---

See Also

• Mountain Documentation
• Architecture Overview
• Why Rust
• Why Tauri
• Cocoon
• Vine
• Echo
• Air

---

License ⚖️

This project is released into the public domain under the Creative Commons CC0 Universal license. You are free to use, modify, distribute, and build upon this work for any purpose, without any restrictions. For the full legal text, see the LICENSE file.

---

Changelog 📜

See CHANGELOG.md for a history of changes specific to Mountain⛰️.

---

Funding & Acknowledgements 🙏🏻

Mountain⛰️ is a core element of the Land🏞️ ecosystem. 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. Learn more at the NLnet project page.

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.

Land	PlayForm	NLnet	NGI0 Commons Fund

---

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