Why Flutter's Websites Now Run on Dart and Jaspr

Flutter's official websites—dart.dev, flutter.dev, and docs.flutter.dev—have undergone a major transformation. Previously built with a disjointed mix of tools like Eleventy (Node.js) and Wagtail (Python), they now share a unified foundation: Jaspr, an open-source Dart web framework. This migration simplifies contributions, boosts code sharing, and brings a consistent developer experience. Here's everything you need to know about the move.

What drove the decision to rebuild Flutter's websites?

The original setup was fragmented and increasingly hard to maintain. The documentation sites relied on Eleventy, a Node.js static-site generator, while flutter.dev used a completely separate system powered by Wagtail, a Python- and Django-based CMS. This meant that anyone wanting to contribute or maintain the sites needed expertise in both Node.js and Python, plus familiarity with the Dart ecosystem for interactive components that were already written in Dart. The lack of a unified stack made code sharing nearly impossible, increased the learning curve for contributors, and demanded extra effort for every site update. As Flutter’s ambitions grew—like adding richer code samples and quizzes—the old setup became a bottleneck, often requiring one-off, imperative DOM logic for each new interactive feature. A single, Dart-based solution was clearly needed.

What exactly was problematic about the old technical stack?

The previous architecture suffered from three core issues. First, ecosystem fragmentation: dart.dev and docs.flutter.dev were built with Eleventy (JavaScript/Node.js), while flutter.dev ran on Wagtail (Python/Django). This forced developers to switch between languages and toolchains for even simple changes. Second, limited code reuse: although some surrounding infrastructure and interactive components were already written in Dart, the separate ecosystems prevented sharing any of that logic across the three sites. Third, increased friction for contributions: potential contributors from the Flutter community, who are primarily Dart developers, faced a steep learning curve because they had to master Node.js or Python just to help out. Over time, maintaining the sites grew complicated, and adding new features became an “uphill battle.”

Why was Jaspr chosen as the unified framework?

Jaspr is a versatile Dart web framework that supports three rendering modes: client-side rendering (CSR), server-side rendering (SSR), and static site generation (SSG). It was an obvious choice for several reasons. First, it’s written entirely in Dart, the same language used to build Flutter apps—so the team and community already have the necessary skills. Second, Jaspr’s component model is designed to feel very similar to Flutter widgets, making it instantly familiar to any Flutter developer. Third, the framework is open source and actively maintained, providing a modern, DOM-based approach to building websites without leaving the Dart ecosystem. By choosing Jaspr, the team could replace two different toolchains with a single, consistent stack where contributing only requires Dart knowledge.

How does Jaspr leverage Flutter developers' existing skills?

Jaspr’s component model mirrors Flutter’s widget tree in a way that feels completely natural. For example, building a FeatureCard component in Jaspr 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)]),
    ]);
  }
}

If you’ve written a Flutter widget before, the syntax—using build, BuildContext, and a tree of components—will be instantly recognizable. This means Flutter developers can jump right into contributing to Flutter’s websites without learning a new framework. The same core Dart concepts and patterns apply, which drastically reduces the onboarding time for new contributors and allows the team to reuse logic more easily across both Flutter apps and web pages.

How does Jaspr improve support for interactive features?

Flutter’s sites needed more interactivity—like dynamic code samples, quizzes, and custom demos—but the old stack made each addition a struggle. With Eleventy and Wagtail, interactive elements often required writing one-off, imperative DOM manipulation code, which was hard to maintain and inconsistent across the sites. Jaspr changes this by offering a unified, component-based architecture where interactivity is built directly into the framework. Since Jaspr supports both server-side and client-side rendering, you can create rich, interactive components that work seamlessly within statically generated pages. For example, a quiz component can be written once in Dart and used across all three websites, with state management handled cleanly. This eliminates the need for ad‑hoc JavaScript and makes the whole development process more intuitive and maintainable.

What does this migration mean for community contributors?

For the Flutter community, the migration to Jaspr is a game-changer. Previously, contributing to the websites required knowledge of Node.js (for Eleventy) or Python (for Wagtail), which excluded many skilled Dart developers. Now, contributing only requires Dart. The entire stack—from static site generation to interactive components—is built with the same language and tools used to develop Flutter itself. This means a contributor can fix a typo in the docs, add a new section to the developer site, or build an interactive tutorial component without leaving the Dart ecosystem. The developer experience is consistent, setup friction is reduced, and more people can easily help improve the sites. Ultimately, this lowers the barrier to entry and empowers the community to be more active in maintaining and enhancing the official Flutter resources.