How Dart and Jaspr United Flutter’s Web Presence: A Technical Migration Story

Introduction

For years, the official Dart and Flutter websites were built on a patchwork of non-Dart technologies. Despite Dart’s origins as a web language and its daily use for building cross-platform apps—including web apps—the team’s own digital properties (dart.dev, flutter.dev, docs.flutter.dev) ran on a fragmented mix of tools. That era is now over. In a strategic move, the Flutter team migrated all three sites to Jaspr, an open-source web framework written entirely in Dart. This shift unifies the technical stack, reduces friction for contributors, and opens the door to richer interactive experiences—all while keeping development firmly inside the Dart ecosystem. Here’s why they made the change and how Jaspr made it possible.

The Challenge: A Fragmented and Unfamiliar Stack

The previous setup worked, but at a cost. The documentation sites were powered by Eleventy, a Node.js static-site generator. Meanwhile, flutter.dev ran on Wagtail, a content management system built with Python and Django. This meant anyone wanting to contribute needed not just Dart skills, but also experience with Node.js tooling for one set of sites and Python for another. The fragmented ecosystems limited code sharing, increased setup and contribution friction, and made it harder to add new features.

Beyond the administrative overhead, the team had growing ambitions for interactivity—richer code samples, quizzes in tutorials, and more dynamic elements. Each new interactive feature required one-off imperative DOM logic, making development an uphill battle. The existing stack simply wasn’t designed for the level of engagement the team wanted.

Why Jaspr? A Framework Built for the Team

Jaspr is a versatile Dart web framework that supports client-side rendering (CSR), server-side rendering (SSR), and static site generation (SSG). It’s a traditional DOM-based framework (using HTML and CSS), but it’s written entirely in Dart—the language the team already knows. However, several specific features made it the ideal choice.

Familiar Component Model

One of the biggest selling points: Jaspr was designed to feel natural to any Flutter developer. Its component model mirrors Flutter’s own widget hierarchy, making skills transfer directly. A typical Jaspr component looks almost identical to a Flutter widget:

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 familiarity drastically lowers the learning curve. Anyone who has written a Flutter widget can immediately contribute to the website’s frontend without learning a new paradigm.

One Language, One Stack

By adopting Jaspr, the Flutter team eliminated the need for Node.js and Python tooling. Everything—from static site generation to server-side logic to client-side interactivity—now lives in a single, unified Dart codebase. This simplifies the developer experience: new contributors only need Dart and Flutter skills, and existing team members can easily move between projects without context switching. The result is a consistent, streamlined workflow.

Support for Modern Web Needs

Jaspr also excels at the type of interactive content the team wanted. Because it supports both SSR and CSR, developers can choose the right rendering strategy per component. Interactive elements like code editors, quizzes, or live documentation previews can be rendered on the client for rich responsiveness, while static content is pre-rendered for performance and SEO. This flexibility was a key factor in the migration decision.

The Migration Process: From Fragmentation to Unity

Moving three websites—each with its own history and content—was no small task. The team took a phased approach:

• Audit existing content and functionality: They cataloged every page, interactive component, and dependency to ensure nothing was lost.
• Replicate core pages in Jaspr: The most critical pages—landing pages, documentation, and blog—were rebuilt first, using the new framework.
• Port interactive elements: Existing interactive pieces (code samples, search, etc.) were rewritten as Jaspr components, often with cleaner, more maintainable code.
• Test and iterate: The team ran extensive tests to ensure parity in performance, accessibility, and SEO before cutting over.

Throughout the migration, the team leveraged Dart’s strong typing and tooling to catch issues early. The shared codebase allowed them to reuse utility functions, theming, and component libraries across all three sites—a major improvement over the previous siloed approach.

Benefits: A Unified, Contributor-Friendly Stack

The results speak for themselves. Today, dart.dev, flutter.dev, and docs.flutter.dev run on Jaspr, bringing several concrete advantages:

• Consistent developer experience: Contributors only need Dart and Flutter knowledge. The same patterns work across all sites.
• Faster iteration: Changes can be made in a single language without context-switching between Node.js and Python tools.
• Rich interactivity: The team can now easily add features like live code editing, quizzes, and dynamic search without resorting to one-off DOM manipulation.
• Better maintainability: A unified stack means fewer dependencies to manage, easier upgrades, and a smaller surface area for bugs.
• Increased community contributions: Because the barrier to entry is lower, more community members can submit pull requests and improvements.

Looking Ahead: What This Enables

With the migration complete, the Flutter team is free to focus on what matters most: improving the developer experience for their users. Future plans include expanding interactive tutorials, adding more live demos, and integrating real-time collaboration features—all powered by Jaspr and Dart. The framework’s versatility means they can experiment with new rendering strategies (like partial hydration or islands architecture) as the web evolves.

Conclusion

The migration to Jaspr marks a turning point for the Dart and Flutter web presence. By eliminating the fragmented mix of technologies and embracing a single, Dart-powered framework, the team has created a unified, contributor-friendly ecosystem. For anyone building web experiences with Dart beyond standard Flutter web apps, this story demonstrates the power of a cohesive toolchain. The websites are now faster to develop, easier to maintain, and ready for the next generation of interactive content—all thanks to Jaspr and the language that started it all.