بِسْمِ اللَّهِ الرَّحْمَنِ الرَّحِيم

MontRS is a Rust-native, trait-driven framework for building cross-platform applications. It provides a unified, deterministic environment for web, desktop, and mobile, powered by the performance of Leptos and the type safety of Rust. MontRS is The Leptos Framework

MontRS exists because building complex applications requires more than just a UI library. It requires a predictable architecture.

• Determinism: The same input should always produce the same output, whether in production or testing.
• Trait-Driven Boundaries: Features are encapsulated in Plates with explicit interfaces.
• Agent-first: Built-in metadata and structured snapshots make MontRS applications natively understandable by agents.

MontRS ships a fast dev loop with three levels of live updates:

• CSS & assets — instant, no recompile.
• view! hot reload — markup edits patch the live DOM in place; structure, text, and styling update without a rebuild.
• Rust hot-patching (experimental) — edit real Rust logic and see it in the running app without a restart: the server keeps running (same PID, in-flight state preserved) while a thin-linked patch is applied through a jump table at a render cutover.

Rust hot-patching is opt-in:

[serve]
hotpatch = true

Applications need no hot-patch code — they serve through one macro:

montrs_hotpatch::serve!(spec.router, || view! { <Shell /> });

See the Hot Reload & Hot Patching guide for the internals and the current limits (tip crate only).

The "Golden Path" is the recommended workflow for building robust MontRS applications:

1. Scaffold: Start with montrs new <app-name> to get a pre-configured workspace.
2. Define: Use #[derive(Validator)] to define your data models and validation rules.
3. Implement: Build features as Plates. Define unified Routes that bundle your Loader, Action, and View.
4. Verify: Use the TestRuntime for in-process, deterministic testing of your entire application spec.
5. Ship: Deploy to your target (Web, Server, or Desktop) using montrs build.

• Everything is a Trait: If you want to change behavior (ORM, Auth, Rendering), you implement a trait.
• Unified Routes: A single struct defines the path, parameters, data fetching, and visual representation for a URL.
• The AppSpec is Truth: Your entire application is defined by a serializable AppSpec, making it portable and inspectable.
• No Magic: We prefer explicit registration over reflection or global state.

use montrs::prelude::*;

#[derive(Validator, Serialize, Deserialize)]
struct Greeting {
    #[validator(min_len = 3)]
    name: String,
}

struct HelloPlate;

impl Plate<AppConfig> for HelloPlate {
    fn register_routes(&self, router: &mut Router<AppConfig>) {
        router.register(HelloRoute);
    }
}

struct HelloRoute;

impl Route<AppConfig> for HelloRoute {
    type Params = EmptyParams;
    type Loader = HelloLoader;
    type Action = EmptyAction;
    type View = HelloView;

    fn path() -> &'static str { "/hello" }
    fn loader(&self) -> Self::Loader { HelloLoader }
    fn action(&self) -> Self::Action { EmptyAction }
    fn view(&self) -> Self::View { HelloView }
}

Since MontRS is not yet published on crates.io, you'll need to build and install from source for local development.

• Rust toolchain: Install via rustup. MontRS pins a specific nightly version in rust-toolchain.toml — it will be installed automatically on first build.
• WASM target: Required for web builds.

  rustup target add wasm32-unknown-unknown

git clone https://github.com/afsall-inc/montrs.git
cd montrs

cargo build --package montrs-cli

The binary will be at target/debug/montrs (or target/debug/montrs.exe on Windows).

To make montrs available globally:

cargo install --path packages/cli

Alternatively, use cargo run from the project root:

cargo run --package montrs-cli -- <subcommand>

cargo run --package montrs-cli -- --help

Use the montrs CLI for common development tasks:

montrs fmt          # format all Rust and view! code
montrs test         # run all tests
montrs bench        # run performance benchmarks
montrs serve        # start the dev server with hot-reload
#   Rust hot-patching is opt-in: `[serve] hotpatch = true` in montrs.toml
montrs build        # build for production
montrs watch        # watch for changes and rebuild automatically
montrs agent check  # run agent-level diagnostics
montrs agent doctor # full health check

For linting, use cargo clippy directly:

cargo clippy --workspace -- -D warnings

Note for Framework Contributors: If you're working on MontRS itself, run montrs agent doctor after building to verify the environment is healthy.

People building apps with MontRS.

• First 30 Minutes: Start here! Your first onboarding experience.

• Introduction: Your first 10 minutes.

• The Golden Path: How to build the right way.

• Common Mistakes: Avoid frequent pitfalls and architectural anti-patterns.

  2. Framework Contributors

People working on MontRS itself.

• Architecture Overview: How the engine works.
• Package Boundaries: Responsibility of each crate.
• Invariants & Philosophy: The rules we don't break.

Machine-readable context for models.

• Agent-first design: Principles of machine-readability.
• Agent Usage Guide: How to use agent.json and tools.json.
• Spec Snapshot: Understanding the machine-readable project state.
• Skills System: Composable, reusable agent capabilities with multi-step workflows.
• PRDoc: Structured PR documentation for agent review.
• Metadata Markers: Look for @agent-tool, @agent-skill, and AgentError implementations in the source.

MontRS is dual-licensed under Apache-2.0 and MIT.