DEV Community

John Still
John Still

Posted on

I Tried Replacing JavaScript with Rust + WASM for Frontend. Here's What Happened.

#rust #webassembly #frontend #programming

TL;DR: Rust + WebAssembly is promising — especially for performance-heavy tools — but it's no JS killer (yet). Still, with tools like ServBay, setting up local dev is easier than you'd expect.

Why Rust? Why Not JS?

I’ve been writing JavaScript for years, and to be honest, I’ve grown a bit tired of its loose types, fragile tooling, and cryptic errors. I stumbled on this post on Reddit that hit home:

“I hate JS. I’ve done the HTML and CSS, but I’m stuck. I want to use Rust instead.”

That got me thinking: What if I could build the frontend using Rust + WASM instead of JS?

Is It Even Technically Feasible?

Surprisingly, yes.

Thanks to WebAssembly, you can compile Rust into .wasm files that run in modern browsers. Several Rust UI frameworks already support this:

Frameworks:

  • Yew: A React-like experience, solid and stable.
  • Dioxus: Multi-platform (web, desktop, mobile) and actively developed.
  • Sycamore: Focused on performance, similar to SolidJS.
  • Leptos: A newer player with fast builds and great ergonomics.

Build tools:

  • wasm-pack: For generating npm-compatible WASM packages.
  • trunk: Like Vite, supports hot reload and bundling.
  • cargo-leptos: Tailored for Leptos projects.

So yes, Rust can build frontends — but the ecosystem is still growing and not nearly as mature as React/Vue/Svelte.

What About DOM, SEO, Accessibility?

These were common concerns when I shared this on Chinese dev platforms:

  • No direct DOM API in WASM: Rust must use JavaScript bridges (via web-sys, wasm-bindgen) to touch the DOM.
  • No SEO benefits: WASM-generated pages are dynamic by default — search engines can’t parse content.
  • Accessibility? Also JavaScript’s job — unless you reimplement a11y from scratch.

So if you're building a blog, landing page, or e-commerce site — Rust + WASM is not your friend. But if you’re creating dashboards, internal tools, or embedded UIs? Keep reading.

Real Dev Experience: The Good, the Weird, the Hacky

🔼 Performance? Definitely noticeable.

If you're rendering charts, crunching numbers, or visualizing data — Rust + WASM performs better than most JS frameworks. Sycamore and Leptos score well in krausest’s benchmarks. Zero runtime overhead, no garbage collection surprises.

⚠️ Learning curve? Steep.

  • Rust's ownership model takes time.
  • WASM debugging is painful (DevTools won’t show proper stack traces unless you configure source maps).
  • You still need JS glue code for DOM interop.

🛠️ Build process? Fragile, but fixable.

That’s where ServBay came in handy. It’s a lightweight local server tool (originally built for PHP/Node), but perfect for WASM too.

Here's what I liked about it:

  • ✅ Instant HTTPS support (WASM often requires secure context)
  • ✅ No need for nginx, no port juggling
  • ✅ Static folder support — just point it to dist/ and go

Example: I built a Dioxus app like this:

fn app(cx: Scope) -> Element {
    cx.render(rsx!(
        div {
            h1 { "Hello, Rust frontend!" }
            button { onclick: |_| println!("Clicked!"), "Click me" }
        }
    ))
}
Enter fullscreen mode Exit fullscreen mode

Compiled with trunk build --release, served via ServBay — done. One command, no config hell.

So, Who Should Use Rust for Frontend?

✅ Good fit for:

  • Internal dashboards or admin panels
  • Data-heavy visualizations
  • Embedded UIs on edge devices
  • Full-stack Rust teams wanting type safety all the way down

❌ Not great for:

  • SEO-sensitive content (blogs, e-commerce, marketing)
  • Heavily interactive sites with animations
  • Projects needing rich JS ecosystem components

In short: Rust + WASM isn’t a replacement for React — but it can complement it. For example, I now use Rust for the data-heavy core logic and keep React/TS for UI glue.

What’s Next?

WebAssembly continues to evolve:

  • Interface Types will make JS ↔ WASM interop much smoother
  • GC support is being proposed — could enable direct DOM access one day
  • Frameworks like Dioxus and Leptos are growing fast

Rust won’t dethrone JS — but for niche, performance-sensitive web apps, it’s becoming a legit option.

Final Thoughts

Rust + WASM won’t replace JavaScript — yet.

But it’s worth exploring, especially for small tools, internal apps, and devs already fluent in Rust. With tools like ServBay, the barrier to entry is getting lower. You no longer need to fight nginx or Docker just to serve static WASM files locally.

👋 Have you tried using Rust for frontend work? Share your experience — curious to know what worked (or didn’t) for you.

Top comments (0)