We Built Our Marketing Website Entirely in Rust
Marketing sites have a reputation for being the place where engineering standards go to die. A WordPress install here, a Webflow export there, a rogue Next.js project that nobody on the team actually knows how to deploy. We decided to do something different.
flux.dev is built entirely in Rust. Static content via Zola. Interactive components via Leptos WASM islands. The whole thing builds in 30 seconds and every content page is pure static HTML with zero JavaScript.
Here’s how it works and why we made this call.
The Challenge
A marketing site for a developer tools company has two competing requirements. First, it needs to handle a lot of content well — blog posts, documentation, a changelog, product pages. That content needs to be fast, indexable, and easy to update. Second, it needs interactivity for the things that actually move visitors to sign up: a live code playground showing what the SDK feels like, a pricing calculator, an architecture diagram that responds to interaction.
Most teams reach for Next.js or Astro for this. Both are good choices. But we’re a Rust shop, and eating our own dogfood is a statement we wanted to make. If we’re asking developers to trust Rust in their critical infrastructure, we should be willing to run Rust ourselves — even where the defaults push toward JavaScript.
The Architecture
The site is split cleanly into two categories of content:
Zola handles everything static: blog posts (including this one), documentation pages, the changelog, pricing page, and most of the product marketing copy. Zola is a static site generator written in Rust. It compiles Markdown to HTML using Tera templates, handles Sass compilation natively, and supports content collections and taxonomies without plugins. There are no npm dependencies. There is no node_modules. The entire site content builds from scratch in under 400ms.
Leptos WASM islands handle the interactive components. Leptos is a Rust UI framework that compiles to WebAssembly. We use it for three things: the SDK code playground on the homepage, the pricing calculator, and the interactive architecture diagram. These components are compiled to WASM and loaded only on the pages that need them. A blog post like this one ships zero JavaScript and zero WASM. The homepage ships a ~180KB WASM bundle for the playground. Nowhere else.
Why Zola
The pitch for Zola is simple: it does exactly what a content site needs and nothing else. Sub-second builds. Sass compilation built in. A sensible content model with front matter, sections, and taxonomies. Shortcodes for reusable template fragments. A live reload dev server.
What it doesn’t do: client-side routing, data fetching, authentication. But we don’t need any of that. Content pages are content pages. The goal is HTML that loads instantly and ranks well.
Why Leptos Islands
The Leptos islands architecture means each interactive component is an independently loadable WASM module. You opt in per-component, per-page. This is the same pattern Astro popularized with JS frameworks, but the output is Rust compiled to WASM instead of React compiled to JS.
The advantages: Rust’s type system catches component bugs at compile time. No JavaScript fatigue. No hydration mismatches. The performance characteristics are predictable in a way that runtime-heavy JS frameworks are not.
The tradeoff: WASM bundle sizes are larger than equivalent JS, and the ecosystem is smaller. For three interactive components on a marketing site, the tradeoff is clearly worth it.
The Build Pipeline
A single just build command does everything:
wasm-pack buildcompiles each Leptos island to WASM and generates the JS gluezola buildcompiles all content to HTML, processes Sass, and copies static assets- The output is a single
public/directory of static files, ready to deploy anywhere
Total build time: approximately 30 seconds on a modern laptop, including the WASM compilation. Incremental builds for content changes are under a second.
The Aesthetic
We use the Catppuccin Mocha palette — a warm dark theme that developers tend to love. The code blocks in documentation and the playground use it throughout. It’s a small thing, but developer tools live in terminals and editors all day. A site that looks like it belongs in that world signals that you understand the audience.
Performance
Every content page is static HTML with no JavaScript. First paint is as fast as your CDN is. Time to interactive is effectively zero — there’s no JS to parse, no hydration to wait for. Pages score 100 on Lighthouse because there’s genuinely nothing to optimize.
On pages with Leptos islands, the WASM loads asynchronously after the HTML renders. The content is immediately readable while the interactive component initializes.
Open Source
We’re planning to open-source the site once we’ve cleaned up a few rough edges. If you’re curious about the Zola templates, the Leptos component structure, or the build pipeline, PRs will be welcome. We think the Zola + Leptos islands combination is underexplored and want to give the community a real-world reference.
Follow @fluxdev for the announcement when the repo goes public.
Enjoyed this post? Get updates from the Flux blog.