Sessions List

AI is rapidly transforming the software development lifecycle, offering new ways for developers to build, test, and maintain applications more efficiently. From monorepo-aware coding assistants to agentic systems for large-scale code migrations, and from AI-generated tests to probabilistic agents reshaping quality strategies—this panel dives into the cutting edge of AI-powered developer tools. You’ll leave with actionable strategies for implementing AI in your own workflows, and practical ideas for driving meaningful productivity gains across your teams. >What does “AI-driven productivity” look like in practice across the software development lifecycle? >How can coding assistants be customized to work effectively in complex environments like monorepos or large codebases? >What are agentic AI systems, and how are they being used for tasks like large-scale code migrations or refactoring? >How is AI reshaping the traditional test pyramid—from the ground up with code generation, and from the top down with probabilistic testing? >What are some low-lift, high-impact ways mobile teams can start integrating AI into their workflows today?

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. Scaling an app under rapid growth presents significant engineering and business challenges. Attendees will learn strategies for handling system scalability, maintaining reliability, and making critical engineering decisions under pressure. > What are the challenges of scaling systems rapidly? > What best practices exist for re-architecting apps under pressure? > How can engineering leaders balance business goals with engineering constraints? > What strategies exist for building resilient and scalable architectures?

Building effective development teams hinges on prioritizing the developer experience. Poor tooling and inadequate support lead to cumbersome builds and inefficient workflows, creating friction that slows engineers and hinders their ability to deliver value. Join this peer discussion to share and discover practical strategies for boosting developer velocity and satisfaction. > How can we effectively measure the developer experience to pinpoint specific friction points that negatively impact team velocity and satisfaction? > What tools or strategies effectively boost knowledge transfer, reduce cognitive load, and accelerate onboarding? > What are your team's biggest DX pain points with builds, IDE, or CI, and what proven leadership tactics address them? > Where does your team experience the most friction day-to-day (e.g., with builds, IDEs, CI/CD, inefficient workflows)? What practical leadership tactics or tooling improvements have successfully addressed these pain points? > How can engineering leaders effectively quantify the impact of DX improvements on velocity, satisfaction, or overall value delivery to justify necessary investments to stakeholders?

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. As mobile teams scale, specialization becomes essential, but striking the right balance between deep expertise and cross-functional flexibility is challenging. This session will explore different specialization paths in mobile engineering and how leaders can structure teams, hiring, and career growth to maximize both innovation and long-term success. > What are the key specialization tracks in mobile engineering? > How can engineering leaders ensure specialization doesn’t create silos within a mobile org? > What strategies help balance hiring and training across specialized and generalist roles? > How does a specialist career track impact long-term growth, leadership opportunities, and adaptability? > What are best practices for integrating specialists into cross-functional product teams?

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. With Kotlin Multiplatform (KMP) and Flutter proving their long-term viability, mobile leaders must navigate the intersection of cross-platform and native development. This session will analyze the strengths and limitations of cross-platform approaches and provide guidance on structuring mobile projects to leverage both paradigms effectively. > How can cross-platform and native development coexist within the same project or company? > What are the primary advantages and trade-offs of cross-platform solutions compared to native? > What types of apps or features benefit most from a cross-platform approach? > How have KMP and Flutter evolved beyond past expectations, and what does that mean for long-term strategy?

A strong engineering culture is crucial for mobile teams to scale efficiently, retain top talent, and drive innovation. This roundtable will explore strategies for fostering an adaptive, inclusive, and high-performing engineering culture across remote, hybrid, and in-person teams. What are the most effective ways to document, spread, and reinforce engineering culture in mobile teams? How do mentorship, knowledge sharing, and in-person events contribute to a strong culture? What common pitfalls can erode engineering culture, and how can leaders prevent them? How does engineering culture evolve over time, and what leadership actions sustain it? What metrics or signals indicate a thriving vs. struggling engineering culture?

If you’ve been in the workforce long enough, you’ve probably had at least one bad boss and if you’re lucky, you’ve had at least one great boss. What is it about the good ones that inspired you? What did they do to establish themselves as leaders? What made you want to work hard for them? In this session we’ll explore the qualities of true leadership. You’ll walk away with strategies on how to inspire your teams and you’ll learn that you don’t have to wait for the promotion or the “management title" to show up as a leader.

Growing an Android team from a handful of developers to 50+ without imploding requires more than just good intentions—it demands architecture, automation, and guardrails that make the right decisions inevitable. At Square, we’ve built a mobile codebase that enables teams to collaborate efficiently, share components like Lego blocks, and avoid stepping on each other’s toes—even in a 5M+ line monorepo with 100 Android ICs actively contributing everyday. But you don’t need to be at Square’s scale to benefit. If your team is 10+ and growing, the challenges of coordination, consistency, and performance creep up fast. This talk will equip you with actionable strategies you can start implementing today to keep your engineering team productive over time. In this talk, you’ll learn how we: * Use a consistent UI framework to enforce strict yet flexible contracts, making UI and business logic highly composable. * Slash build times by modularizing code, separating interfaces from implementations, and structuring dependencies to minimize build times. * Ensure consistency at scale with custom lint rules and CI checks that enforce best practices. You’ll see real-world CI checks from Square that you can apply to your own projects—preventing dependency misuse, enforcing modularization, and maintaining architecture standards—to help engineers "fall into the pit of success" without constant oversight. These aren’t just theories—they’re battle-tested strategies that have helped us maintain velocity without sacrificing quality. Of course, it’s not always smooth sailing. I’ll share the challenges we’ve faced, the landmines we’ve hit, and how we’ve had to pivot along the way—so you can avoid the same pitfalls.

A strong engineering culture is crucial for mobile teams to scale efficiently, retain top talent, and drive innovation. This roundtable will explore strategies for fostering an adaptive, inclusive, and high-performing engineering culture across remote, hybrid, and in-person teams. > What are the most effective ways to document, spread, and reinforce engineering culture in mobile teams? > How do mentorship, knowledge sharing, and in-person events contribute to a strong culture? > What common pitfalls can erode engineering culture, and how can leaders prevent them? > How does engineering culture evolve over time, and what leadership actions sustain it? > What metrics or signals indicate a thriving vs. struggling engineering culture?

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. AI coding assistants have been hyped as game-changers for software engineering, but how effective are they in practice? This session provides a reality check on current AI coding tools, analyzing what works, what doesn’t, and how these tools impact software development workflows. You'll get a chance to discuss best practices, challenges, and the future trajectory of GenAI in software development with your peers and examine: > What is the current state of AI coding assistants? >How are AI coding assistants improving developer productivity? > What AI tools are effective for software development today, which ones are disappointing? > What are the future trends and implications of AI-driven software development? > What are the implications for cross-platform development?

Gain insights from engineering leaders about how effectively managing technical debt in their codebases. We'll discuss approaches to prioritization, refactoring, and establishing healthy development practices to ensure long-term maintainability and team velocity. We'll discuss questions like: >What are effective methods for identifying and quantifying technical debt in projects to make informed prioritization decisions? >How can engineering leaders effectively communicate the business impact of technical debt to product teams and secure resources for necessary refactoring efforts? >What are proven strategies and processes for preventing the accumulation of technical debt in mobile development workflows, considering the nuances of both native Android and cross-platform frameworks? >Beyond dedicated refactoring sprints, what are some incremental approaches and engineering practices that can be integrated into daily development to continuously address technical debt and maintain codebase health?

Engineering teams often rely on traditional metrics, but are these truly driving better outcomes? This session examines conventional measurement approaches and explores how to combine performance measurement with positive developer experience. Attendees will learn how to measure team effectiveness in a way that fosters engagement, alignment, and long-term success. • What are the limitations of traditional engineering metrics? • How can KPIs be balanced with developer experience? • What frameworks exist for measuring team effectiveness? • What strategies exist for improving alignment and engagement? • What actionable insights can be used to drive high-performance engineering teams?

This session will take you on a journey through the world of server-driven UI in Flutter, where I'll share hard-won lessons from my time in the trenches at enterprise scale. Have you ever had to wait a week for App Store approval after fixing a tiny UI bug? I have. I'll walk you through how SDUI freed our team from those painful app store cycles, helped us maintain perfect consistency across platforms with a single source of truth, and dramatically improved our development workflow. I'll share the real performance optimization techniques we discovered (including some mistakes you can avoid), and show you exactly how we implemented patterns that scaled with our growing user base. By the end of this lightning talk, you'll have practical strategies you can apply to your own Flutter projects—whether you're building your first app or managing a complex enterprise codebase! Key Takeaways - Learn how server-driven UI allows you to ship UI updates instantly - Discover how using a single source of truth on the server helps ensure your Flutter app looks and behaves the same across platforms - Get real-world insights into performance optimizations, architectural patterns, and common pitfalls to avoid

Embark on a nostalgic yet instructive journey as we explore the process of breathing new life into Rogue, a seminal 40 plus year-old turn based synchronous game, using the power of Flutter. During this session we will 1) Duplicate the original UI with an eye towards creating a proper graphics interface. 2) Deconstruct the syncronous interface and design a modern class based asynchronous Flutter program. 3) Discuss existing game frameworks like Casual Flutter Games Toolkit and Flame and how we can leverage them in our program 4) Finally, we will discuss lessons learned and next steps

The dreaded RenderFlex frustration gets us all sooner or later. Why is that, and what's going on under the hood to cause it? In this entertaining deep dive we'll go into the multi-child layout algorithm and look carefully at each step in the process, demystifying it once and for all. After this talk you will: - Understand the six steps in the process of laying out multiple children. - Understand why RenderFlex errors happen and what you can do about them. - Never let the Flex, flex, FlexFit, and Flexible leave you Flummoxed again. Come join us not only because the talk is informative, but also because it's a hilariously good time!

Unfortunately there is too much advice given online about the right way to write software that often tends to be very dogmatic and is outright harmful if not understood correctly. One prime example is the demand that all objects should be immutable to avoid problems. I will show you why we should avoid these kind of dogmatic thinking and why immutability might not even be something you want to strive for. As an alternative I will introduce you to ProxyObjects as a more flexible alternative

Discover why Universal Studios adopted Flutter as the foundation for its park's mobile platforms and more—and what they've learned along the way. In this panel, engineering leaders will share why they made the switch, the value they’ve seen since implementing Flutter, and the key challenges they’ve worked through during the transition. You'll hear insights into how Flutter has influenced developer productivity, improved user experience, and what opportunities lie ahead as they continue to scale the framework across the organization.

Interop with dart:ffi promises to make native libraries libraries available to apps without writing full-blown Flutter plugins or dealing with platform-specific build configurations. However, dart:ffi itself offers no mechanism to actually bundle native libraries with apps, requiring complex workarounds. Dart’s upcoming native assets feature fills this gap. This talk gives an overview of that feature and how it can be adopted by packages today. Key takeaways from this talk are: - An overview of the new @Native interop style used to call C from Dart. - How build hooks can be used to easily compile native code across platforms. - Which steps package authors can take to adopt native assets without breaking users. - Features to give users more control over their native dependencies. The talk introduces necessary concepts, but assumes basic familiarity with dart:ffi and writing Flutter plugins.

We're entering a new era of interactive applications, where user interfaces are not just passive displays but active collaborators. This talk explores how Flutter developers can build powerful 'agentive experiences' that anticipate user needs and proactively guide them, transforming static apps into dynamic, intelligent partners. Prepare for this new paradigm as Andrew examines, What is an Agentive Experience? The Value of Agentive Experiences: Measuring Impact Reusable Patterns for Implementing Agentive Workflows in Flutter Privacy and Ethical Considerations in Agentive Design The Future of Agentive Flutter Applications

This talk provides practical insights and best practices gained from the real-world development of google_navigation_flutter — a plugin bridging the native Google Maps Navigation SDKs with Flutter. Key topics include: - High-level introduction to Google Maps Navigation - Effective documentation strategies - Importance of comprehensive feature coverage in the example app - The benefits of a unified API design - Real-world testing strategies - Extending support for the Driver SDK This talk offers broadly applicable practical tips for Flutter plugin development.

After the disappointing (if understandable) decision to abandon macros, what can we do about json serialization? This talk will discuss the current state of the art for using json in our applications including existing packages, rolling our own, and that part of macros that will survive.

Sometimes in Flutter, you need to access a native system, library, or API that doesn’t already have a Pub package available to you, so you have to bind it yourself. Dart and Flutter provide several different methods for leveraging native libraries and APIs: Method Channels, JS Interop, FFI to C, FFI gen to Swift and Objective-C, and JNIgen. Which one is right for your use case? This talk will take a look at the various methods for plugin development, their benefits and drawbacks, and some gotchas you might run into when developing complex plugins.

Supabase gives you a powerful PostgreSQL backend out of the box—but that power comes with risky responsibilities. In this session, I’ll talk about real-world lessons from building and scaling a production Flutter app with Supabase, focusing on four areas where things can and do break if you’re not careful: schema design, row-level security, edge functions, and performance. You’ll learn: - Why not planning foreign key relationships early on can block feature rollouts later - The difference between a working RLS policy and a secure one, and how I accidentally exposed private data to the wrong users - How writing logic in the wrong place (client vs function) caused avoidable downtime and security risks - How RPC & Edge Functions helped offload expensive client operations for faster UX Join this talk to learn some PostgreSQL tips, and practical fixes to keep your Supabase-backed Flutter app fast, secure, and production-ready.

Flutter for Mobile is released, Flutter for Web is released, Flutter for macOS, Linux, and Windows is in also released and it's really cool that Flutter officially supports six platforms. But what if I want to run my Flutter app on the TV? Unfortunately, nobody has heard of the official Flutter for TV yet. Actually, a Flutter app can be launched on TV (not AndroidTV only, but AppleTV, Tizen, and others as well). In my talk, I'm going to tell you how to do this, what difficulties and issues you will face, and how to resolve them.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. > How can developers get started with contributing to Flutter’s open-source projects? > What are the best ways to build and maintain Flutter packages and plugins? > What are some inspiring success stories from developers who contributed to Flutter and advice? > How do contributions to Flutter help boost a developer’s career and visibility? > What are the challenges and rewards of maintaining open-source projects in the Flutter ecosystem?

Effective error handling is crucial for building robust and reliable Dart and Flutter applications. This session goes beyond basic `try`/`catch` blocks to explore the nuances of Dart's exception system. We'll delve into best practices for throwing, catching, and propagating exceptions effectively within your application architecture. Learn when and how to create meaningful custom exceptions, handle errors in asynchronous code (Futures and Streams), differentiate between Exceptions and Errors, and implement strategies for clear error reporting and monitoring in production Flutter apps. Elevate your code quality by mastering exception handling in Dart.

Let’s take a deep dive into Flutter’s Semantics Widget and see how it helps with accessibility and screen readers. I’ll walk you through how semantics work under the hood, how to use semantic widget to improve the user experience, and some best practices for making apps more inclusive. Whether you’re just starting with accessibility or want to fine-tune your implementation, this talk will give you the tools to make your Flutter apps more usable for everyone.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. > What are the most anticipated features on the Flutter roadmap? > How are Flutter and Dart evolving to meet new technological demands? > What features do you wish were being developed that are NOT on the roadmap? > How can the community contribute and impact the evolution of Flutter?

In this session we'll introduce Flutter's newly available Vertex AI SDK. Takeaways: 1. How to set up Firebase AI SDK 2. How to develop an agentive app using Firebase AI SDK 3. How to receive feedback using Firebase AI SDK

Discover Firebase Studio, Google's new AI-powered, cloud-based workspace designed to supercharge your Flutter development. Integrating a CodeOSS IDE, Gemini AI assistance, and seamless FlutterFire support , Studio streamlines building, testing, and deploying full-stack Flutter apps.Learn how Studio's AI accelerates Dart/FlutterFire coding , how Flutter templates get you started faster , and how to securely infuse your apps with the Gemini API using the production-ready Vertex AI in Firebase SDK —often without a dedicated backend.Key Takeaways: Leverage Firebase Studio for Flutter; Boost productivity with AI assistance; Integrate Gemini securely via Vertex AI; Streamline your workflow from idea to deployment.

Join this unconference-style session designed for interactive group discussion. Whether you want to share your insights or simply learn from others, everyone is welcome in this community-driven learning experience. > What causes excessive widget rebuilds, and how can developers minimize them? > What are the best practices for structuring widgets efficiently for performance? > What are the common performance bottlenecks you encounter when implementing complex animations and UI elements in Flutter? > What techniques do you use to optimize animation performance and reduce jank? > How do you profile and debug rendering performance issues in Flutter? > What improvements could be made to Flutter's rendering engine and animation APIs to improve performance and developer experience? > How can developers handle responsive design across different screen sizes?

Managing multiple app versions doesn’t have to be a headache. With Flutter Flavors, you can easily create separate builds for Android and iOS—whether it's for development, staging, or production—while maintaining a single codebase. In this session, we’ll dive deep into: Setting up Flutter flavors for Android (via Gradle) and iOS (using Xcode schemes), with clear and easy-to-follow configurations. Automating your build process with GitHub Actions, including how to configure workflows to handle multiple flavors automatically. Deploying your flavors with confidence to different platforms, such as Firebase App Distribution, Google Play, and TestFlight, making sure each flavor goes to the right environment. By the end, you'll have a streamlined, automated CI/CD pipeline that ensures your Flutter apps are built, tested, and deployed efficiently—saving you time, reducing human error, and letting you focus on what truly matters: building awesome features. This session is perfect for Flutter developers looking to master multi-environment setups, automate tedious processes, and elevate their app deployment game.

Unleash your inner maker. In this session learn to push Flutter far beyond the usual boundaries. Discover ways to connect Flutter to the world of DIY electronics, prototyping, 3D printing, and more! Topics covered include serial communication, running Flutter on a Raspberry Pi, basic Arduino programming, and interacting with electronic devices using GPIO. Seasoned engineers and new developers alike will benefit from practical demos and real-life tips to spark ideas. Don’t miss this unexpected mashup of hardware and software design.

Q&A session with members of the Flutter team. Panel members are from the developer relations team, the framework team, and management.

As the Flutter framework continues to grow and change, it expands beyond what the team at Google can manage themselves. In this keynote, we'll discuss how we continue to scale Flutter as a community, what we really need from the team at Google and how do we work together to take Flutter to the place it needs to be realize it's full potential in our industry.

Join the Flutteristas as we discuss the limitations of current DEI efforts and where well-intentioned initiatives may have fallen short. We’ll look at how we can move beyond checking boxes and get back to the original spirit of DEI.

Golden tests are a great tool, but are poorly understood, and rarely used. This talk takes a deep dive into how golden tests are implemented by Flutter, surveys common difficulties when using golden tests, and introduces new tools built by the Flutter Bounty Hunters to solve those common problems.

Remember those matrix operations from school you thought you'd never use again? Dive into the world of Flutter's Matrix4 and discover how fundamental operations like scale() and transform() can bring your UI to life in ways you might not have thought of. We'll demystify how Flutter utilizes matrix transformations, cleverly handling translation, rotation and scaling within its core mechanics. You'll learn how these are applied using the Transform widget, how to layer them effectively, and how Flutter's Axis system interacts with these transformations. Mastering these fundamentals is key to building compelling animations, smooth zooming functionalities, and other dynamic visual effects with precision. Going beyond theory, we'll showcase real-life examples from a production application, demonstrating how these techniques are used to handle complex and performant animations and interactions. Learn practical techniques, see matrix math turn into UI magic, and equip yourself with the skills to implement visually engaging experiences in your Flutter applications.

Flutter Web is rapidly maturing with features like stateful hot reload and WASM compilation, but the default full-screen application model presents challenges for integration into large, existing web platforms. While iframes offer isolation, they introduce complexities in communication, styling, and context sharing. This talk is about taking a more integrated approach: embedding multi-view Flutter apps within your host web app, using custom initialization logic instead of relying on the standard generated index.html and its associated bootstrap script. We dive into how multi-view apps allow multiple, independent Flutter components to be initialized at runtime in different parts of an existing web application. These views can share state internally, communicate with the host via JS interop and benefit from deferred imports to reduce startup times. This session will show a case study of how we implemented multi-view embedding at Robaws to reuse an existing feature from our mobile Flutter app within our existing web application. We discuss the benefits, such as how our Web and Flutter team could continue to work independently and how this allowed us to easily add multiple other Flutter features without overhead. We also explain why we chose having 1 multi-view app over multiple smaller apps. Furthermore, the talk goes over some unintended improvements that adopting web had to our existing mobile apps, such as better support for large tablet screens. Finally, we go over some challenges when embedding existing features in a web app, such as URL strategies, using plugins that only support mobile platforms, etc). The talk will also include some practical approaches for easy development, such as using separate build modes (mocked standalone without embedding, local server with embedding, final hosting of static release build), handling JS interop for passing context like design tokens and localization, and managing potential CORS issues during development. This talk is aimed at Flutter developers who want to explore the possibilities of adding Flutter to their existing web applications and will focus on less explored concepts, such as deferred imports, custom initialization and Flutter views interacting with each other and with the host web app.

Displaying an image in a Flutter app seems straightforward—just use an Image widget and you’re done, right? In reality, what appears simple on the surface conceals a surprising depth of complexity. From raster images and SVGs to icon fonts and vectors, Flutter offers a range of options for displaying images—but picking the right one for the right context is rarely as obvious as it seems. In this talk, we’ll peel back the layers of abstraction to examine how Flutter handles image rendering under the hood. You’ll learn the strengths and limitations of different image formats, explore their impact on performance and scalability, and discover how platform-specific behaviors can affect your users’ experience. What you’ll learn: * The internal workings of Flutter’s basic image widgets * Tradeoffs between rasterized images, SVGs, vector graphics, and icon fonts * How to choose the optimal image type for your use case * Performance considerations and pitfalls to avoid * Real-world scenarios where image type choice really matters * I’ll also introduce a new tool I created to streamline and simplify how we handle images at ClickUp

In this session, we'll go through taking a simple no-database app, generating a new schema using Gemini, and then using new generated SDKs for their app. Takeaways: 1. How to set up Firebase Data Connect 2. How to use Gemini to create new schemas for your app 3. How to generate typesafe SDKs for your app using Firebase Data Connect

Have you ever been puzzled by the error "called on null BuildContext"? Or perhaps you've struggled to make Navigator.of(context) work as expected? These are just a few of the many common issues that arise when BuildContext is misused in Flutter. In this talk, we’ll start from the very basics and demystify what BuildContext actually is and how it functions within the widget tree. You’ll learn why BuildContext is crucial for navigating, managing states, and maintaining a smooth UI in your Flutter apps. We'll explore common mistakes, like using the wrong context after async operations or outside the widget lifecycle, and discuss what goes wrong when these mistakes happen. You’ll also get insights into handling BuildContext correctly when dealing with dialogs or modals. I’ll walk you through real-world examples to explain how to use BuildContext safely and effectively, ensuring you can write more robust and scalable Flutter code. By the end of this session, you'll not only understand the underlying mechanics of BuildContext, but you’ll also have a solid strategy for preventing the most common issues developers face, empowering you to build better, more maintainable Flutter apps. Key Takeaways: - Understand what BuildContext truly is and how it drives widget management and navigation in Flutter apps. - Learn to identify frequent mistakes with BuildContext usage and how to fix them for more stable and error-free apps. - Master the use of BuildContext when opening dialogs, modals, and performing navigation to avoid unexpected behavior.

Developing complex web applications with Flutter often requires some JavaScript and understanding how to use js_interop is essential. We'll talk through getting started with the basics, common pitfalls and tips for success.

Material and Cupertino are the most popular widget kits in Flutter. But those widget kits are primarily mobile-oriented. The community needs a greater selection of desktop-oriented widget kits. In this talk, you will learn about many of the UI and UX responsibilities that come with creating desktop widgets, as we explore offerings from Lucid, a desktop widget kit for Flutter apps.

If you’ve been in the workforce long enough, you’ve probably had at least one bad boss and if you’re lucky, you’ve had at least one great boss. What is it about the good ones that inspired you? What did they do to establish themselves as leaders? What made you want to work hard for them? In this session we’ll explore the qualities of true leadership. You’ll walk away with strategies on how to inspire your teams and you’ll learn that you don’t have to wait for the promotion or the “management title" to show up as a leader. NOTE: This can be adapted to a lightening talk or a round table discussion.

Over four years ago, I had the opportunity to present "Lessons Learned Building Invoice Ninja" at Flutter Europe 2020. It was an exciting time as we had just launched our Flutter Web app: https://demo.invoiceninja.com A lot has happened since then! In my upcoming talk, I'll share the valuable lessons we've learned along the way, covering topics such as: - Leveraging Flutter Web in a production environment - Deploying desktop apps across Microsoft, Apple, Snap, and Flatpak - Navigating the challenges of app store reviews - Insights into state management options - Techniques for optimizing app performance - Practical tips to enhance developer efficiency - Thoughts on what the future holds for Flutter Check out the original talk here: https://www.youtube.com/watch?v=G30K5wm7j_M I look forward to exploring how far we've come since then!

CustomPainter gives you full control over the canvas in Flutter, which is perfect for building visuals that standard widgets just can’t handle. In this session, I’ll share how I used CustomPainter in a real production feature to draw and manipulate paths. We’ll also touch on vector theory and how to transform an SVG into custom path data that you can use directly in your Flutter app. You’ll learn how to structure drawing logic, break down complex visuals, and approach custom UI challenges with confidence—especially when your design ideas don’t fit into a widget box. Key Takeaways: - Understand how CustomPainter works and where to use it - Learn how to transform SVG paths into Flutter-compatible custom drawings - Explore core vector theory concepts applied in Flutter - Break down complex drawing logic for real UI implementations - Get inspired to go beyond widgets for unique, custom UIs

Key Takeaways and Learning Points - A deep technical look at Dart isolates, Flutter runtime, and app execution on Android/iOS - How the Dart runtimes start executing on Native App launches - Understanding the Dart isolate entry-point and customizing it for your app's needs - Creating custom isolates triggered by geofences, notifications, or background tasks - Real-world techniques to optimize resource sharing between isolates

Stop letting custom widget styling become a chaotic mess! This session delivers scalable best practices you can immediately apply to bring clarity and maintainability to your Flutter UI. We'll break down actionable patterns for effective theming, including encapsulating styles in dedicated classes for better organization, leveraging WidgetStateProperty for dynamic state-based visuals, and using WidgetStatesController to handle rebuilds. Plus, we'll touch on hierarchical theming for managing complex component relationships. If you're looking to build robust component libraries or simply write cleaner, more maintainable UI code, this talk provides the practical insights you need to master widget theming in Flutter. Key takeaways: - Understand how to build well-structured theming solutions for your custom widgets that integrate effectively with your design system. - Learn actionable patterns for encapsulating style properties in dedicated classes to enhance code clarity and simplify style modifications. - Discover how to leverage WidgetStateProperty to manage visual changes based on widget states without complicating your widget's logic. - Understand how to effectively use WidgetStatesController to manage interaction states and optimize widget rebuilds for better performance. - Learn how hierarchical theming can help you manage and organize styling for complex custom widget structures.

AI is moving very fast and a lot has changed even since the first "Flutter and Dart and AI, Oh My" talk in September of 2024. In this talk, I'll update you on the state of the Flutter AI Toolkit, how to use it with both closed and open source LLMs and how to extend it for us with your apps and data. In addition, I'm going to show you tools and techniques you can use as a Dart and Flutter developer to fast-forward your development using the latest AI tooling. This talk will be filled with demos -- it's not one you're going to want to miss!

What are the biggest challenges when targeting mobile, web, and desktop from a single codebase? What are the most common challenges you face when integrating native platform features (e.g., specific hardware access, platform APIs) into your Flutter apps?" What approaches exist for building hybrid apps that mix Flutter with existing native code? How do plugin dependencies and package support vary across platforms? What tools and libraries help streamline multi-platform development?

Ever wondered how Flutter could handle multiple wireless technologies like UWB and BLE in a single app? In this session, we'll dive into the exciting world of multi-radio applications, stepping beyond basic examples to tackle real-life scenarios. I'll share practical insights on how these technologies complement each other, discuss the architecture patterns that help keep your code clean and maintainable, and highlight performance considerations to ensure your apps remain responsive, even when juggling multiple data streams.

Build responsive, real-time control systems with Flutter & WebRTC! This talk tackles building 'snappy' remote robot control. Discover why Flutter & WebRTC are a great combination for handling low-latency data and video crucial for teleoperation. Learn practical Flutter integration, connecting your UI instantly to remote hardware. We'll cover essential concepts, Flutter patterns, key packages/libraries, and the core APIs you need to start building.

Every more advanced Flutter developer has heard of RenderBoxes, their layer, and their advantages over containing themselves just in the Widgets world. But in reality, a small number of developers have ever written one, they’re usually intimidated by the amount of boilerplate to write, and the methods to override, most with some scary-looking name. In this talk, I’ll introduce the audience to the boxy package and its CustomBoxy and BoxyDelegate classes that make taking advantage of the render object layer a very low-hanging fruit that is easy to understand, with almost no boilerplate and some advanced features if you feel like it. I’ll start by quickly reminding you how rendering widgets in Flutter works, when we need to step up the game from just the widgets layer, and what Flutter framework gives us (5 approaches of the varying magnitude of complexity) for render object layer development. Then I’ll dive in the BoxyDelegate world solving a few real-life production UI problems and I’ll talk about the pros and cons of BoxyDelegate and how I use it on a daily basis. Spoiler alert: BoxyDelegate is a wrapper on RenderObject API making it 3x more convenient to use.

Are you ready to explore the uncharted territories of Flutter graphics? 'Rive: The Final Frontier of Graphics for Flutter Apps' will guide you through the next evolution of UI/UX. Discover how Rive's real-time interactive animations and lightweight runtime are redefining what's possible in Flutter. I'll show you how to break free from traditional static graphics and create dynamic, engaging experiences that will set your apps apart. Crucially, I'll demonstrate how Rive streamlines the designer-developer handoff, allowing for seamless collaboration and rapid iteration through its single file format and intuitive editor. You will learn how Rive's powerful state machines and intuitive editor can revolutionize your workflow and unlock the potential for truly immersive user interfaces. Join me as we venture into the final frontier of Flutter graphics!

When was the last time you had to ensure that your new feature works well in all required states but this feature was deep down in your app and you had to use hot restart, navigate back and forth to test all required states? Do you remember how it felt? Did you try to tear your skin off your face because it was so tedious? No worries, you’re not alone😅 That is how I felt for years… I wanted to make it stop. I’m happy to tell you that I built a solution! Widgetbook - an open-source Flutter package that allows you build your components in isolation. In this talk, you’ll learn: - How to build widgets in isolation - How to quickly test your widgets in all different states - How to review your own (and your team’s) UI changes in your Git environment without the need to checkout the code locally and run it to see how it looks like

The age of AI is upon us, yet powerful Large Language Models often remain isolated, unable to interact meaningfully with our application data and user context. This talk explores the Model Context Protocol (MCP), an open standard emerging as the "USB-C for AI," designed to break down these barriers. We'll journey through MCP's architecture, its core capabilities (Tools, Resources, Prompts), and why it's a game-changer for creating truly context-aware applications. As the author of mcp_dart, I'll share the quest to bring this power natively to the Dart & Flutter ecosystem, showcasing how mcp_dart enables seamless integration. Discover eye-catching use cases like AI understanding Figma designs and fueling the "vibe coding" trend, and see a live demo of mcp_dart in action. Join us to learn how you can equip your Flutter and Dart applications to not just use AI, but to truly collaborate with it

## Abstract The static interface era is ending. This session explores "Fleeting Interfaces" - ephemeral UIs that intelligently evolve without explicit programming. Unlike traditional adaptive designs, these interfaces transform based on usage patterns and context, with elements appearing, adapting, and vanishing as needed. Through schema-driven architecture in Flutter, powered by Gemini for decision-making, I'll demonstrate how interfaces become living temporal experiences. Discover how combining Flutter's rendering capabilities with AI can create interfaces that respond to the fourth dimension - time - establishing a new paradigm for truly responsive digital experiences. ## Session Details See the future of UI with Flutter and Gemini AI: * Build with behaviors, not states: Schema systems that adapt naturally * Smart interfaces: AI-powered decisions based on how users interact * Live demos of tomorrow's UIs: * Interfaces that shift with context and learn from use * Elements that appear when needed and vanish when done * Demos showing real world applications ## Key Takeaways 1. Understanding the shift from static to ephemeral interfaces: UIs that appear, adapt, and vanish based on context 2. Approach to defining interfaces through behaviors rather than explicit states 3. Techniques for integrating Gemini AI to make UI decisions based on usage patterns 4. Practical strategies for implementing schema-based adaptive interfaces in Flutter 5. Real-world applications demonstrated through adaptive dashboard and cooking app examples

Delve into advanced Flutter rendering by harnessing RenderSliverMultiBoxAdaptor, RenderObjectElement, and a tailored SliverChildDelegate to craft slivers that lazily build and recycle children on-demand. I’ll begin with a concise overview of Slivers, the RenderSliver family, and how these three classes collaborate inside Flutter’s widget–element–render pipeline. Next we will walk step-by-step through a practical example, designing and implementing a custom sliver that keeps memory low while scrolling remains butter-smooth. We will explore how to lay out and paint the sliver and its children, touching briefly on how SliverConstraints and SliverGeometry provide the scroll metrics that drive those calculations. Lastly we will make the sliver interactive—wiring up hit-testing, gestures, and a dash of custom paint to achieve the exact look and feel your design calls for. This session will deepen your understanding of Flutter’s rendering engine and give you the knowledge to create your own custom widget using a more low-level API.

Dart is a great programming language for most apps. It's modern, strongly-typed, null-safe, and memory-safe. However, it is not particularly fast compared to other compiled languages. The solution for Flutter apps that require better performance for compute-heavy tasks is Dart Foreign Function Interface (FFI). FFI allows functions written in different languages to be called from Dart code. This means that most of the app can be written in Dart, but specific compute-intensive tasks can be implemented in a lower-level language like C, which can be up to 5x faster. We will cover the following topics: - What is Dart FFI? - What are the limitations of Dart FFI? - How to use Dart FFI in a Flutter app - What is the difference in performance between Dart and C in real-life examples?

AI is here to stay, it fundamentally changes the way we build software. In this workshop we will be vibe coding a project from scratch. Exploring various areas of AI driven development such as: - Prompting techniques - Limitations of AI - Difference between LLMs - Tools for using AI This workshop aims to bring a deeper understanding on how you can use AI today to improve your overall efficiency as a software engineer.

Vibe code, no-code, lo-code - the one thing these all still mention is: code. Code is the lingua franca for telling computers what to do. But as all these tools continue to evolve, is code really still the best language for that?

What if your app could sense the world around it and respond before the user taps anything? This talk explores how to build real-time, spatially aware apps using Flutter and the official ArcGIS Maps SDK for Flutter by Esri, the global market leader in GIS software, location intelligence, and mapping. Unlike lightweight community plugins, Esri’s SDK offers enterprise-grade precision, full geospatial services, and advanced capabilities like geotriggers, routing, satellite imagery, and background location monitoring through a Flutter-native API. We’ll cover: - Geotriggers that respond when users enter/exit spatial zones - Offline-first awareness with background location tracking - Voice navigation using Flutter TTS for real-time audio directions - Satellite imagery and dynamic mapping layers - Reactive spatial UX with interfaces that adapt to user position in real time You’ll learn how to create apps that feel intelligent and responsive to movement and place. We’ll walk through a live demo that combines background geotriggers and voice-guided navigation, ideal for tourism, field ops, agriculture, or emergency response. This session is perfect for Flutter devs who want to go beyond pins on a map and into smart, geospatial UX.

Many developers feel that writing tests is just busywork — a distraction from the real work of writing the code that users will run. And they're not wrong: in too many codebases, too many of the tests really are busywork. A busywork test doesn't meaningfully help catch bugs, and consumes effort not only to write the test but to update it again and again as things change in the codebase. But it doesn't have to be that way. The right techniques can make a test more effective at catching bugs now, and preventing regressions next month and next year. The same techniques can greatly reduce the burden of maintaining tests as the codebase evolves, and make the tests easier to read, with less code, even while being more comprehensive. Done right, tests are an affordable investment today that lets your team develop faster and more confidently tomorrow, and deliver a higher-quality product. The core techniques apply in any language or framework. Flutter offers especially rich support for writing high-quality tests right up through the UI layer, as we'll see. In this talk, I'll share the principles I've seen work, with practical tips and examples from real-world code: * How to choose what layer of API a given test should operate at (beyond the binary of "unit test" vs. "integration test"), to make it both low-maintenance and high-signal. * The specific tools from Flutter's rich test framework that enable writing tests at a range of different layers. * How to factor out the boring setup from each test case in ways that make the test easier to understand, not harder, and enable writing more tests with less code and less maintenance. * How to imitate Flutter's own "binding" system (a form of dependency injection) to let tests cleanly simulate network requests, your database, and all the Flutter plugins you use, and how to apply package:fake_async to manipulate time itself. * The package:checks library, an alternative to `expect` designed for modern Dart and backward-compatible with `expect`-style matchers. I've put these principles into practice in Zulip, and coached numerous contributors to write high-quality tests there. Some points are inspired by my experience in the upstream Flutter tree itself, which is relentless about testing all kinds of changes, and I'll draw examples from there too.