Rust framework for creating
fast and reliable web apps

You are very welcome to join our forum and chat!


Seed is a frontend Rust framework for creating fast and reliable web apps with an elm-like architecture.

  • All the benefits of Rust and macro based syntax.
  • Minimal overhead, configuration, and boilerplate.
  • Clear documentation made to be accessible regardless of your familiarity with Rust.
  • Written without any unsafe code and works with stable Rust, no nightly required!


If you already know Rust and Seed or frontend development basics, the examples provided in the repository are a good place to get started. They also act as an integration testing suite we run before every commit to ensure there are no unintended breaking changes to the user space. Because of Rust's compile-time checking, testing is that much more robust and changes can be pushed confidently.

You'll learn more about Rust and how to setup a new Seed project in next chapters, however if you are an experienced Rust developer and want to try something now - you can run examples with cargo make start example_name from the Seed repository root.

Here's our counter example:

use seed::{prelude::*, *};

// `init` describes what should happen when your app started.
fn init(_: Url, _: &mut impl Orders<Msg>) -> Model {

// `Model` describes our app state.
type Model = i32;

// `Msg` describes the different events you can modify state with.
enum Msg {

// `update` describes how to handle each `Msg`.
fn update(msg: Msg, model: &mut Model, _: &mut impl Orders<Msg>) {
    match msg {
        Msg::Increment => *model += 1,

// `view` describes what to display.
fn view(model: &Model) -> Node<Msg> {
        "This is a counter: ",
            ev(Ev::Click, |_| Msg::Increment),

pub fn start() {
    // Mount the `app` to the element with the `id` "app".
    App::start("app", init, update, view);


If you are proficient in a frontend framework, creating a standalone web app is painless. You'll notice minimal configuration:

├── Cargo.toml
├── Makefile.toml
├── index.html
└── src

We currently have two template repositories:

Why Use Seed


You may prefer writing in Rust and appreciate its benefits, including:

  • Rust safety.
  • Rust compile-time error, type, and immutability checking.
  • Rust built-in testing.
  • Rust speed.
  • Cleaner code and less runtime errors.
  • Cargo packages.
  • Potential pipeline/stack language consistency.

Developer Experience

Our main focus is on developer experience, the benefits of which are currently:

  • Seed has a batteries-included approach, meaning less boilerplate and dependencies.
  • Macro syntax removes the need for transpiling and integrates naturally and flexibly with the language. This also means all the pains of embedded HTML are avoided; linting, commenting, etc. all work out of the box.
  • Built in elm-like architecture, no need for another state manager.
  • Perhaps you find JS frameworks and tools difficult to set up.
  • Very active development.

Why Not Use Seed

  • Seed is under rapid development, so there may be breaking changes at times. However, Seed is more than stable enough for personal projects, and production apps are in development.
  • Finding Rust/WASM/Seed help outside of Discord or Discourse may be difficult, as tutorials and guides outside the official ones aren't yet prevalent.
  • Seed doesn't have as many existing reusable components that more mature frameworks have (date-pickers, etc.), so you may need to implement them yourself, or adapt them from existing solutions.