tokio-rs/topcoatPublic

A batteries-included framework for building web apps

AI summary: A batteries-included full-stack web framework for Rust built on the Tokio async runtime.

Stars
7.3K
+34 today
Forks
312
Watchers
47
Open issues
36
Open PRs
29
Contributors
~42
Commits
1.1K
Branches
30
Views (30d)
4

RustMITCreated Apr 3, 2026Last push 6d agoLatest release v0.12.1+112 stars this week+1.1K this month

Quick answers

What is topcoat?
A batteries-included full-stack web framework for Rust built on the Tokio async runtime.
What does topcoat do?
Topcoat is an experimental, modular Rust framework designed to provide a comprehensive, all-in-one solution for building full-stack web applications. It bundles routing, templating, and state management into a cohesive package, eliminating much of the boilerplate traditionally associated with Rust web development. Built on top of the high-performance Tokio asynchronous ecosystem, Topcoat emphasizes developer ergonomics. It features a unique approach to client reactivity, executing logic entirely on the server for initial renders and seamlessly translating it to JavaScript for instant browser interactivity without a heavy WASM bundle.
Who is topcoat for?
Rust developers looking for a cohesive, productive web framework, and developers from other languages wanting high performance without sacrificing developer ergonomics. It requires familiarity with Rust basics.
How do I get started with topcoat?
See the 'Getting started' documentation to create a new project and install the CLI.
How popular is topcoat on GitHub?
tokio-rs/topcoat has 7,276 stars and 312 forks on GitHub, and gained 112 stars in the last 7 days.
What license does topcoat use?
tokio-rs/topcoat is released under the MIT license.

Star history

since Jul 29, 2026
02K4K6KJul 2026Sep 2026Oct 2026Nov 2026
7.3K stars as of Nov 20, 2026. Measured daily since Jul 29, 2026; GitHub no longer exposes earlier star timestamps.

Update history

3 recorded
  • Nov 20, 2026New release v0.12.1 (previously v0.11.0).
  • Oct 29, 2026New release v0.11.0 (previously v0.10.0).
  • Oct 6, 2026New release v0.10.0 (previously v0.9.0).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 0 commits2026-03-13: 0 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 0 commits2026-03-26: 4 commits2026-03-27: 3 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 6 commits2026-04-04: 4 commits2026-04-05: 9 commits2026-04-06: 0 commits2026-04-07: 4 commits2026-04-08: 4 commits2026-04-09: 3 commits2026-04-10: 1 commit2026-04-11: 8 commits2026-04-12: 0 commits2026-04-13: 11 commits2026-04-14: 12 commits2026-04-15: 6 commits2026-04-16: 2 commits2026-04-17: 3 commits2026-04-18: 7 commits2026-04-19: 16 commits2026-04-20: 31 commits2026-04-21: 4 commits2026-04-22: 0 commits2026-04-23: 0 commits2026-04-24: 3 commits2026-04-25: 3 commits2026-04-26: 0 commits2026-04-27: 0 commits2026-04-28: 11 commits2026-04-29: 3 commits2026-04-30: 5 commits2026-05-01: 6 commits2026-05-02: 37 commits2026-05-03: 22 commits2026-05-04: 23 commits2026-05-05: 0 commits2026-05-06: 6 commits2026-05-07: 7 commits2026-05-08: 0 commits2026-05-09: 15 commits2026-05-10: 6 commits2026-05-11: 12 commits2026-05-12: 9 commits2026-05-13: 35 commits2026-05-14: 7 commits2026-05-15: 2 commits2026-05-16: 33 commits2026-05-17: 11 commits2026-05-18: 2 commits2026-05-19: 6 commits2026-05-20: 2 commits2026-05-21: 5 commits2026-05-22: 7 commits2026-05-23: 16 commits2026-05-24: 0 commits2026-05-25: 0 commits2026-05-26: 5 commits2026-05-27: 0 commits2026-05-28: 4 commits2026-05-29: 7 commits2026-05-30: 1 commit2026-05-31: 13 commits2026-06-01: 1 commit2026-06-02: 15 commits2026-06-03: 29 commits2026-06-04: 22 commits2026-06-05: 20 commits2026-06-06: 9 commits2026-06-07: 5 commits2026-06-08: 2 commits2026-06-09: 0 commits2026-06-10: 4 commits2026-06-11: 2 commits2026-06-12: 8 commits2026-06-13: 1 commit2026-06-14: 0 commits2026-06-15: 0 commits2026-06-16: 2 commits2026-06-17: 0 commits2026-06-18: 1 commit2026-06-19: 5 commits2026-06-20: 7 commits2026-06-21: 4 commits2026-06-22: 2 commits2026-06-23: 4 commits2026-06-24: 13 commits2026-06-25: 2 commits2026-06-26: 0 commits2026-06-27: 0 commits2026-06-28: 0 commits2026-06-29: 0 commits2026-06-30: 2 commits2026-07-01: 0 commits2026-07-02: 6 commits2026-07-03: 2 commits2026-07-04: 3 commits2026-07-05: 6 commits2026-07-06: 5 commits2026-07-07: 6 commits2026-07-08: 11 commits2026-07-09: 0 commits2026-07-10: 7 commits2026-07-11: 7 commits2026-07-12: 7 commits2026-07-13: 9 commits2026-07-14: 10 commits2026-07-15: 5 commits2026-07-16: 6 commits2026-07-17: 23 commits2026-07-18: 5 commits2026-07-19: 17 commits2026-07-20: 6 commits2026-07-21: 4 commits2026-07-22: 5 commits2026-07-23: 14 commits2026-07-24: 5 commits2026-07-25: 2 commits2026-07-26: 7 commits2026-07-27: 11 commits2026-07-28: 4 commits2026-07-29: 9 commits2026-07-30: 17 commits2026-07-31: 5 commits2026-08-01: 1 commit2026-08-02: 0 commits2026-08-03: 6 commits2026-08-04: 3 commits2026-08-05: 5 commits2026-08-06: 1 commit2026-08-07: 6 commits2026-08-08: 4 commits2026-08-09: 5 commits2026-08-10: 0 commits2026-08-11: 0 commits2026-08-12: 3 commits2026-08-13: 1 commit2026-08-14: 1 commit2026-08-15: 2 commits2026-08-16: 1 commit2026-08-17: 4 commits2026-08-18: 6 commits2026-08-19: 1 commit2026-08-20: 1 commit2026-08-21: 0 commits2026-08-22: 4 commits2026-08-23: 2 commits2026-08-24: 0 commits2026-08-25: 1 commit2026-08-26: 0 commits2026-08-27: 0 commits2026-08-28: 0 commits2026-08-29: 2 commits2026-08-30: 0 commits2026-08-31: 0 commits2026-09-01: 2 commits2026-09-02: 0 commits2026-09-03: 0 commits2026-09-04: 1 commit2026-09-05: 3 commits2026-09-06: 0 commits2026-09-07: 1 commit2026-09-08: 2 commits2026-09-09: 7 commits2026-09-10: 1 commit2026-09-11: 0 commits2026-09-12: 0 commits2026-09-13: 4 commits2026-09-14: 2 commits2026-09-15: 5 commits2026-09-16: 6 commits2026-09-17: 0 commits2026-09-18: 3 commits2026-09-19: 2 commits2026-09-20: 1 commit2026-09-21: 1 commit2026-09-22: 1 commit2026-09-23: 5 commits2026-09-24: 6 commits2026-09-25: 0 commits2026-09-26: 1 commit2026-09-27: 4 commits2026-09-28: 6 commits2026-09-29: 3 commits2026-09-30: 0 commits2026-10-01: 8 commits2026-10-02: 0 commits2026-10-03: 4 commits2026-10-04: 0 commits2026-10-05: 0 commits2026-10-06: 5 commits2026-10-07: 0 commits2026-10-08: 3 commits2026-10-09: 0 commits2026-10-10: 0 commits2026-10-11: 14 commits2026-10-12: 0 commits2026-10-13: 4 commits2026-10-14: 2 commits2026-10-15: 0 commits2026-10-16: 0 commits2026-10-17: 0 commits2026-10-18: 0 commits2026-10-19: 0 commits2026-10-20: 0 commits2026-10-21: 0 commits2026-10-22: 0 commits2026-10-23: 2 commits2026-10-24: 7 commits2026-10-25: 0 commits2026-10-26: 2 commits2026-10-27: 1 commit2026-10-28: 1 commit2026-10-29: 3 commits2026-10-30: 0 commits2026-10-31: 0 commits2026-11-01: 0 commits2026-11-02: 4 commits2026-11-03: 4 commits2026-11-04: 0 commits2026-11-05: 4 commits2026-11-06: 0 commits2026-11-07: 2 commits2026-11-08: 2 commits2026-11-09: 7 commits2026-11-10: 2 commits2026-11-11: 2 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 1 commit2026-11-15: 0 commits2026-11-16: 0 commits2026-11-17: 0 commits2026-11-18: 0 commits2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
1,057 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Very active

    1,057 commits in 52 weeks

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

What topcoat does

Topcoat is an experimental, modular Rust framework designed to provide a comprehensive, all-in-one solution for building full-stack web applications. It bundles routing, templating, and state management into a cohesive package, eliminating much of the boilerplate traditionally associated with Rust web development. Built on top of the high-performance Tokio asynchronous ecosystem, Topcoat emphasizes developer ergonomics. It features a unique approach to client reactivity, executing logic entirely on the server for initial renders and seamlessly translating it to JavaScript for instant browser interactivity without a heavy WASM bundle.

Rust developers looking for a cohesive, productive web framework, and developers from other languages wanting high performance without sacrificing developer ergonomics. It requires familiarity with Rust basics.

  • Batteries Included: Provides essential full-stack features out of the box, reducing the need to stitch together numerous disparate crates.
  • High Performance: Built natively on the Tokio ecosystem, ensuring highly efficient asynchronous request handling.
  • Seamless Client Reactivity: Evaluates expressions on the server and translates them to JavaScript for instant browser interactivity without client build steps.
  • Built-in HTML Templating: Offers a powerful `view!` macro that allows using familiar Rust control flow directly within HTML structures.
  • Module-Based Routing: Optionally infers the application's route tree directly from the project's module structure without requiring a build step.
  • Asset Bundling and Tailwind: Scans for assets, serves them with aggressive caching, and includes built-in support for Tailwind CSS.

Where teams use it

High-Traffic Web Services

Building scalable, performant web applications that need to handle thousands of concurrent connections efficiently.

Rapid Prototyping

Quickly spinning up full-stack applications without spending days configuring and wiring together various Rust web crates.

Interactive Dashboards

Developing fast, reliable internal tools and enterprise dashboards with real-time server-side reactivity.

API Development

Creating robust REST APIs while simultaneously serving server-rendered HTML views from the same application.

Getting started: See the 'Getting started' documentation to create a new project and install the CLI.

README

main branch
Topcoat

The full full-stack framework for Rust

Crates.io Docs.rs MIT licensed Build Status Discord chat

Topcoat is a modular, batteries-included Rust framework for building full-stack apps. It prioritizes simplicity and productivity. See Learn Topcoat to get started, or the Roadmap for what's coming next.

Early-stage and experimental. Expect breaking changes.

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> })
}

What makes Topcoat different

Client reactivity without the boilerplate

Topcoat renders all markup on the server: components can be async and query the database directly, eliminating all the traditional boilerplate needed for a separate API layer. Interactivity does not have to cost a round-trip, though. A $(...) expression is ordinary type-checked Rust that Topcoat evaluates on the server for the initial render and also translates to JavaScript, so it re-runs instantly in the browser. No wasm bundle, no client build step:

#[component]
async fn faq(cx: &Cx) -> Result<impl View> {
    let open = signal(cx, || false);

    Ok(view! {
        // Runs entirely in the browser; no server round-trip.
        <button @click=$(|_e| open.set(!open.get()))>"What is Topcoat?"</button>
        <p :hidden=$(!open.get())>"A full-stack Rust framework."</p>
    })
}

When an update does need the server, like fresh search results, mark the component as a #[shard]. Topcoat re-renders it on the server whenever one of its $(...) arguments changes and swaps the new HTML in place:

#[component]
async fn search(cx: &Cx) -> Result<impl View> {
    let query = signal(cx, String::new);

    Ok(view! {
        <input @input=$(|e: Event| query.set(e.target.value))>

        // Updates as the user types.
        search_results(query: $(query.get()))
    })
}

#[shard]
async fn search_results(cx: &Cx, query: String) -> Result<impl View> {
    Ok(view! {
        <ul>
            // Your own server-side code, like a database query:
            for product in search_products(cx, &query).await? {
                <li>(product.name)</li>
            }
        </ul>
    })
}

Powerful, unsurprising HTML templates

The view! macro stays true to HTML and Rust. Use familiar Rust control flow as part of your templates:

view! {
    <nav>
        for item in nav_items {
            <a
                href=(item.url)
                if item.url == current_path {
                    aria-current="page"
                    class="active"
                }
            >
                (item.label)
            </a>
        }
    </nav>
}

Use the topcoat fmt CLI command to automatically format view! snippets (and other macros) across your codebase.

Module-based routing

Topcoat can optionally infer your route tree from your app's module structure (without a build step):

src/
|-- app.rs              -> /            (and the root <html> layout)
`-- app/
    |-- about.rs        -> /about
    |-- _marketing.rs                  (layout, no URL segment)
    |-- _marketing/
    |   `-- pricing.rs  -> /pricing
    |-- posts.rs        -> /posts
    |-- posts/
    |   `-- id.rs       -> /posts/{post_id}
    `-- api/
        `-- health.rs   -> GET /api/health

Premade components you can edit

Topcoat UI is a component library based on Tailwind inspired by shadcn/ui. Components are copied into your project via the topcoat ui CLI command, meaning you can freely change their design and functionality to fit your use case:

#[component]
async fn delete_card(cx: &Cx) -> Result<impl View> {
    Ok(view! {
        card(
            card_header(
                card_title("Delete workspace")
                card_description(
                    "This permanently removes the workspace and all of its data."
                )
            )
            card_footer(
                attrs: attributes! { class="justify-end" },
                button(variant: ButtonVariant::Ghost, "Cancel")
                button(variant: ButtonVariant::Destructive, "Delete workspace")
            )
        )
    })
}

Asset bundling

The bundler scans your compiled binary for asset! calls, copies (or even downloads) every file into a local asset directory, and allows Topcoat to serve them efficiently with aggressive browser caching.

const FERRIS: Asset = asset!("./ferris.png");

view! { <img src=(FERRIS)> }

Topcoat also ships with utilities for web fonts and icons, as well as easy integrations for Fontsource (Google Fonts) and Iconify.

Built-in Tailwind support

Enable the tailwind feature to integrate Tailwind into your project:

view! { <link rel="stylesheet" href=(topcoat::tailwind::stylesheet!())> }

Learn Topcoat

Start here

Rendering

  • view! mixes HTML, Rust expressions, control flow, and component calls.
  • #[component] makes async functions callable from markup with named arguments and child content.
  • attributes! collects attributes to pass through components and spread onto elements.
  • class! joins base, optional, and conditional CSS classes.
  • suspense shows a fallback while content loads. error_boundary shows one if rendering fails.
  • live! and emit! replace part of a page as async work produces new HTML.

Routing

Working with requests

  • Context (Cx): read request data and values stored by type. Add shared values with the router builder's .with, or use cx.with to add a value for part of a request.
  • Memoization: #[memoize] for per-request caching and fan-out dedup.
  • Cookies: read and write the request cookie jar, with signed, encrypted, and prefixed cookies.
  • Sessions: bring-your-own-storage session authentication: login/logout lifecycle, sliding expiration, and token rotation.

Asset system

  • Assets: declare assets in Rust, serve them with content-hashed URLs.
  • Fonts: bundle and serve web fonts.
  • Icons: download Iconify icon sets or declare your own.

Client reactivity

  • The runtime: signals, $(...) expressions, @ event handlers, and : bind attributes.
  • Expressions: the dual Rust/JavaScript expression language and its vocabulary.
  • Procedures: async server functions callable from the browser.
  • Shards: components that re-render on the server when their arguments change.
  • Client-side navigation: links, prefetching, and navigation without a full document reload.

Miscellaneous

  • Topcoat UI: premade components vendored into your project for you to edit.
  • Metadata: titles, descriptions, and link previews for search engines and social networks, set per layout and page.
  • Localization: choose the language for each request and display translations from Fluent files.
  • Mail: build mail with Mail::builder, deliver through SMTP, file, or in-memory transports.
  • OpenAPI: describe API routes where they are declared and generate an OpenAPI document from the router.

Third-party integrations

  • Tailwind: Tailwind CSS without Node, wired into the asset pipeline.
  • htmx: drive partial HTML swaps from the server with request/response header helpers.
  • Alpine AJAX: drive partial HTML swaps from the server with Alpine AJAX's request-header conventions.
  • Datastar: patch elements and signals into the page over server-sent events.

Roadmap

Planned features we'd like to bring to Topcoat. Have an idea? Open an issue.

  • Static export
  • (More) reactivity (topcoat-runtime)
  • More Topcoat UI components, full "blocks" e.g. sign-in form
  • Better Toasty integration (safely create/update records from forms without listing out all the fields)
  • Validations
  • Docs for how to deploy Topcoat
  • Pre-rendering for static pages
  • WebTransport
  • Image optimization / resizing
  • Markdown support
  • Easier-to-use middlewares like rate-limiting
  • Authentication
  • Background jobs
  • Islands
View on GitHub

Recent activity

commits and pull requests

Releases and announcements

12 total
  1. v0.12.1v0.12.1Nov 10, 2026

    - [OpenAPI](#openapi) - [Getting started](#getting-started) - [Inherited settings](#inherited-settings) - [Parameters, bodies and authentication](#parameters-bodies-and-authentication) - [Listing routes](#listing-routes) ## <a id="openapi"></a>OpenAPI ### <a id="getting-started"></a>Getting started Enable the new `openapi` feature and add [schemars](https://docs.rs/schemars), which describes the data in your request and response bodies: ```sh cargo add topcoat --features openapi cargo add schemars ``` Attach an `Operation` to a route with `with(...)`. Topcoat takes the path, HTTP methods and path parameters from the router, and you add the rest: ```rust use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use topcoat::{ Result, context::Cx, openapi::Operation, router::{StatusCode, content::Json, route}, }; #[derive(Deserialize, JsonSchema)] struct CreateUser { /// The name to show for the user. name: String, } #[derive(Serialize, JsonSchema)] struct User { id: u64, name: String, } #[route(POST "/api/users", with( Operation::new() .summary("Create a user") .reques

  2. v0.12.0v0.12.0Nov 9, 2026

    This release reworks some foundations of Topcoat. Most apps will need many small edits. We are sorry for the churn, but we believe these changes make Topcoat simpler and more extensible. The [upgrade guide](#upgrade-guide) at the end lists the required changes. - [Context](#context) - [One context](#one-context) - [Route context](#route-context) - [Router settings](#router-settings) - [Page metadata](#page-metadata) - [Macros](#macros) - [Context comes first](#context-comes-first) - [One argument style](#one-argument-style) - [Completions while typing](#completions-while-typing) - [Formatting](#formatting) - [Removed cookie! and mail!](#removed-cookie-and-mail) - [Path parameter accessors](#path-parameter-accessors) - [Mail](#mail) - [Fixes](#fixes) - [Upgrade guide](#upgrade-guide) - [Checklist](#checklist) - [Renamed and removed APIs](#renamed-and-removed-apis) - [Behavior changes](#behavior-changes) ## <a id="context"></a>Context ### <a id="one-context"></a>One context Topcoat used to keep app context and request context apart, each with its own functions. They are now one context, read with `context`, `try_context` and the new

  3. v0.11.0v0.11.0Oct 24, 2026

    - [Localization](#localization) - [Fluent translations](#fluent-translations) - [Number and date formatting](#number-and-date-formatting) - [Translation checks](#translation-checks) - [Creating apps](#creating-apps) - [Element IDs](#element-ids) - [Popovers](#popovers) - [Navigation menu](#navigation-menu) - [Edited form controls](#edited-form-controls) - [Errors from memoized functions](#errors-from-memoized-functions) - [New demo and examples](#new-demo-and-examples) - [Documentation and fixes](#documentation-and-fixes) - [Upgrade guide](#upgrade-guide) - [Rust version](#rust-version) - [Dropdown menus](#dropdown-menus) - [Rerendered inputs](#rerendered-inputs) - [Formatting ignored files](#formatting-ignored-files) ## <a id="localization"></a>Localization You can now render your app in different languages. The new `l10n` module lets you choose a locale for each request, translate text with [Fluent](https://projectfluent.org/) files, and format numbers and dates for the locale. Translations work in pages, but also in emails, push notifications, and any other text that has access to a context. ```rust use topcoat::{ Result, context

  4. v0.10.0v0.10.0Oct 3, 2026

    ## Client side navigation You can now navigate between server-rendered pages without a full page reload. The new `runtime::link` component updates the page, title, and browser history while preserving signals shared by both pages. Back and forward navigation restores scroll positions. ```rust use topcoat::{ Result, router::{href, page}, runtime::link, view::{View, view}, }; #[page] async fn home() -> Result<impl View> { Ok(view! { link(href: href!(about::page), "About") }) } mod about { use super::*; #[page] pub async fn page() -> Result<impl View> { Ok(view! { <h1>"About"</h1> }) } } ``` To get started, add `.runtime()` to your router and `topcoat::runtime::script()` to the document head, with assets configured as described in [runtime setup](https://github.com/tokio-rs/topcoat/blob/main/docs/runtime.md#setup). Links still work without JavaScript. Modifier clicks, downloads, and external links keep their normal browser behavior. Custom anchors can get the same behavior through `link_attrs`. Inside a component or page with `cx: &Cx`: ```rust use topcoat::runtime::{link_attrs, prefetch_mode}; let

  5. v0.9.0v0.9.0Sep 24, 2026

    - [Server push with `live!` and `connected`](#server-push-with-live-and-connected) - [Suspense and error boundaries](#suspense-and-error-boundaries) - [Stable identities for state and live regions](#stable-identities-for-state-and-live-regions) - [More capable runtime expressions](#more-capable-runtime-expressions) - [Stateful hot reload](#stateful-hot-reload) - [Reactive UI components, sidebars, and form fields](#reactive-ui-components-sidebars-and-form-fields) - [Routing and server integration](#routing-and-server-integration) - [Client IPs and trusted proxies](#client-ips-and-trusted-proxies) - [Cheaply cloneable errors](#cheaply-cloneable-errors) - [Upgrading from 0.8.1](#upgrading-from-081) ## Server push with `live!` and `connected` Keep server-rendered content updating after the page finishes loading. `live!` and `emit!` render the updates; `connected(cx)` asks Topcoat to keep them flowing over a WebSocket. Here's the [chat example](https://github.com/tokio-rs/topcoat/blob/bcf345756c3b6fdde6d71c700f78cccda49ce3a3/examples/live/src/chat.rs). Its `Chat` app state stores messages and notifies subscribers when a message arrives: ```rust use topcoat::{

Code frequency

additions and deletions
+99.3K-99.3KWeek of 2026-03-22: +1,039 linesWeek of 2026-03-22: -502 linesWeek of 2026-03-29: +842 linesWeek of 2026-03-29: -554 linesWeek of 2026-04-05: +2,603 linesWeek of 2026-04-05: -1,409 linesWeek of 2026-04-12: +2,973 linesWeek of 2026-04-12: -1,019 linesWeek of 2026-04-19: +5,732 linesWeek of 2026-04-19: -1,207 linesWeek of 2026-04-26: +4,457 linesWeek of 2026-04-26: -2,974 linesWeek of 2026-05-03: +5,992 linesWeek of 2026-05-03: -3,965 linesWeek of 2026-05-10: +10,203 linesWeek of 2026-05-10: -7,136 linesWeek of 2026-05-17: +9,835 linesWeek of 2026-05-17: -3,185 linesWeek of 2026-05-24: +3,436 linesWeek of 2026-05-24: -3,562 linesWeek of 2026-05-31: +28,044 linesWeek of 2026-05-31: -15,982 linesWeek of 2026-06-07: +5,542 linesWeek of 2026-06-07: -2,694 linesWeek of 2026-06-14: +3,783 linesWeek of 2026-06-14: -396 linesWeek of 2026-06-21: +21,009 linesWeek of 2026-06-21: -14,925 linesWeek of 2026-06-28: +11,145 linesWeek of 2026-06-28: -1,846 linesWeek of 2026-07-05: +99,286 linesWeek of 2026-07-05: -35,651 linesWeek of 2026-07-12: +19,523 linesWeek of 2026-07-12: -9,160 linesWeek of 2026-07-19: +10,092 linesWeek of 2026-07-19: -2,734 linesWeek of 2026-07-26: +18,791 linesWeek of 2026-07-26: -3,588 linesWeek of 2026-08-02: +17,928 linesWeek of 2026-08-02: -15,401 linesWeek of 2026-08-09: +8,435 linesWeek of 2026-08-09: -3,116 linesWeek of 2026-08-16: +8,759 linesWeek of 2026-08-16: -852 linesWeek of 2026-08-23: +5,330 linesWeek of 2026-08-23: -1,161 linesWeek of 2026-08-30: +12,130 linesWeek of 2026-08-30: -6,017 linesWeek of 2026-09-06: +4,249 linesWeek of 2026-09-06: -1,094 linesWeek of 2026-09-13: +22,336 linesWeek of 2026-09-13: -6,389 linesWeek of 2026-09-20: +23,584 linesWeek of 2026-09-20: -20,020 linesWeek of 2026-09-27: +17,643 linesWeek of 2026-09-27: -10,724 linesWeek of 2026-10-04: +6,840 linesWeek of 2026-10-04: -725 linesWeek of 2026-10-11: +14,697 linesWeek of 2026-10-11: -2,212 linesWeek of 2026-10-18: +12,225 linesWeek of 2026-10-18: -873 linesWeek of 2026-10-25: +7,382 linesWeek of 2026-10-25: -3,568 linesWeek of 2026-11-01: +18,223 linesWeek of 2026-11-01: -16,689 linesWeek of 2026-11-08: +89,903 linesWeek of 2026-11-08: -57,091 linesWeek of 2026-11-15: +0 linesWeek of 2026-11-15: -0 linesMar 22, 2026Nov 15, 2026
+534K lines added, -258.4K removed over the last year.

Commits per week

last 52 weeks
1090Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 7 commitsWeek of 2026-03-29: 10 commitsWeek of 2026-04-05: 29 commitsWeek of 2026-04-12: 41 commitsWeek of 2026-04-19: 57 commitsWeek of 2026-04-26: 62 commitsWeek of 2026-05-03: 73 commitsWeek of 2026-05-10: 104 commitsWeek of 2026-05-17: 49 commitsWeek of 2026-05-24: 17 commitsWeek of 2026-05-31: 109 commitsWeek of 2026-06-07: 22 commitsWeek of 2026-06-14: 15 commitsWeek of 2026-06-21: 25 commitsWeek of 2026-06-28: 13 commitsWeek of 2026-07-05: 42 commitsWeek of 2026-07-12: 65 commitsWeek of 2026-07-19: 53 commitsWeek of 2026-07-26: 54 commitsWeek of 2026-08-02: 25 commitsWeek of 2026-08-09: 12 commitsWeek of 2026-08-16: 17 commitsWeek of 2026-08-23: 5 commitsWeek of 2026-08-30: 6 commitsWeek of 2026-09-06: 11 commitsWeek of 2026-09-13: 22 commitsWeek of 2026-09-20: 15 commitsWeek of 2026-09-27: 25 commitsWeek of 2026-10-04: 8 commitsWeek of 2026-10-11: 20 commitsWeek of 2026-10-18: 9 commitsWeek of 2026-10-25: 7 commitsWeek of 2026-11-01: 14 commitsWeek of 2026-11-08: 14 commitsWeek of 2026-11-15: 0 commitsNov 23, 2025Nov 15, 2026
1.1K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 1 commitsSun 1:00 — 1 commitsSun 2:00 — 7 commitsSun 3:00 — 1 commitsSun 4:00 — 0 commitsSun 5:00 — 7 commitsSun 6:00 — 1 commitsSun 7:00 — 1 commitsSun 8:00 — 0 commitsSun 9:00 — 4 commitsSun 10:00 — 3 commitsSun 11:00 — 11 commitsSun 12:00 — 9 commitsSun 13:00 — 18 commitsSun 14:00 — 17 commitsSun 15:00 — 10 commitsSun 16:00 — 5 commitsSun 17:00 — 7 commitsSun 18:00 — 7 commitsSun 19:00 — 11 commitsSun 20:00 — 17 commitsSun 21:00 — 8 commitsSun 22:00 — 5 commitsSun 23:00 — 5 commitsMon 0:00 — 2 commitsMon 1:00 — 4 commitsMon 2:00 — 0 commitsMon 3:00 — 1 commitsMon 4:00 — 0 commitsMon 5:00 — 2 commitsMon 6:00 — 0 commitsMon 7:00 — 7 commitsMon 8:00 — 12 commitsMon 9:00 — 2 commitsMon 10:00 — 0 commitsMon 11:00 — 1 commitsMon 12:00 — 9 commitsMon 13:00 — 13 commitsMon 14:00 — 11 commitsMon 15:00 — 11 commitsMon 16:00 — 17 commitsMon 17:00 — 13 commitsMon 18:00 — 11 commitsMon 19:00 — 5 commitsMon 20:00 — 9 commitsMon 21:00 — 10 commitsMon 22:00 — 8 commitsMon 23:00 — 1 commitsTue 0:00 — 1 commitsTue 1:00 — 0 commitsTue 2:00 — 0 commitsTue 3:00 — 0 commitsTue 4:00 — 0 commitsTue 5:00 — 0 commitsTue 6:00 — 3 commitsTue 7:00 — 4 commitsTue 8:00 — 3 commitsTue 9:00 — 0 commitsTue 10:00 — 1 commitsTue 11:00 — 3 commitsTue 12:00 — 6 commitsTue 13:00 — 8 commitsTue 14:00 — 14 commitsTue 15:00 — 10 commitsTue 16:00 — 19 commitsTue 17:00 — 18 commitsTue 18:00 — 11 commitsTue 19:00 — 6 commitsTue 20:00 — 17 commitsTue 21:00 — 10 commitsTue 22:00 — 0 commitsTue 23:00 — 3 commitsWed 0:00 — 1 commitsWed 1:00 — 3 commitsWed 2:00 — 1 commitsWed 3:00 — 0 commitsWed 4:00 — 1 commitsWed 5:00 — 0 commitsWed 6:00 — 0 commitsWed 7:00 — 0 commitsWed 8:00 — 0 commitsWed 9:00 — 0 commitsWed 10:00 — 0 commitsWed 11:00 — 1 commitsWed 12:00 — 6 commitsWed 13:00 — 7 commitsWed 14:00 — 23 commitsWed 15:00 — 19 commitsWed 16:00 — 16 commitsWed 17:00 — 12 commitsWed 18:00 — 16 commitsWed 19:00 — 19 commitsWed 20:00 — 14 commitsWed 21:00 — 7 commitsWed 22:00 — 11 commitsWed 23:00 — 7 commitsThu 0:00 — 5 commitsThu 1:00 — 3 commitsThu 2:00 — 0 commitsThu 3:00 — 2 commitsThu 4:00 — 2 commitsThu 5:00 — 1 commitsThu 6:00 — 2 commitsThu 7:00 — 0 commitsThu 8:00 — 4 commitsThu 9:00 — 0 commitsThu 10:00 — 7 commitsThu 11:00 — 5 commitsThu 12:00 — 8 commitsThu 13:00 — 10 commitsThu 14:00 — 7 commitsThu 15:00 — 11 commitsThu 16:00 — 5 commitsThu 17:00 — 17 commitsThu 18:00 — 15 commitsThu 19:00 — 11 commitsThu 20:00 — 8 commitsThu 21:00 — 9 commitsThu 22:00 — 3 commitsThu 23:00 — 0 commitsFri 0:00 — 2 commitsFri 1:00 — 2 commitsFri 2:00 — 0 commitsFri 3:00 — 0 commitsFri 4:00 — 2 commitsFri 5:00 — 2 commitsFri 6:00 — 1 commitsFri 7:00 — 0 commitsFri 8:00 — 0 commitsFri 9:00 — 2 commitsFri 10:00 — 1 commitsFri 11:00 — 9 commitsFri 12:00 — 2 commitsFri 13:00 — 7 commitsFri 14:00 — 8 commitsFri 15:00 — 9 commitsFri 16:00 — 20 commitsFri 17:00 — 19 commitsFri 18:00 — 10 commitsFri 19:00 — 13 commitsFri 20:00 — 6 commitsFri 21:00 — 9 commitsFri 22:00 — 1 commitsFri 23:00 — 1 commitsSat 0:00 — 5 commitsSat 1:00 — 12 commitsSat 2:00 — 8 commitsSat 3:00 — 2 commitsSat 4:00 — 2 commitsSat 5:00 — 2 commitsSat 6:00 — 0 commitsSat 7:00 — 0 commitsSat 8:00 — 2 commitsSat 9:00 — 1 commitsSat 10:00 — 2 commitsSat 11:00 — 5 commitsSat 12:00 — 11 commitsSat 13:00 — 21 commitsSat 14:00 — 13 commitsSat 15:00 — 21 commitsSat 16:00 — 23 commitsSat 17:00 — 10 commitsSat 18:00 — 11 commitsSat 19:00 — 17 commitsSat 20:00 — 5 commitsSat 21:00 — 7 commitsSat 22:00 — 2 commitsSat 23:00 — 9 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Jul 22, 2026daily#12+4
  • ultraworkers/claw-code

    An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

    194.8K stars · Rust

  • farion1231/cc-switch

    A cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode,DeepSeek Harness and more. Only official website: ccswitch.io

    156K stars · Rust

  • openai/codex

    Lightweight coding agent that runs in your terminal

    136K stars · Rust

  • rust-lang/rust

    Empowering everyone to build reliable and efficient software.

    122.3K stars · Rust

  • pbakaus/impeccable

    The design vocabulary for your coding agent. Steer with polish and bolder, review with critique and audit, catch AI slop before it ships.

    114.1K stars · Rust

  • denoland/deno

    A modern runtime for JavaScript and TypeScript.

    109.1K stars · Rust