10 Key Insights from Rebuilding Flutter's Websites with Dart and Jaspr

When we set out to modernize the web presence for Dart and Flutter, we knew the status quo wasn't cutting it. Our three main sites—dart.dev, flutter.dev, and docs.flutter.dev—were built on a disjointed mix of technologies. After months of planning and execution, we migrated them to Jaspr, an open-source Dart web framework. The result? A unified stack that slashes complexity, empowers our community, and feels like home to any Flutter developer. Here are the ten biggest lessons and outcomes from this transition.

1. The Fragmented Stack: A Painful Reality

Our previous setup was far from elegant. Documentation sites relied on Eleventy, a Node.js static-site generator, while flutter.dev ran on Wagtail, a CMS built with Python and Django. This fragmentation meant contributors needed expertise in both Node.js and Python tooling, plus the Dart ecosystem we used for interactive components. Maintaining three separate tech stacks led to duplicated effort, increased friction for new contributors, and growing technical debt.

10 Key Insights from Rebuilding Flutter's Websites with Dart and Jaspr

2. Why Dart Was the Obvious Choice

Dart started as a web language and remains the foundation of Flutter. Since our team and community already know Dart, unifying on it eliminated the need to juggle multiple languages. By using Dart everywhere, we reduced onboarding time, enabled code sharing between sites, and aligned with the ecosystem our developers love. It was the natural move to streamline our web infrastructure.

3. Enter Jaspr: A Framework Built for the Web

Jaspr is a versatile Dart web framework that supports client-side rendering (CSR), server-side rendering (SSR), and static site generation (SSG). Unlike Flutter Web’s canvas-based rendering, Jaspr produces standard HTML and CSS, making it SEO-friendly and lightweight. It’s also open-source, so we can shape it to our needs while giving back to the community.

4. Widget Model That Feels Like Flutter

One of Jaspr’s biggest wins is its component model—it mirrors Flutter’s widget tree. If you’ve written a Flutter widget, you can read Jaspr code immediately:

class FeatureCard extends StatelessComponent { …
  return div(classes: 'feature-card', [
    h3([.text(title)]),
    p([.text(description)]),
  ]);
}

This familiarity dramatically lowered the learning curve for our team and opened the door for Flutter developers to contribute to web content without learning a new paradigm.

5. A Single, Consistent Developer Experience

With Jaspr powering all three sites, developers no longer need to switch between Eleventy, Wagtail, and Dart tooling. Everyone uses dart and jaspr CLI commands from day one. We also standardized build processes, testing, and deployment, reducing cognitive load and letting contributors focus on improving content rather than wrestling with infrastructure.

6. Interactivity Without Pain

Our old setup made adding interactive elements—like live code samples, quizzes, or dynamic navigation—a chore. We often resorted to one-off JavaScript and fragile DOM manipulation. Jaspr’s component architecture lets us compose interactive widgets declaratively, reusing Dart logic across pages. Now, adding a quiz to a tutorial or an interactive code runner is as simple as dropping a component.

7. Static Site Generation Done Right

For content-heavy sites like dart.dev and docs.flutter.dev, performance and SEO are critical. Jaspr’s SSG mode pre-builds HTML pages at compile time, delivering lightning-fast load times. At the same time, we can switch to SSR or CSR for pages that need server data or client-side interactivity—all within the same codebase. This flexibility allows us to optimize per page without juggling multiple frameworks.

8. Community Contributions Simplified

Previously, contributing to our websites required setting up Node.js, Python, and understanding two different build systems. Now, you only need Dart installed. Contributions flow more smoothly because the entire stack speaks one language. Issues like “I wanted to fix a typo but couldn’t get Eleventy running” are a thing of the past.

9. Code Sharing Between Sites

With a unified framework, we could create shared Dart packages for common components—like headers, footers, and code blocks—and use them across all three sites. Previously, identical UI elements had separate implementations in Jinja (Python) and Nunjucks (Node.js). Now, changes propagate instantly, and we avoid drift between sites.

10. Open Source Future and Community Growth

By adopting Jaspr, we contribute to its open-source development, helping it mature into a robust web framework for the Dart ecosystem. This encourages more developers to build web experiences in Dart, strengthening the community. We’re excited to see how Jaspr evolves and to welcome contributions from anyone who shares our passion for a unified web stack.

Conclusion

Migrating to Jaspr wasn’t just a technical upgrade—it was a cultural shift toward simplicity and unity. Our websites now reflect the very principles of Dart and Flutter: consistent, expressive, and developer-friendly. If you’re considering rebuilding your web presence with Dart, Jaspr offers a proven path. We hope our journey inspires you to explore the possibilities of a truly unified web stack.

Tags: