The Friendly Flutter Conference

Following the success of the first talk in the "Flutter Grimoire" series about demystifying the open-source magic of Dart and Flutter, it's time for a sequel!

This talk will cover how to create a publishable open-source package from scratch, cover all aspects such as code analysis, testing, CI and publishing, all the way to that coveted 160/160 score on pub.dev! ✨ As usual, there's some secret magic sauce to this that will be shared with the attendees* ;)

(*please note the "secret magic sauce" is a metaphor — no actual sauce will be distributed)

Debugging and maintaining apps can be tough. Fortunately, nowadays Dart offers various ways to improve development and maintenance.

Let's dive into: - Custom devtool extensions and VM services - Custom lint rules

Most Flutter apps treat AI as a cloud-only feature — send a request, wait for a response, pay per token. But what about offline scenarios, real-time interactions, or features where user data should never leave the device?

Hybrid AI combines cloud and on-device models in a single application. Cloud providers like Gemini or OpenAI handle complex reasoning and multimodal tasks. Local models — Gemma, Llama, DeepSeek, Phi, and others — run directly on the user's device for low-latency responses, offline access, and data privacy. The challenge has always been maintaining two completely different AI stacks with different APIs, formats, and deployment models.

Genkit's Dart SDK and its plugin system solve this. With plugins like genkit_flutter_gemma for TFLite/LiteRT models and genkit_llamadart for GGUF, on-device inference runs across Android, iOS, macOS, Windows, Linux, and Web — through the same API you use for cloud providers. Switching between cloud and local inference is a one-line change: same flows, same structured output, same tool calling — just a different model reference.

We'll start with an overview of Genkit — its core concepts, plugin architecture, and capabilities for building AI orchestrations: flows, structured output, tool calling, agentic workflows, and the middleware system. Then we'll dive into what makes Genkit on Dart unique — a native SDK that lets you build AI features in the same language as your Flutter app, from backend to frontend. Finally, we'll focus on the hybrid AI approach in detail: why it matters, what architectural patterns it enables, and how to build it in practice — configuring cloud and on-device models, defining shared flows that work with both, and switching between them through a single Genkit API without changing your application logic.

Over the past year, we've migrated all of flutter.dev, docs.flutter.dev and dart.dev to Jaspr, the open-source framework for building websites with Dart. The result is a unified stack with a consistent developer experience where contributing only requires Dart. In this talk, we share the full story of the migration, and see if Jaspr stood up to the task of powering documentation for millions of Flutter developers.

We will look at: - The challenges we faced while migrating each website. - What benefits and drawbacks we ended up with. - How dogfooding Jaspr at scale shaped the framework itself.

You will also get an early look at new and upcoming features in Jaspr — many of them driven by real-world needs from this migration — focused on improving developer experience, performance, and full-stack capabilities.

Whether you're building apps, websites, or both, this talk will show how Jaspr fills a crucial gap in the Flutter ecosystem. By the end, you'll have a clear picture of where Jaspr is today, how it holds up in production, and whether it's something you can confidently bring into your own stack.

Over the past year, we've migrated all of flutter.dev, docs.flutter.dev and dart.dev to Jaspr, the open-source framework for building websites with Dart. The result is a unified stack with a consistent developer experience where contributing only requires Dart. In this talk, we share the full story of the migration, and see if Jaspr stood up to the task of powering documentation for millions of Flutter developers.

We will look at: - The challenges we faced while migrating each website. - What benefits and drawbacks we ended up with. - How dogfooding Jaspr at scale shaped the framework itself.

You will also get an early look at new and upcoming features in Jaspr — many of them driven by real-world needs from this migration — focused on improving developer experience, performance, and full-stack capabilities.

Whether you're building apps, websites, or both, this talk will show how Jaspr fills a crucial gap in the Flutter ecosystem. By the end, you'll have a clear picture of where Jaspr is today, how it holds up in production, and whether it's something you can confidently bring into your own stack.

Did you know that Flutter natively supports building arbitrary renderers with zero external dependencies?

Use Flutter Scene (https://pub.dev/packages/flutter_scene) to easily add good looking 3D to your Flutter apps today!

The traditional mobile app release cycle is often a bottleneck for innovation due to the lengthy store review processes. Shorebird changes this with over-the-air (OTA) updates, enabling you to deploy logic changes and bug fixes in real-time to users' devices.

This introductory workshop provides a hands-on deep dive into integrating Shorebird into your existing Flutter workflow. We will explore the architecture behind Shorebird, walk through initialization, and demonstrate how to push OTA updates without lengthy store reviews (while maintaining compliance). Whether you're looking to fix a critical production crash or iterate on features at the speed of web development, this session will equip you with the tools to take back control of your app's lifecycle.

By the end of this workshop, participants will: - Understand the difference between releases and patches. - Initialize Shorebird in a Flutter app. - Instantly deploy a patch. - Rollback a patch.

Your designer would like to check out your changes, but they can't just flutter run it.

What if you could build the app, send a QR code, and have your designer scan it and tap around? That's what we're gonna show.

It's a talk about a collaboration problem solved by going pretty deep into the Dart VM.

This talk dives into the practical realities of monetizing Flutter apps through subscriptions and in-app purchases, covering both the technical implementation and the design decisions that determine whether users actually convert. We'll walk through how IAP works under the hood on iOS and Android, the quirks of integrating it cleanly in a cross-platform Flutter codebase, and the third-party tools that can save you weeks of headache around receipt validation, entitlements, and analytics. Beyond the code, we'll look at what makes a paywall feel inviting rather than pushy, how pricing and trial structures influence user behavior, and the small UX details that separate apps people happily pay for from ones they immediately uninstall. By the end, you'll have a clear mental model of the entire monetization stack in Flutter and a practical sense of where to invest your time to actually start earning revenue from your app.

As mobile applications grow into large, long-lived systems, maintaining a clear and scalable codebase becomes increasingly challenging. This talk explores a production-proven architectural approach for large-scale Flutter applications, successfully used for several years in a product with millions of users and a multi-million-line codebase, developed by a team of 100+ mobile engineers.

Built around a "LEGO" concept, where the application is composed of highly modular, interchangeable, self-contained building blocks, this architecture enables teams to develop and deliver features in isolation, while keeping the overall system consistent and maintainable. We'll cover key aspects such as code organization, state management, navigation, dependency injection, configuration, testing, and more, along with the principles that guided these choices.

You'll leave with practical recommendations for structuring large codebases and scaling development without sacrificing efficiency or maintainability.

In this hands-on workshop, we'll build a fun, creative mobile app using Flutter powered by Nano Banana.

We'll focus on turning simple prompts into rich visual experiences and shaping an interface that feels fast, interactive, and intuitive. Using Firebase, we'll connect everything into a smooth, real-time flow so users can generate and refine results instantly.

By the end of the workshop, you will: - Build a Flutter app that generates and edits images - Turn user input into dynamic visual results - Design a clean, responsive UI around generative features - Explore how AI reshapes modern app experiences

This session is practical, with a strong focus on building something real. You'll leave with a new Flutter app added to your developer portfolio and a clear sense of how to bring AI-driven creativity into your own projects.

No special prerequisites are required, just Flutter set up on your machine and an existing Firebase account.

Quick - name the first generative AI interface that pops to your head. Was it an input field and chat bubbles? I thought so.

As AI models get smarter and context windows grow, limiting our apps to just text feels outdated. Why settle for a paragraph of text when you could render a clickable carousel, a live chart, or a custom-built form? Generative UI (GenUI) allows us to move beyond simple chat and generate entire interactive experiences on the fly.

In this talk, we'll explore the Flutter GenUI SDK to learn how you can use orchestration layers and widget catalogs to transform AI intent into rich, interactive Flutter experiences.

Flutter for Desktop has been around since 2019 and has always been in the shadow of Electron or, more recently, Tauri. Where are we now in 2026? Why, despite clear benefits, is it still not getting that much traction? In 2026, multi-window support is more mature than ever, and we'll dig into that as well.

In the past adding Homescreen Widgets involved a lot of native code interactions: - Creating Infrastructure Files and Changes in Android Studio - Clicking around in Xcode to create additional Targets

And crucially writing Widget code in Kotlin and Swift, losing all the benefits of Flutter with "Write once run anywhere".

With some new additions to the home_widget ecosystem this is now a thing of the past! Either create Widget infrastructure from the CLI so only the Widget code needs to be handwritten — or even better: write Widget code once in Dart with a Flutter-like syntax and generate the full code with a single CLI command. You don't even need a Mac to write iOS Widgets!

In this session we will explore and go through all the (few) necessary steps to set this up and learn how fast it is now to write Homescreen Widgets for your Flutter apps.