Leptos is a full-stack, isomorphic Rust web framework that leverages fine-grained reactivity to build declarative user interfaces.

It’s worth noting that the framework is under active development. The developers kept it on the 0.0.x release cycle to show that it wasn’t even ready for 0.1.0. Active work is being done on documentation and features, and the API is not necessarily considered stable. At the same time, it’s not just a toy project or proof of concept, the authors are actively using it for their own application development.

use leptos::*;

#[component]
pub fn SimpleCounter(cx: Scope, initial_value: i32) -> Element {
    // create a reactive signal with the initial value
    let (value, set_value) = create_signal(cx, initial_value);

    // create event handlers for our buttons
    // note that `value` and `set_value` are `Copy`, so it's super easy to move them into closures
    let clear = move |_| set_value(0);
    let decrement = move |_| set_value.update(|value| *value -= 1);
    let increment = move |_| set_value.update(|value| *value += 1);

    // this JSX is compiled to an HTML template string for performance
    view! {
        cx,
        <div>
            <button on:click=clear>"Clear"</button>
            <button on:click=decrement>"-1"</button>
            <span>"Value: " {move || value().to_string()} "!"</span>
            <button on:click=increment>"+1"</button>
        </div>
    }
}

// Easy to use with Trunk (trunkrs.dev) or with a simple wasm-bindgen setup
pub fn main() {
    mount_to_body(|cx| view! { cx,  <SimpleCounter initial_value=3 /> })
}

Features:

• full stack: Leptos can be used to build applications that run in the browser (client-side rendering), on the server (server-side rendering), or by rendering HTML on the server and then adding interactivity (hydration) in the browser. This includes supporting HTTP streams of data (resources) and HTML (out-of-sequence streams for components).
• isomorphism: Leptos provides primitives for writing isomorphic server functions, i.e. functions that can be called “in the same form” on either the client or the server, but run only on the server. This means you can write your server-specific logic (database requests, authentication, etc.) next to the client components, and call server functions as if they were running in the browser.
• Web: Leptos is built on the web platform and web standards. The router is designed to take web fundamentals like links and forms and build on them, not try to replace them.
• frame: Leptos provides most of what you need to build a modern web application: a reactive system, a templating library, and a router that can run both server-side and client-side.
• fine-grained reactivity: The whole framework is built based on reactive primitives. This allows extremely efficient code to be written with minimal overhead: when the value of a reaction signal changes, it can update a single text node, toggle a single class, or remove an element from the DOM without running any other code. (So, no virtual DOM!)
• Declarative : Tell Leptos how you want the page to look and let the framework tell the browser what to do.