How Flutter's Websites Got a Unified Dart-Powered Makeover with Jaspr

For years, the official websites of Dart and Flutter (dart.dev, flutter.dev, docs.flutter.dev) ran on a patchwork of different technologies. That meant anyone wanting to improve the sites had to juggle Node.js, Python, and Django—none of which are native to the Dart ecosystem that powers Flutter apps. Now, that's changed. The entire web presence has been migrated to Jaspr, an open-source, Dart-based web framework. The result is a single stack where contributing only requires knowing Dart. This article dives into what drove the migration and why Jaspr and Dart are the perfect match for building modern, interactive websites.

The Old Fragmented Stack

Before the migration, the three sites were maintained with entirely different tools. dart.dev and docs.flutter.dev were built with Eleventy, a Node.js static-site generator. Meanwhile, flutter.dev used Wagtail, a CMS powered by Python and Django. This split meant that developers had to switch contexts between JavaScript and Python tooling just to fix a typo or add a new feature. Even though some interactive components were already written in Dart, the lack of a unified system prevented code reuse and made collaboration more difficult.

As the team's ambitions grew—adding richer code samples, quizzes, and interactive tutorials—the old setup became a bottleneck. Each new interactive element required custom, imperative DOM manipulation, which was slow to build and hard to maintain. The team knew they needed a single language and framework that could handle both static content and dynamic interactions seamlessly.

Why Jaspr Won the Day

After evaluating several options, the team chose Jaspr, a full-stack Dart web framework that supports client-side rendering, server-side rendering, and static site generation. Jaspr stood out for three key reasons:

1. Familiarity for Flutter developers – The component model feels like writing Flutter widgets. If you know StatelessWidget in Flutter, you can quickly grasp Jaspr's StatelessComponent. For instance, a simple card component looks like this:

class FeatureCard extends StatelessComponent {
  const FeatureCard({
    required this.title,
    required this.description,
    super.key,
  });

  final String title;
  final String description;

  @override
  Component build(BuildContext context) {
    return div(classes: 'feature-card', [
      h3([text(title)]),
      p([text(description)]),
    ]);
  }
}

This direct transfer of skills means anyone on the Flutter team—or in the Flutter community—can start contributing to the websites without learning a new paradigm.

1. Unified rendering options – Jaspr can generate static HTML for fast initial loads, render on the server for dynamic content, or hydrate into a fully interactive client-side app. This flexibility allowed the team to migrate each page at its own pace.
2. Dart-only ecosystem – The entire build toolchain, from linting to testing to deployment, runs on Dart. No more switching between npm and pip. This drastically reduces setup friction for new contributors.

Migration Strategy

The team didn't flip a switch overnight. Instead, they adopted a gradual migration pattern. They started with the documentation sites, where the content was mostly static but had a few interactive code editors. By using Jaspr's static-site generation mode, they could export all pages as plain HTML and then selectively hydrate interactive components. For flutter.dev, they rebuilt the CMS-backed pages as Jaspr components, pulling content from a headless CMS via Dart's HTTP client.

Throughout the process, the team maintained backward compatibility by running the old and new sites side by side. They used feature flags to roll out new pages to a subset of users, catching issues early. The migration was completed in a few months, with zero downtime.

Real Benefits Observed

Since the switch, the team has noticed several concrete improvements:

• Faster contribution cycle – A developer only needs Dart installed to work on any of the three sites. The average time to set up a local development environment dropped from hours to minutes.
• Code reuse between sites – Shared components like search bars, navigation menus, and code snippet rendering are now in a single Dart package used by all sites.
• Better interactivity – Adding a new quiz or interactive example no longer requires manual DOM scripting. Jaspr's state management and event handling make it straightforward.
• Improved performance – Static generation yields near-instant page loads, while progressive hydration ensures interactive elements are ready when needed.

Getting Started with Jaspr

If you're a Flutter developer curious about building web experiences beyond standard Flutter web apps, Jaspr is worth a look. The framework is open source and well-documented. You can get started with a single command:

dart create -t jaspr my_site

From there, the component-based architecture will feel instantly familiar. You can build fully static sites, server-rendered pages, or interactive single-page applications—all from the same Dart codebase.

Conclusion

The migration of dart.dev, flutter.dev, and docs.flutter.dev to Jaspr represents a significant win for the Dart and Flutter community. It eliminates the polyglot complexity that once hindered contributions and makes it easier than ever to maintain and enhance these critical developer resources. If you're looking to build a modern website with a familiar Flutter-like development experience, Jaspr and Dart are now a proven choice.