Library / SDK
sycamore-rs/sycamore avatar
sycamore-rs/sycamore

sycamore: reactive Rust with no virtual DOM, and a candid alternatives list

A library for creating reactive web apps in Rust and WebAssembly

3,369 stars170 forksRustMIT

At a glance

What is it?
A library for building web interfaces in Rust compiled to WebAssembly, organised as a nine-package Cargo workspace with a couple of dozen runnable examples. The most useful paragraph in the readme is the one that says where its ideas came from and who has the larger community.
Who is it for?
Sycamore suits a Rust developer who wants a fine-grained reactive interface and is willing to hold the rendering model in their head, rather than someone porting an existing JavaScript codebase. Two things to weigh first.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 3 days ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 22, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • sycamore-rs/sycamore3,369 ★ · +12
Star history
Repository2026-09-242026-11-22
sycamore-rs/sycamore3.4k3.4k

12 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Reactive primitives instead of a virtual DOM

The pitch is three claims, and the middle one is the design decision. It uses Rust compiled to WebAssembly for performance control, it builds on reactive primitives rather than a virtual document object model, and it lets you write the whole application without touching JavaScript. The smallest example shows how little ceremony that involves: a function annotated as a component returning a view macro invocation containing a paragraph with some text.

rust
#[component]
fn Hello() -> View {
    view! {
        p { "Hello World!" }
    }
}

The phrase about the virtual DOM is doing real work in that list. A framework that reconciles a tree has one update path; a library that tracks signals has another, and it is the reason a component here is annotated rather than wrapped in a runtime type. It is also the reason the alternatives section matters, since that choice is exactly what separates this project from the frameworks it points at.

Nine packages, and examples that are not default members

The workspace manifest is the clearest description of how the project is put together. Nine library packages make up the default members: the facade, a reactive core, a web layer, a router with its own macro crate, a view parser, a futures integration, and a procedural macro crate. Alongside them sit around two dozen example projects, which are declared as workspace members in their own right, and two benchmarking tools. The examples being members is the interesting part, because the manifest also restricts the default members to packages only, with a comment saying so explicitly.

That means a plain build compiles the library and nothing else. Examples are built when you ask, which keeps the fast path fast and stops an example from breaking the library's build. The flip side is that nothing in the default build proves the examples still compile, so the benchmark and comparison tools have to do that job separately.

A recent toolchain floor, and one version repeated everywhere

The shared package metadata sets the language edition to a recent one and names a specific minimum compiler release, which together define who can build this at all. That is worth checking first, because it is the kind of requirement that rules out an older pinned toolchain immediately rather than producing an error later. Version numbering is handled in a way that shows the cost of a workspace: every internal dependency is declared twice, once as a local path and once with the version string, so that a published crate depends on a registry copy of its siblings rather than on the local directory. The upside is that consumers of one crate do not need the workspace checked out. The downside is that a release means editing that version in many places, which is the kind of repetition that makes a consistent release script worth having.

Three rendering paths sit in the examples

The example list is a map of what the library actually supports, and the cluster around server-side rendering is the densest part of it. There is a plain server-rendered example, one that streams, and one that uses a suspense-based boundary, plus a separate hydration example. Read together, they say that the rendering path is a choice rather than a fixed assumption, and that the boundary between server output and client takeover is treated as a first-class concern rather than an afterthought. Alongside those sit examples for higher-order components and for context, which are the two features that tend to be awkward in a fine-grained model, and examples for attributes being passed through to the underlying elements. That last one is a small signal about how much of the underlying web platform the library exposes directly.

The performance claim comes with a benchmark directory

Two of the example directories and both of the workspace tools are about measurement rather than demonstration. One example is named for comparing against JavaScript frameworks, and the two tools under the packages directory are a benchmark and a benchmark differ, which is the pair you need to compare a result against a recorded baseline rather than against your memory of last week. That combination is the honest response to a performance claim, and it is more persuasive than the wording in the feature list, which promises speed and full control while providing no numbers. If you are evaluating this library against a JavaScript framework you already ship, those directories are where you would run the comparison rather than trusting the marketing phrasing or trusting your own timings from an unrelated application.

The readme says its design was borrowed from a JavaScript library

The alternatives section is the most credible paragraph in the file, because it is specific and it is unflattering in the right places. The first entry is a JavaScript library that the project says greatly inspired it, naming the two concepts it took: fine-grained reactivity, and components written as factory functions. The second is another Rust library on the same reactivity paradigm, which the project says shares many similarities and currently has the larger community. The third is a fullstack framework targeting web, desktop, and mobile, which the entry explains uses a virtual DOM for updating the page while using fine-grained reactivity for state management. So the three entries bracket the current project: same paradigm and borrowed ideas on one side, a bigger community on the other, and a different rendering model in the third.

Examples are hosted by name, and Trunk serves them locally

Trying the library takes two minutes by either route. Every example is published under a path built from the example's name, so a to-do example has its own address and can be linked to directly. For local work, the instructions are three lines: change into the example directory, run the serving command from a Web tooling project, and open a specific local port. Using the same tooling for every example means the local path and the hosted path behave alike, which is the main reason to prefer local work when you intend to change something. Documentation comes in two forms as well, a prose book that starts with the concepts and moves to advanced topics, and generated reference documentation for the facade crate. Questions go to a chat server, and the logo has a named credit in the readme, which is a small sign of how the project handles attribution.

Editorial conclusion

Sycamore suits a Rust developer who wants a fine-grained reactive interface and is willing to hold the rendering model in their head, rather than someone porting an existing JavaScript codebase. Two things to weigh first. The toolchain requirement is recent, so check your compiler version before anything else. And read the alternatives section honestly, because the project itself says a similar Rust library has the larger community and that its own design was borrowed from a JavaScript one.

Frequently asked questions

what is sycamore

A reactive library for building web applications in Rust, compiled to WebAssembly. You write a component as a function and describe its markup with a view macro, and the library is built on reactive primitives rather than a virtual DOM, so state changes update the page directly.

how to use sycamore

Add the crate, write a component, and render a view. To try it without installing anything, every example is published online under a path named after the example, and any example can also be built locally with the Web tooling project's serve command, which serves it on port 8080.

What alternatives to Sycamore does the project name?

A JavaScript library that it says greatly inspired it, with fine-grained reactivity and components as factory functions borrowed from that project; another Rust library on the same paradigm that shares many similarities and currently has the larger community; and a fullstack framework for web, desktop, and mobile that uses a virtual DOM for rendering while keeping fine-grained reactivity for state.

How is the Sycamore repository organised?

As a Cargo workspace with nine library packages, covering the facade, a reactive core, a web layer, a router and its macro, a view parser, a futures integration, and a procedural macro, alongside around two dozen example projects and two benchmarking tools. Only the packages are default members, so an ordinary build does not compile the examples.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. sycamore-rs/sycamore on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sycamore-rs-sycamore.svg)](https://hysenlabs.com/projects/sycamore-rs-sycamore)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sycamore-rs-sycamore.svg)](https://hysenlabs.com/projects/sycamore-rs-sycamore)

Was this useful?