Rust has strong building blocks for web servers, but a complete web application still requires a router, templates, assets, CSS, sessions and client-side interaction.

Topcoat, a project in the Tokio ecosystem, is trying to make that stack feel integrated. It is a full-stack, server-rendered web framework with Rust-first templates, module-based routing, an asset pipeline and a small reactive browser runtime.

Topcoat appeared at #3 on the November 18, 2026 Rust weekly Trending list. Its latest release, v0.12.1, shipped on November 10 and added OpenAPI generation and route introspection. The framework is still early-stage and experimental, so treat this as an evaluation candidate rather than a mature replacement for an established production stack.

Topcoat logo from the official Tokio repository

Official Topcoat logo. Source: tokio-rs/topcoat.

What Topcoat is trying to simplify

Topcoat lets a Rust application own the server and rendered UI without requiring a separate JavaScript application for every interaction.

Pages and components are async Rust functions. The view! macro provides HTML-like templates with Rust expressions and control flow. Module-based routing maps source modules to URLs, and components can query a database during server rendering.

Its browser interaction model is unusual. A $(...) expression is type-checked Rust that Topcoat evaluates for the initial render and translates into JavaScript for the browser. Selected interactions can update locally without a network round trip or a WebAssembly bundle. When a change needs server data, a #[shard] component can be re-rendered on the server and swapped into the page.

Topcoat application preview from the official repository

Official project preview from the Topcoat documentation.

The v0.12.1 update: OpenAPI and route introspection

The November 10 release adds OpenAPI generation. With the openapi feature and schemars, you can attach an Operation description to a route. Topcoat can derive path, methods and parameters from the router while your code supplies summaries, request and response schemas, status codes and authentication metadata.

The release also adds Router::routes(), which exposes registered route information such as path, methods and context values. That can support your own route inventory or development tooling.

One security detail matters: OpenAPI metadata describes an API; it does not prove that the handler enforces the documented authorization rule. The release notes explicitly say the generator does not verify that an operation matches its handler. Your middleware and handlers still need to enforce access control.

The previous v0.12.0 release reworked foundations such as request context and macro conventions. Read the v0.12.1 notes and v0.12.0 upgrade guide before upgrading an existing app.

Create a minimal project

Install Rust and Cargo, then follow the official CLI guide:

cargo install topcoat-cli topcoat new hello-world --minimal cd hello-world topcoat dev 

The minimal preset creates a small app without a database or browser interaction library. The development server listens at http://127.0.0.1:3000.

For the recommended starter, use topcoat new hello-world --recommended. It includes module routing, the browser runtime, Tailwind CSS, Topcoat UI, icons, fonts and a todo example backed by Toasty and SQLite. Generate and apply the initial database migration before running it:

cargo run -- toasty migration generate cargo run -- toasty migration apply topcoat dev 

What a page looks like

The manual setup guide documents this basic shape:

use topcoat::{ Result, context::Cx, router::{module_router, page}, view::{View, component, view}, }; #[tokio::main] async fn main() { topcoat::start(module_router!().build()).await.unwrap(); } #[page] async fn home(cx: &Cx) -> Result<impl View> { Ok(view! { <!DOCTYPE html> <html> <body> hello(name: "World") </body> </html> }) } #[component] async fn hello(cx: &Cx, name: &str) -> Result<impl View> { Ok(view! { <h1>"Hello, " (name) "!"</h1> }) } 

The module router discovers the page and maps the root module to /. Nested modules can become nested routes. The same component system is used for layouts and reusable UI.

To add OpenAPI metadata, enable the feature and schema crate:

cargo add topcoat --features openapi cargo add schemars 

Then attach Operation::new() metadata to a route. The official release notes include the complete typed request and response example.

Who should evaluate it?

Topcoat is interesting if your team already writes Rust, wants server-rendered HTML with selected reactive interactions, and prefers one project to own routing, components, assets and UI primitives.

It is less attractive if your app depends on a large React component ecosystem, if you need a turnkey authentication package, or if you require a long production track record.

The README calls Topcoat early-stage and experimental and warns that breaking changes are expected. Its roadmap still lists validations, easier rate-limiting middleware, background jobs, static export, deployment documentation and a more complete authentication story. Session primitives exist, but that is not the same as a finished authentication system.

The project is MIT-licensed. You still need Rust expertise and should expect framework APIs to evolve.

Topcoat vs Axum, Leptos and Dioxus

Choose When it fits
Topcoat Batteries-included server-rendered Rust pages with selected browser reactivity
Axum Lower-level HTTP routing for APIs and services
Leptos / Dioxus More client-heavy Rust UI approaches, including WebAssembly interactivity
htmx / Datastar HTML-over-the-wire patterns without a full Rust UI framework

Tokio's Topcoat announcement explains why the project avoids compiling the entire UI to WebAssembly. The framework also supports htmx, Alpine AJAX and Datastar integrations where those patterns fit better.

Watch a walkthrough

Francesco Ciulla's July 29, 2026 video is an exact-project introduction. It predates v0.12.1, so it does not cover the new OpenAPI work.

For written context, see Francesco's DEV.to first look and Tokio's September progress update.

Sources and further reading

Would you try Topcoat for a new internal tool, or wait until more production essentials are complete?

I write about software, open source and developer tooling.