Build fast web applications with Rust.
Alternatives To Leptos
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
20 hours ago30mitRust
Build fast web applications with Rust.
Sycamore2,07984 days ago19June 26, 202247mitRust
A library for creating reactive web apps in Rust and WebAssembly
Binding.scala1,5751221 days ago119December 25, 201945mitScala
Reactive data-binding for Scala
Yox1,07957a month ago639May 06, 20223mitJavaScript
A lightweight mvvm framework
Vue Composable1,02554 months ago85October 17, 202120mitTypeScript
Vue composition-api composable components. i18n, validation, pagination, fetch, etc. +50 different composables
Sinuous9166102 months ago108February 13, 202215JavaScript
🧬 Light, fast, reactive UI library
Reflex Platform681
2 months ago90bsd-3-clauseNix
A curated package set and set of tools that let you build Haskell packages so they can run on a variety of platforms. reflex-platform is built on top of the nix package manager.
2 months ago14March 11, 20218mitRuby
Reactive frontend UI components for Rails in pure Ruby
Dom Expressions651161819 hours ago301July 15, 202222mitJavaScript
A Fine-Grained Runtime for Performant DOM Rendering
2484 months ago15October 04, 201625otherJavaScript
:fire: Meteor Blaze is a powerful library for creating live-updating user interfaces
Alternatives To Leptos
Select To Compare

Alternative Project Comparisons
Leptos Logo

crates.io docs.rs Discord


use leptos::*;

pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
    // 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);

    // create user interfaces with the declarative `view!` macro
    view! {
            <button on:click=clear>"Clear"</button>
            <button on:click=decrement>"-1"</button>
            <span>"Value: " {value} "!"</span>
            <button on:click=increment>"+1"</button>

// 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 /> })

About the Framework

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

What does that mean?

  • Full-stack: Leptos can be used to build apps 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 in the browser (hydration). This includes support for HTTP streaming of both data (Resources) and HTML (out-of-order streaming of <Suspense/> components.)
  • Isomorphic: Leptos provides primitives to write isomorphic server functions, i.e., functions that can be called with the same shape on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, 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 use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
  • Framework: Leptos provides most of what you need to build a modern web app: a reactive system, templating library, and a router that works on both the server and client side.
  • Fine-grained reactivity: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signals value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (So, no virtual DOM!)
  • Declarative: Tell Leptos how you want the page to look, and let the framework tell the browser how to do it.

Learn more

Here are some resources for learning more about Leptos:

nightly Note

Most of the examples assume youre using nightly Rust.

To set up your Rust toolchain using nightly (and add the ability to compile Rust to WebAssembly, if you havent already)

rustup toolchain install nightly
rustup default nightly
rustup target add wasm32-unknown-unknown

If youre on stable, note the following:

  1. You need to enable the "stable" flag in Cargo.toml: leptos = { version = "0.2", features = ["stable"] }
  2. nightly enables the function call syntax for accessing and setting signals. If youre using stable, youll just call .get(), .set(), or .update() manually. Check out the counters_stable example for examples of the correct API.


cargo-leptos is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use cargo-leptos and our starter template.

cargo install cargo-leptos
cargo leptos new --git https://github.com/leptos-rs/start
cd [your project name]
cargo leptos watch

Open browser on http://localhost:3000/


Whats up with the name?

Leptos () is an ancient Greek word meaning thin, light, refine, fine-grained. To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term leptospirosis, a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.

Is it production ready?

People usually mean one of three things by this question.

  1. Are the APIs stable? i.e., will I have to rewrite my whole app from Leptos 0.1 to 0.2 to 0.3 to 0.4, or can I write it now and benefit from new features and updates as new versions come?

With 0.1 the APIs are basically settled. Were adding new features, but were very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to, for example, a 0.2.0 release.

  1. Are there bugs?

Yes, Im sure there are. You can see from the state of our issue tracker over time that there arent that many bugs and theyre usually resolved pretty quickly. But for sure, there may be moments where you encounter something that requires a fix at the framework level, which may not be immediately resolved.

  1. Am I a consumer or a contributor?

This may be the big one: production ready implies a certain orientation to a library: that you can basically use it, without any special knowledge of its internals or ability to contribute. Everyone has this at some level in their stack: for example I (@gbj) dont have the capacity or knowledge to contribute to something like wasm-bindgen at this point: I simply rely on it to work.

There are several people in this community using Leptos right now for internal apps at work, who have also become significant contributors. I think this is the right level of production use for now. There may be missing features that you need, and you may end up building them! But for internal apps, if youre willing to build and contribute missing pieces along the way, the framework is definitely usable right now.

Can I use this for native GUI?

Sure! Obviously the view macro is for generating DOM nodes but you can use the reactive system to drive native any GUI toolkit that uses the same kind of object-oriented, event-callback-based framework as the DOM pretty easily. The principles are the same:

  • Use signals, derived signals, and memos to create your reactive system
  • Create GUI widgets
  • Use event listeners to update signals
  • Create effects to update the UI

I've put together a very simple GTK example so you can see what I mean.

How is this different from Yew/Dioxus?

On the surface level, these libraries may seem similar. Yew is, of course, the most mature Rust library for web UI development and has a huge ecosystem. Dioxus is similar in many ways, being heavily inspired by React. Here are some conceptual differences between Leptos and these frameworks:

  • VDOM vs. fine-grained: Yew is built on the virtual DOM (VDOM) model: state changes cause components to re-render, generating a new virtual DOM tree. Yew diffs this against the previous VDOM, and applies those patches to the actual DOM. Component functions rerun whenever state changes. Leptos takes an entirely different approach. Components run once, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
  • Performance: This has huge performance implications: Leptos is simply much faster at both creating and updating the UI than Yew is.
  • Mental model: Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. Your app can be divided into components based on what makes sense for your app, because they have no performance implications.

How is this different from Sycamore?

Conceptually, these two frameworks are very similar: because both are built on fine-grained reactivity, most apps will end up looking very similar between the two, and Sycamore or Leptos apps will both look a lot like SolidJS apps, in the same way that Yew or Dioxus can look a lot like React.

There are some practical differences that make a significant difference:

  • Maturity: Sycamore is obviously a much more mature and stable library with a larger ecosystem.

  • Templating: Leptos uses a JSX-like template format (built on syn-rsx) for its view macro. Sycamore offers the choice of its own templating DSL or a builder syntax.

  • Read-write segregation: Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like let (count, set_count) = create_signal(cx, 0); (If you prefer or if it's more convenient for your API, you can use create_rw_signal to give a unified read/write signal.)

  • Signals are functions: In Leptos, you can call a signal to access it rather than calling a specific method (so, count() instead of count.get()) This creates a more consistent mental model: accessing a reactive value is always a matter of calling a function. For example:

    let (count, set_count) = create_signal(cx, 0); // a signal
    let double_count = move || count() * 2; // a derived signal
    let memoized_count = create_memo(cx, move |_| count() * 3); // a memo
    // all are accessed by calling them
    assert_eq!(count(), 0);
    assert_eq!(double_count(), 0);
    assert_eq!(memoized_count(), 0);
    // this function can accept any of those signals
    fn do_work_on_signal(my_signal: impl Fn() -> i32) { ... }
  • Signals and scopes are 'static: Both Leptos and Sycamore ease the pain of moving signals in closures (in particular, event listeners) by making them Copy, to avoid the { let count = count.clone(); move |_| ... } that's very familiar in Rust UI code. Sycamore does this by using bump allocation to tie the lifetimes of its signals to its scopes: since references are Copy, &'a Signal<T> can be moved into a closure. Leptos does this by using arena allocation and passing around indices: types like ReadSignal<T>, WriteSignal<T>, and Memo<T> are actually wrappers for indices into an arena. This means that both scopes and signals are both Copy and 'static in Leptos, which means that they can be moved easily into closures without adding lifetime complexity.

Popular Dom Projects
Popular Reactive Projects
Popular Web User Interface Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.