Awesome Open Source
Awesome Open Source version downloads Built with cargo-make

Website | Forum | Chat

Seed is a front-end 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!


The examples provided in this 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.

To build any of examples, you need cargo-make. Install it by cargo install cargo-make (or see cargo-make for more).

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 front-end 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.

See more on our about page.

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.








Supported By


This project is supported by:

Official Website is served by Netlify.


Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
rust (4,309
webassembly (327
wasm (258
web-framework (141
frontend-framework (27

Find Open Source By Browsing 7,000 Topics Across 59 Categories