For those who haven’t yet tried it out, Advent of Code is a fantastic developer role playing game (DRPG) that is taking the community by storm. Set in a fantasy world of elves, AoC can be played online by thousands of people.

As a DRPG, you can play as one of a variety of character classes. Here’s a quick run-down of the unique attributes of each character type, to help you identify your fellow game players.

1. The Warrior. Dedicated to their task, which is simply to faithfully complete every day’s challenge on the day. It may not be pretty, but they make steady progress at their star count.
2. The Thief. Fast and stealthy. You’ll never see their code, but you may see their name in lights. They have finished their day’s work before others have even downloaded the task.
3. The Mage. Occupying a lofty position in the ivory tower, they are advanced practitioners of arcane arts, uttering languages that most mortals have never heard of. Most likely to use: Haskell, APL.
4. The Craftsperson. The opposite attributes to The Thief. They may still be on the third day’s challenges after six months, as they search endlessly for an unrealized Platonic ideal of code beauty. Success takes a distant backseat to aesthetic quality.
5. The Librarian. A rarer breed. Less of an active character, they prefer to catalog and dissect others work, ever on the hunt for a new depth-first algorithm or novel regular expression.
6. The Questioner. They prefer not to write original lines of code, instead carefully constructing search queries to find small pieces of code to assemble into a semi-working whole. Most likely to use: StackOverflow.
7. The Conjurer. A newer class of character, introduced last year and now becoming more popular. Rather than write code, they seem to whisper their desires to an unseen spirit which relays them into semi-finished works. Most likely to use: ChatGPT, Bard.

Let me know if you observe another character class in the wild!

I love the Old Testament book of Ecclesiastes for its meditations on our purpose on this earth. In sharp contrast to a world today, where many claim simple answers to life’s most profound questions, the book’s author dwells on his human frailty in a universe of which our existence is a blink of an eye.

Perhaps the most well-known part of Ecclesiastes today is chapter 3, the start of which was immortalized by The Byrds in the hit song Turn! Turn! Turn!

To everything turn, turn, turn
There is a season turn, turn, turn
And a time to every purpose under Heaven.

And so, it’s the end of a season for me, and a time to ‘turn’.

Leading PM and UX for Flutter, Dart, and more recently Go has been the most rewarding role in my professional career so far. And so it’s with very mixed feelings that I’m sharing today the news that I’m leaving Google at the end of the week.

It’s been a wonderful journey. I joined the team in November 2017, when Flutter was still an early-stage alpha with a couple of hundred daily users and Dart was a weakly-typed language that advertised itself as ‘boring’. Even then, the potential of the projects were very apparent to me: it had the classic Google attributes of a humble team with incredible engineering. We decided to accelerate the path to Flutter 1.0 and the rest was history. Flutter is now the most popular multi-platform UI framework, is deeply embedded in big brands and huge Google properties, and over one million apps have been published with it. Dart has transformed itself into a strongly-typed, sound null safe, highly expressive language that is almost unique in offering production-quality support across web, mobile and desktop.

Of course, I can only claim the smallest credit. I’ve merely been a passenger along for the ride. I’ve always felt that the main thing I can offer is to draw the spotlight on the incredible engineering work the team has done. It has seemed outrageous luck on my part that I have been able to represent everyone’s work at events from Flutter Live to Flutter Forward. And not a week goes by without other teams at Google asking how they can replicate the success of Flutter, whether through community engagement, user satisfaction, or openness.

Flutter Forward always felt like it might be a capstone for my involvement in the project. What a way to go out on a high: bringing a world-class product launch to Africa; setting out an incredible roadmap of innovation across web, mobile and desktop; connecting with the incredible Flutterista community and watching their energy and confidence; and shipping early previews of Dart 3! Seeing so many talented people from across the team pull together engineering innovation, marketing and community execution, and stunning demos was a great reminder to me that Flutter and Dart are far bigger than any one individual, myself in particular.

So I’m passing the baton on. After eighteen stable feature releases of Flutter, the product is finally an adult. And I know I leave it in good hands. The Flutter and Dart teams are healthy and well-funded; they have vision and clarity of purpose; and the community that surrounds them is like no other.

To end back at Ecclesiastes, the author claims no ‘solution’ to the human condition other than to marvel at God’s world and his own insignificance in it. But he also emphasizes the value of positivity and of not giving in to fatalism. In this paraphrase of Ecc 5:13–20, the author has some good advice for us all:

“A man hoards far more wealth than is good for him
And then loses it all in a bad business deal.
He arrived naked from the womb of his mother;
He’ll leave in the same condition — with nothing.

Take care of yourself, and make the most of whatever job you have for as long as God gives you life. And that’s about it. Yes, we should make the most of what God gives, both the bounty and the capacity to enjoy it, accepting what’s given and delighting in the work.”

As ever, I’m in debt to the remarkable Flutter and Dart community. Thank you for an incredible ride. I hope to stay connected with many of you, and wish you ongoing delight with what we’ve all built together!

Yours always, Tim

At any point in time, I normally have a variety of small experiments and hobby projects at various stages of development. As a product manager for developer frameworks or languages, it’s important to make time to explore and use your own product. While it’s dangerous to over-index on your own experiences, it’s also tough to truly empathize with your users if you haven’t walked a fair amount in their shoes.

For several years, I’ve been having fun with one side-project in particular, which combined my experience working on Windows and related technologies at Microsoft with my current focus on Dart and Flutter. The purpose of this project is to make it easy to do Windows programming with Dart, by exposing C-based Windows APIs to Dart.

I last wrote about this project a couple of years ago, when it was still at a fairly immature status, and then last year I gave a talk at Flutter Vikings about it. But it’s finally reached a point where the project has grown out of hobby project status, so it’s a good time to rebrand and reintroduce it.

A suite of Windows packages

Today I’m therefore delighted to introduce Dart | Windows, a suite of packages that provide projections for each of the various programming models available to Windows developers: Win32, COM and the modern Windows Runtime (also known as WinRT).

The base win32 package provides a low-level, API-compatible mapping of the core Win32 APIs. With this package, you can write Dart code that calls APIs ranging from simple MessageBox calls to networking, disk management, cryptography and window management. This package also includes many COM interfaces covering things like audio, sensors, spell checkers and WMI.

It’s not likely that the average Flutter developer will need to use this package directly; instead, they’ll typically use a higher-level package that provides a more idiomatic interface to this low-level functionality, and perhaps also includes implementations for other platforms. Indeed, there are tens of packages that are already written that use win32, thanks to kind volunteers who have invested in the Dart package ecosystem, including file pickers, biometric storage, console output, and share tools. The Dart | Windows suite also includes a number of such packages, including win32_gamepad and win32_registry.

Windows Runtime support

One contributor in particular has gone further and become a deep collaborator in this project over the last year or so. Halil Durmus has been quietly laboring away to improve my own haphazard efforts. As an actual professional developer, he has kindly invested a huge amount of time to fix bugs and improve readability in my own code. I’ve learned a great deal from him.

But beyond that, he’s extended my work on automatically generating support for COM APIs to build the next layer up: Windows Runtime support. WinRT was introduced in Windows 8 as a new API model for Windows development, and extends COM with many modern capabilities including generics, events, properties and asynchronous programming. With the Windows Runtime API, Windows finally gets a programming model that is accessible to a wide variety of languages.

The breadth of Halil’s work is extraordinary: he’s created layers of abstraction that convert WinRT primitives like IMap and HSTRING to Dart equivalents; he’s built well-tested generators that take Windows metadata and create Dart wrappers; and he’s written documentation that makes it all clear. At this point, the bulk of the credit belongs to him, not me.

The first version of this WinRT work is now available, and with it, you’ll find that you can write Windows code that looks like it was designed with Dart in mind. Here’s a simple example that retrieves geolocation from Windows:

import 'package:windows_devices/windows_devices.dart';

void main() async {
  await Geolocator.requestAccessAsync();

  final locator = Geolocator()..allowFallbackToConsentlessPositions();
  final location = await locator.getGeopositionAsync();
  if (location?.coordinate case final coordinate?) {
    final position = coordinate.point?.position;
    if (position case BasicGeoposition(:final latitude, :final longitude)) {
      print('Current location: ($latitude, $longitude)');
    } else {
      print('Current location: N/A');
    }
    print('Location accuracy: ±${coordinate.accuracy} meters');
    print('Current heading: ${coordinate.heading ?? 'N/A'}');
  } else {
    print('No location received.');
  }
} 

Using Dart 3 pattern matching, this code gets coordinate information and destructures it into latitude and longitude measurements. While there are a few more nulls than you might expect if this were powered by Dart code all the way down, it doesn’t take a Windows expert to write code like this (yay!).

Over time, I expect that the original win32 package will take a backseat to this more friendly approach to Windows development. I’m so excited by the work Halil has done, because I think this opens the door for many more packages to support Windows, and for a world where serious Windows apps can be built with Flutter without requiring any C++ knowledge.

Getting started with Dart | Windows

A blog isn’t a good medium for evergreen learning materials, so instead interested readers should consult the Dart | Windows website or visit the GitHub organization where we’re collating various packages and information.

We’d love to have more folk join us on the journey: particularly those with existing Windows experience. You can contribute examples or tests; update existing packages at pub.dev to support Windows; convert packages with C++ plugin implementations to native Dart replacements; or provide feedback on gaps that need filling. Come have fun with Dart | Windows!

We’re delighted to be back for this year’s Google I/O, streaming live around the world from near our headquarters in Mountain View, California!

Just over three months ago, we introduced a bold new roadmap for Flutter and Dart at Flutter Forward in Nairobi, Kenya. At I/O, we’re sharing our progress against that vision with updates across the four themes that we shared: breakthrough graphics experiences, seamless integration with web and platforms, support for new and emerging architectures, and a focus on developer experience.

As you probably know, Flutter is a UI toolkit that enables app developers to build for mobile, web, desktop, and embedded devices from a single codebase. Flutter enables you to build beautiful apps, giving you complete control over every pixel on the screen. It’s fast, taking advantage of your device’s capabilities with support for hardware-accelerated graphics and natively-compiled machine code. It’s productive, with technologies like stateful hot reload that allow you to immediately see code changes in your app. Its portability enables you to deploy to a wide variety of platforms with the same source code and without surprises. And it’s fully open source, with no cost to license it or need to pay for tools to develop for it.

Ongoing Flutter momentum

Use of Flutter continues to grow both at Google and across the broader industry. Here at Google, teams have deployed Flutter apps across mobile, web and desktop platforms, with examples including:

• Android’s new Nearby Share app for Windows, built with Flutter, which allows wireless sharing of photos and documents between Windows and Android devices.
• The new Play Console app, currently in open beta, which lets developers view app statistics and reply to reviews.
• The Google Cloud mobile app, which lets you monitor your services with a new Flutter-powered experience.
• Google Classroom practice sets, a new web-based tool for creating and distributing interactive assignments that deliver real-time feedback and help to students.

On the subject of Classroom, we announced at Flutter Forward that the team was building a new version of the mobile app using Flutter. The new version is starting to roll out on iOS now, with new features in an updated version of the Android app coming soon. This version of Classroom uses the latest Flutter technologies, including our new Impeller graphics rendering engine, which enables fast, jank-free UI.

Rewriting Classroom in Flutter has even improved performance. The new version of the app has faster cold startup time than the old version, as this side-by-side video demonstrates:

We are continuing to invest in packages to connect your Flutter app with the rest of the Google developer ecosystem. This includes major updates to our Google Ads support for native ads; new Windows and better web support for Firebase; and new experimental support for deeper Android interoperability.

With Flutter support on six platforms (Android, iOS, web, Windows, macOS, and Linux), over one million published apps now use Flutter. They come from all over the world: from SNCF Connect, the train travel app for the French railway; to Apple App of the Day winner SO VEGAN; from Rive’s blazing-fast desktop apps for creating animated graphics to the relationship-empowering Agapé mobile and tablet app; from the beautiful, newly-redesigned Global Citizen app to the new Ubuntu Linux installer. We’re so glad to see proof of Flutter’s value!

Breakthrough graphics performance with Impeller

We aspire for Flutter to offer developers and designers immense power for delivering amazing graphical experiences. Over the last few years, we’ve been rebuilding our graphics rendering architecture for speed and power. We call this new engine Impeller.

“We aspire for Flutter to offer developers and designers immense power for delivering amazing graphical experiences.”

Since we introduced Impeller on iOS, we’ve expanded testing and our work with early adopters to validate production quality and further tune performance. With today’s Flutter 3.10 release, we’re delighted to announce that Impeller is now turned on by default for iOS, giving apps a big performance boost simply by migrating to the latest version of Flutter.

With Impeller now enabled for production iOS use, we turn our attention to adding preview support for Android. Just as Impeller on iOS uses the underlying Metal APIs, Android’s implementation of Impeller builds on Vulkan, which provides low-level APIs for speedy rendering on the underlying graphics hardware. While the vast majority of modern Android devices support Vulkan, we will support a backward-compatible mode for older devices. We’ll be sharing an early preview of Impeller for Android, along with more details about the technical underpinnings of Impeller, in an upcoming blog post.

Seamless integration with the web

As we described at Flutter Forward, we have a different goal than most existing web frameworks. The implementation of Flutter we’re building for the web is explicitly not designed to be a general purpose web framework. There are plenty of existing web frameworks, like Angular and React, that fill that space very well. Instead, Flutter is the first framework designed architecturally around new and emerging web technologies like CanvasKit and WebAssembly, which particularly suit complex app experiences.

“Flutter is the first framework designed architecturally around new and emerging web technologies like CanvasKit and WebAssembly.”

Since our early releases of Flutter’s web support, we’ve been working hard to improve performance, accessibility and interoperability.

A major contributor to perceived performance is load time, the interval between a page being requested and becoming interactive. In this release, we’ve taken a leap forward, thanks to reductions in the size of CanvasKit on all browsers, and additional optimizations for Chromium-based browsers. In Flutter 3.10, CanvasKit shrank to 1.5MB (from 2.7MB in our previous version). Icon fonts have also been trimmed of unused glyphs, resulting in a 100× reduction in size in most cases. Thanks to these optimizations, we reduced the load time for our default counter app by 42% using a simulated cable connection.

As previewed at Flutter Forward, we now support embedding Flutter content in an existing HTML web page, rather than Flutter occupying the entire page or needing to use inline frames. With Flutter 3.10, we introduced element embedding, which allows you to integrate Flutter content just like any other CSS element on the page — for instance, applying complex CSS transitions and transformations. To get started, try one of these samples that use JavaScript or wrap Flutter in an Angular component.

Continuing our focus on breakthrough graphics performance, Flutter 3.10 also gains support for fragment shaders on the web. Custom shaders can be used to provide rich graphical effects beyond those that the Flutter SDK provides. A shader is a program authored in a small, Dart-like language, known as GLSL, and executed on the user’s GPU. If you want to learn more, check out our documentation on shaders, as well as our new codelab.

Early to new architectures with WebAssembly

WebAssembly (often abbreviated to Wasm) has been growing in maturity as a platform-neutral binary instruction format for modern browsers. On the web, Flutter has been using Wasm to distribute the CanvasKit runtime, while the Dart framework and application code has historically been compiled to JavaScript. We’ve been interested in targeting Wasm, instead of JavaScript, for a while. Until recently, however, Wasm lacked native support for garbage-collected languages like Dart.

Over the past year we’ve therefore collaborated with several teams across the WebAssembly ecosystem to introduce garbage collection to the standard. This has been achieved via a new extension called WasmGC, which now has near-stable implementations in Chromium-based and Firefox browsers.

WebAssembly excites us with its potential to bring the performance of native code to the web. Dart’s JavaScript compiler, used across millions of lines of code at Google, already generates fast, well-tuned JavaScript. However, switching to Wasm will give us the efficiency of native code with the portability of JavaScript, which will further improve our performance on the web. In some early benchmarks, we’ve seen a boost of 3× for execution speeds, which translates into yet richer web-based experiences. And Wasm couples this with easier integration with code written in other languages like Kotlin and C++.

“WebAssembly excites us with its potential to bring the performance of native code to the web.”

As we wait for browser support to become more pervasive, we have introduced preview support for compiling Flutter apps to WebAssembly in pre-release channels. We’d love you to try it for your own apps and give us early feedback. To learn more, check out flutter.dev/wasm.

Continued focus on developer experience

While we hope to delight many with the breakthrough graphics performance and richer web support listed earlier, we also introduce many improvements to developer velocity and productivity in this release. And our detailed technical blog captures hundreds of improvements to Flutter itself, which will be of great interest to existing Flutter developers.

But perhaps the most significant improvement in this release to the core developer experience is the release of Dart 3, which is included in Flutter 3.10.

Dart 3 completes a long journey to bring sound null safety to the Dart ecosystem. Writing null-safe code protects against a whole class of programming bugs that come from uninitialized values being used without checks. While we’ve supported null safe code since Dart 2.0, we’ve now turned off the legacy “unsafe” mode. As an ecosystem, we’ve been preparing for this for some time, and with 99% of the top 1,000 packages supporting null safety, we believe now is the right time to make the transition.

“Dart 3 completes a long journey to bring sound null safety to the Dart ecosystem.”

Dart 3 introduces many other new features, including records, patterns, and class modifiers, which will improve the readability and fluidity of Dart code. Head to the main Dart 3 blog for more information and examples. Flutter itself is already taking advantage of these new Dart 3 features, so you’ll see improvements to our own codebase as these roll in. And we think you’ll enjoy using them in your own code.

SLSA and software supply chain security

In the modern age, protecting against threats to critical software infrastructure is unfortunately a necessity. So in addition to the headline features listed earlier, our engineering team has made a priority this year of investing in security. This investment spans security testing, automation, and supply chain security.

“Our team has prioritized investments in security”

By undertaking the following work, we aim to give businesses further confidence in adopting Flutter:

• The Open Source Security Foundation Best Practices Program serves as a useful benchmark for helping projects adhere to best practices for security and vulnerability management. We are delighted to announce that we have completed 100% of the passing requirements for this program passing level. We continue to advance towards demonstrating adherence to silver and gold criteria.
• Flutter has also enabled OpenSSF Scorecards and Dependabot on all Flutter critical repositories. OpenSSF Scorecards is a static analysis tool that checks how well your repository adheres to best practices, and creates issues when those practices aren’t being met. Dependabot monitors vulnerabilities in project dependencies and creates pull requests to update them as necessary. Using these tools, the Flutter team has identified and resolved over 300 vulnerabilities across our sites and codelabs.
• The Flutter and Dart SDKs, along with the release workflows for these SDKs, have recently reached the SLSA L1 level. The SLSA (Supply-chain Levels for Software Artifacts) framework helps open source projects maintain strong supply chain security. Reaching SLSA L1 is a great step towards protecting the tools Flutter developers use daily.
• Lastly, we made many security improvements to our infrastructure. This includes migrating to more secure build and test environments while limiting access to these environments. In addition, we have improved our logging and auditing capabilities for Flutter framework and engine artifacts, providing exceptional protection of our artifacts. These improvements provide the Flutter team far greater insight into how the artifacts we generated are handled during the build process.

An open-source project, a work of thousands

There are thousands of other changes in this release that we hope will delight existing Flutter developers. But it’s worth noting how many of those contributions come from developers outside Google. They include new features; documentation improvements; packages that extend Flutter to horizons we never could have anticipated; and reproducible issue reports and feature requests that give us fresh perspectives on how we can improve.

Flutter is not a Google project, it’s an all of us project. We’re so grateful for the diversity and enthusiasm of the community that makes Flutter the product it is. It’s a joy to join you on this mission; the future for Flutter is brighter than ever!

Racing Forward at I/O 2023 with Flutter and Dart was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

I was late to product management as a career. For most of my formative years at Microsoft, I worked in developer relations roles: working with early adopters, crafting messaging and demos for events, writing content for a broad developer audience, and helping teams understand their customers.

These skills and experiences are tremendously useful for any product manager, but they’re not sufficient. Product managers are fundamentally balancers: making endless prioritization decisions about strategy and direction across various dimensions (business or customer? now or later? growth or revenue? incremental or revolutionary? build or buy? open or closed? double down or cut bait?).

Product managers often are the DRI for strategy, but almost never have direct ownership of the resources necessary to deliver that strategy. So being successful as a product manager means having a lot of “soft power” — being respected for their track record, rather than because of their position in the management chain.

Recently I’ve been chatting with a colleague I respect greatly who has made a similar career transition, and they asked me to identify some characteristics that are critical to success in the PM role. This is a revised version of my response.

Good product managers are curious.

Read widely from outside your direct sphere. Catalog elegant solutions and experiences. Commission new sources of data. Identify your own prior biases and look for evidence that surprises you. Talk to people who challenge you, rather than those who agree with you. Assume things you “know” are actually hypotheses to be tested.

Good product managers are data miners.

Devour external sources of information: from your own product research and user studies; from non-users; from competitors; from broad community forums. Build a bookmark list of data sources and insights.

Good product managers are skeptical.

As a corollary to the last point, don’t trust everything you read. Look for evidence of selection bias. Be careful about listening to those who will be disrupted if you’re successful (the horse-and-cart consortium wouldn’t have given Henry Ford good feedback on the Model T). And beware of summaries that pre-digest results but miss all the texture of the feedback.

An anecdote: every quarter, we do a survey of nearly 10,000 developers for one of the products I work on. The longitudinal insights and quantitative data are always valuable. But we also invite respondents to give us verbatim feedback. And there’s often huge treasure buried in such individual insights. So I try and make time to read as many of those individual insights as possible (both good and bad), in order to ground myself in the actual voices of our customer. And we share those nuggets broadly around the team, with a chat room robot called “From {Product} Users” which posts new random insights every day.

Good product managers are hands-on.

Know your product well, rather than relying on others’ knowledge. If you work on a developer product and you haven’t ever built something with it, you should rectify that. Don’t be embarrassed that there are others who know more than you, but equally don’t be complacent about filling your knowledge gaps.

Good product managers are opinionated.

Have an opinion and be able to back it up. (And if you are curious but skeptical, data-oriented, and hands-on, the chances are your opinion will be a good default much of the time.)

Another anecdote: One of my team is fond of the saying, “have strong opinions, but hold them loosely”. There’s goodness here: even a bad decision may be better than no decision, since it generates data you can use to quickly pivot — so long as you are open to that new data.

But there’s also a trap in the first clause of the sentence. It’s valuable to be able to bring a well-articulated perspective to others’ problems, sure. But to do so at the appropriate time without drowning out others or being a jerk — that’s the real skill. So perhaps it’s better to say, “have strong opinions that are lightly given and loosely held.”

Good product managers are communicators.

Few product managers write enough for an external audience. Don’t be shy to ask your team dumb questions that aren’t documented, because that will almost always reveal user journey gaps. Write public documentation in favor of private customer emails.

Miguel de Icaza on Twitter: "When I ask myself "what would have the most impact today?" I sit down and write documentation. / Twitter"

When I ask myself "what would have the most impact today?" I sit down and write documentation.

Good product managers are future-looking.

Be bold and exploratory. Investigate questions that you’ve been told are off the table. Try to look further ahead and broader afield than your engineering counterparts. They might well be focused on shipping the next release; but your focus is the release after that. Don’t solve today’s problems; identify tomorrow’s problems instead.

Good product managers are innovative.

Don’t just look at what others are doing and focus on matching them feature-for-feature. You can never lead a race by looking over your shoulder. Breakthroughs come from challenging the orthodoxy. Be humble, for sure, but have just enough arrogance to be able to believe in yourself that you can find a better path than anyone before you has found.

Good product managers are positive.

You will find plenty of detractors. Plenty of problems to solve. Plenty of reasons why failure is possible, even likely. But positivity is a highly attractive trait. If you exude it, you will always be surrounded with talented, positive people, because talented, positive people want to find others like them.

In closing, a book I recommend without reservation to tech product managers of all levels is Inspired: How to Create Tech Products Customers Love. Don’t put it on a bookshelf, though, nor try to read it cover to cover. Instead leave it on your desk and just turn to a random page once in a while. It’s full of vignettes and useful tools for product managers. If I’m feeling blocked on something, I’ll often skim through it and be reminded of or inspired by an approach.

Hope this is useful!

As an open source project, we believe that we serve our customers best when we are transparent about our roadmap.

For developers who adopt a technology like Flutter, it’s not enough for a product to merely offer a useful set of features. A dependency on Flutter is also a long-term commitment to maintain a skillset and codebase. For that reason, it’s important that we articulate a vision and direction that is compelling and realistic. We hope that sharing more about why we (Google) invest in Flutter will give you greater trust in our future and direction, and allow you to plan with better clarity as to how your investments might connect or supplement ours.

We’re therefore sharing our 2023 strategy document today, where we express our statement of purpose and guiding principles, and describe the major investments that we plan to undertake through the remainder of this year. By necessity, there are some minor redactions (such as commercially-sensitive data or references to unannounced products), and like all plans, we don’t expect this to survive first contact with reality. This strategy document should be read alongside the engineering roadmap on our wiki, which adds further specifics around features that we’re working on.

In closing, an important note on the use of the word ‘we’ in the above sentences, which might be read as “those who Google pay to work on Flutter”. We hope that the Flutter contributors remain far more numerous than just those who are employed by Google, but we don’t claim to speak for the incentives that others have or the work that they might independently undertake. We’re unendingly grateful for this collaboration.

Flutter in 2023: strategy and roadmap was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

Today we’re excited to share our vision for Flutter at Flutter Forward, our developer event streaming live from Nairobi, Kenya, as developers from around the world gather in-person and online to learn about future directions for Flutter.

Flutter is a UI toolkit that enables app developers to build for mobile, web, and desktop from a single codebase. Flutter enables you to build beautiful apps, giving you complete control over every pixel on the screen. It’s fast, taking advantage of your phone or computer’s hardware with support for hardware-accelerated graphics and natively-compiled machine code. It’s productive, with technologies like stateful hot reload that allow you to immediately see code changes in your app. Its portability enables you to deploy to a wide variety of platforms with the same source code and without surprises. And it’s fully open source, with no cost to license it or need to pay for tools to develop for it.

Flutter has proven popular, with over 700,000 published apps to date: from small startups with big ideas to enterprises with critical needs. At Google, too, we’re finding Flutter a valuable tool, enabling teams like Google Classroom to deliver high-quality solutions to mobile and web users; we’re also adding support for it in our other developer tools including Google Ads, Google Maps, Google Pay, and of course Firebase.

“With Flutter, we reduced the code size by 66% for the same functionality… this means less bugs for each platform and less tech debt in the future.” (Kenechi Ufondu, Software Engineer, Google Classroom)

The first release of Flutter provided a UI toolkit for building mobile apps on Android and iOS, but with Flutter 3, we expanded production support to include Windows, macOS, Linux, and the web, while also enabling embedded platforms to use Flutter. Building on that, this week we shipped our latest stable release, Flutter 3.7, which adds a broad set of new features including a new rendering engine on iOS, enhanced support for Material 3 and iOS-style widgets, revamped support for internationalization, background processing improvements, and updates to developer tooling.

But at this event, we’re looking forward, offering a preview of the next wave of investments we’re making in Flutter: breakthrough graphics performance, seamless integration for web and mobile, early support for new and emerging architectures, and a continued focus on developer experience. We’re showcasing work that will gradually be delivered over the coming months, and we hope that this leaves you excited about our vision for Flutter as a powerful toolkit for any developer who wants to build high-quality, beautiful user experiences that can go anywhere pixels are painted.

A disclaimer: the features we’re previewing here are still under development and may change significantly over the coming months. Showing them at this early stage is designed to give early adopters a chance to contribute.

Breakthrough graphics performance

Historically, cross-platform frameworks have required compromise on visuals, due to the challenges of creating an abstraction layer. Flutter has taken a different approach than most, with its own rendering layer that offers hardware-accelerated graphics and a consistent visual appearance on every device. Moving forward, we will invest in breakthrough graphics performance that extends Flutter’s existing strength in this area.

At Flutter Forward, we’re showing more progress on Impeller, Flutter’s next generation rendering engine. Impeller is optimized for Flutter, giving us even more flexibility and control over the graphics pipeline, and opening new opportunities for us. Impeller provides more predictable performance, using precompiled shaders that alleviate dropped frames at runtime caused by shader compilation. It takes advantage of primitives in Metal and Vulkan, the modern low-level APIs in iOS and Android. And it makes effective use of concurrency, distributing single-frame workloads across threads.

In addition to offering a silky-smooth UI, Impeller can drastically improve performance in certain scenarios. One demo (shown below) demonstrates a best-case example of this. On the left is a kaleidoscope app using SVG clipping, built using the current default renderer. Scrolling down the page, performance drops with rendering taking longer than the per-frame budget, leading to a frame rate of 7–10 fps. The right side shows the same app running under Impeller, rendering at a glitch-free 60 fps.

One advantage of building from the ground up is that the architecture can support brand new use cases. Newly introduced support for custom shaders is already leading to some amazing new demos that show seamless integration with the Flutter widget hierarchy. Our work here isn’t limited to mobile devices, though: we now have early support for custom shaders on the web too, with the same code now powering hardware-accelerated experiences across iOS, Android, and the browser.

And now we’re starting early work on supporting 3D with Flutter. During the keynote, we showed that you can import models created with Blender, and even use hot reload to iterate with Blender in real-time and see the results in a running app. It’s early days, but we’re excited about the initial performance we’re getting, along with the potential of integrating 3D into other Flutter experiences.

Adding 3D and custom shaders raises the bar for graphics performance in a portable UI toolkit to a new level. We’re very excited to see what you do with these new features as they become available.

Seamless integration for web and mobile

While you can write an app entirely using Flutter and Dart, almost any non-trivial project needs to connect with other code. On the web, Flutter may be used as an embedded component within a larger app; on mobile, apps may need to call system APIs or other code written in another language. Our second major theme of investment is therefore seamless integration for web and mobile.

On the web, we’re previewing a new feature that we’re calling element embedding, which allows Flutter content to be added to any standard web <div>. When embedded in this way, Flutter just becomes a web component, integrating cleanly with the web DOM and even enabling the use of CSS selectors and transformations to style the parent Flutter object.

We’re also making some big changes to the js package, to enable seamless interoperability between JavaScript and Dart code. With js, you can annotate any function in your Dart code with a @JSExport attribute, and then call it from your JavaScript code.

Combining these two new features opens up some exciting new scenarios for using Flutter on the web. In a proof-of-concept demo that we showed at Flutter Forward, you can see a simple Flutter app embedded in a HTML-based webpage. Using CSS, we apply an animated rotation effect; even while rotating, the Flutter content remains interactive. The demo also shows that you can use an HTML button and JavaScript event handler to make changes to the Flutter state, and vice versa. When this work is complete, we think this will open up many new opportunities to use Flutter to add interactivity to an existing web app.

Turning to Android and iOS, Flutter has long supported integration with system APIs using platform channels, which offer a message-based approach for communicating with code written in a language like Kotlin or Swift. While this unlocks access to those libraries, it requires an app author to be conversant with multiple languages and requires a fair amount of boilerplate code.

We’re now starting work on a new approach for system interoperability that allows libraries to be called directly. On iOS, we’re building on our work on FFI for C interoperability, adding support for Swift and Objective-C libraries. On Android, we’re using JNI to bridge to Jetpack libraries written in Kotlin. With a new command, Dart automatically creates bindings for cross-language interoperation and converting data classes appropriately. When complete, we aspire that this work will enable a Flutter developer to call a new Jetpack or iOS library without needing to use a plugin or learn a different API syntax, as well as greatly easing the work for a plugin author. Check out our sample to learn more!

Early to new and emerging architectures

Thanks to Dart’s broad support for a wide range of processor architectures, as well as its highly-optimized JavaScript compiler, Flutter can already run on a broad variety of devices and form factors. But with some exciting new options on the horizon, our third theme is bringing early support to new and emerging architectures.

WebAssembly has been growing in maturity as a platform-neutral binary instruction format, with growing support on modern browsers. Excitingly, WebAssembly opens the web platform to other languages beyond JavaScript. Over recent months, we’ve been collaborating with the Chrome team and other WebAssembly partners to add early support for garbage-collected languages like Dart. This new extension to WebAssembly is now supported with a flag in the latest development builds of Chrome. At Flutter Forward, we’re unveiling early support for Flutter compilation to WebAssembly, which will enable further speed and size optimizations for our web support.

Another platform architecture that is generating growing interest is RISC-V, an open standard instruction set architecture (ISA) designed for broad usage. The Android team recently gave a talk on their work to support RISC-V, and we’re happy to also announce that Dart now supports RISC-V, as part of our own journey to enable Flutter to run on RISC-V devices as they become available. Production RISC-V hardware is still in its infancy, but at Flutter Forward we demonstrated our progress to date on the ClockworkPi DevTerm Kit R-01, a self-assembly portable terminal running Linux. We believe RISC-V support will be of particular interest for embedded scenarios, where Flutter can provide a powerful UI toolkit for a diverse set of needs.

Continued focus on developer experience

Foundational to everything we’ve described above is developer productivity, which has been a hallmark of Flutter since its inception, with features like stateful hot reload. Our fourth and final area of investment for the future is a continued focus on developer experience, across both Flutter and Dart.

At Flutter Forward, we’re previewing some of our early work on some major new Dart language features that we hope demonstrate our commitment to tasteful evolution of the language. In our development channel, we now have early support for records and patterns, two new enhancements that work particularly well together.

We’re also formally announcing Dart 3, which is the culmination of our work to introduce sound null safety to the language. Dart 3 also removes other long-deprecated features to further modernize the language. We have started publishing alpha-quality builds of Dart 3, along with matching Flutter builds, enabling developers to test packages and apps. For more information on Dart 3, check out the separate blog post on the Dart channel.

We’re investing in the developer experience for Flutter as well, of course. Following on from the success of the casual game toolkit we announced at I/O last year, we’re sharing the first version of our news toolkit, which accelerates mobile development for news publishers and other content providers who want to reach mobile users without having to design an app from scratch. It includes everything you need to build an article-centric app, with navigation and search, authentication, ad integrations, notifications, profiles and subscriptions, while incorporating best practices from Google News Initiative’s research. We’re today featuring three early adopters here in Africa who are building apps based on this toolkit, including Hespress, one of the largest news sites in Morocco, Bold Sports, a popular the Nigerian sports site; and The Standard, the oldest newspaper in Kenya.

Moving forward together

We hope you share our excitement about where we’re taking Flutter moving forward. We’re continuing to invest heavily in the core developer experience, while making some foundational improvements that pave the way for ourselves and others to build even more powerful experiences with Flutter.

This image summarizes our direction:

Beyond our own development themes, it’s gratifying to see how the Flutter ecosystem continues to expand, like FlutterFlow is a low-code builder for developing native mobile applications, and Widgetbook, which provides flexible tooling for designers and developers to collaborate on user interface development.

In closing, it has been wonderful to come to Kenya and see the entrepreneurship and talent of local developers. The vibrancy of the Flutter community here in Africa is special; the Flutter Kenya user group alone has over 1,000 developers. And we’re thrilled that Flutter can provide new opportunities for developers across Africa to participate in the fast-growing app economy. Klasha is a great example of this promise, using Flutter to quickly get to market and solve local problems. Here’s a video of their experience with Flutter:

What’s next for Flutter was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

Happy Christmas! This year’s Advent of Code is over, and it was tremendous fun as always. I’ve enjoyed doing the (easier) challenges over the years, but this year we thought it would be fun to have a private leaderboard for Dart entries.

This was a spur of the moment thing on our part, and we launched it just with a tweet:

Tim Sneath on Twitter: "Let's do this! If you want to participate in Advent of Code 2022 with Dart, join our private leaderboard: https://t.co/EsxBFTj5rLUse code 1671198-6c003f39. Who knows, we might even find some swag for the most committed! #AdventOfCode2022 @dart_lang #Flutter / Twitter"

Let's do this! If you want to participate in Advent of Code 2022 with Dart, join our private leaderboard: https://t.co/EsxBFTj5rLUse code 1671198-6c003f39. Who knows, we might even find some swag for the most committed! #AdventOfCode2022 @dart_lang #Flutter

We had some great participation from all over the world, with nearly 150 people signing up to join us.

The team at Invertase got in on the fun, and kindly offered to send some swag to the top five entrants. Lots of folk had fun:

Peter Aleksander Bizjak on Twitter: "My #AdventOfCode solutions are looking like I'm transforming Dart into Haskell. It's awesome using the language for something else than just Flutter. Nothing wrong with Flutter, but I feel like Dart was made for challenges like that. Having so much fun! / Twitter"

My #AdventOfCode solutions are looking like I'm transforming Dart into Haskell. It's awesome using the language for something else than just Flutter. Nothing wrong with Flutter, but I feel like Dart was made for challenges like that. Having so much fun!

Jeevan Joshi on Twitter: "#AdventOfCode is getting interesting, This year I am competing on the #Dart side.Glad to be on the top leaderboard, and I hope I'll maintain the momentum. https://t.co/NFa8oDZZQE / Twitter"

AdventOfCode is getting interesting, This year I am competing on the #Dart side.Glad to be on the top leaderboard, and I hope I'll maintain the momentum. https://t.co/NFa8oDZZQE

The winner was Meï (@meixdev), who just pipped second-place Darren Austin from our own Flutter team at the finishing line. Meï is in France, so had to get up at 6am each morning to start the challenge as each day was released.

Meï on Twitter: "It's a 1-point lead! I can't claim all the fame as it wouldn't have happened without the fast skills of tons of others.It was so much fun ! Hope we will meet again for next year's AoC ! 💪 / Twitter"

It's a 1-point lead! I can't claim all the fame as it wouldn't have happened without the fast skills of tons of others.It was so much fun ! Hope we will meet again for next year's AoC ! 💪

Some people tried using ChatGPT to build their Dart solutions, which was an interesting approach, but ultimately unsuccessful.

Particularly fun is that many folk published their solutions to GitHub, making it easy to compare different approaches. Here are some of the winning Dart repos:

• GitHub - MeixDev/Advent-of-Code2022: AoC2022
• GitHub - darrenaustin/advent-of-code-dart: Darren's solutions to the Advent of Code puzzles in Dart.
• GitHub - imaNNeoFighT/adventofcod_2022
• GitHub - ndelanou/advent_of_code: https://adventofcode.com/2022
• GitHub - Mosc/advent-of-code-2022

It’s not too late to do the challenges, by the way. I’m planning to continue working away at my own solutions in spare time over the coming weeks, without the pressure of competition or it taking time away from my other programming hobby projects.

To close, I want to give a giant shout out and thank you to Eric Wastl, who is the creator of each year’s Advent of Code challenge. This is a tremendous amount of work each year: creating interesting challenges, building and maintaining site infrastructure, dealing with technical support questions and fending off malicious actors. He has given a lot of us a great deal of pleasure. If you’ve had some fun from Advent of Code this year, do send him a token of your appreciation, which will I’m sure be an encouragement for future years.

Greetings from the beautiful Norwegian capital of Oslo, where members of the Flutter community are gathering for the Flutter Vikings conference. Flutter Vikings is a two day community-driven developer event with three tracks of content from experts who have traveled from across the world. Over five thousand developers have registered so far, and while the in-person event is sold out, you can watch all the sessions online for free.

Flutter continues to grow, both in usage and in the size of the ecosystem. Every day, more than 1,000 new mobile apps using Flutter are published to the Apple and Google Play stores, along with more usage on web and desktop. And the Flutter package ecosystem now comprises over 25,000 packages, providing further evidence of maturity and breadth.

Today we’re announcing Flutter 3.3. This release is focused on refinements and performance improvements that reinforce the features shipped in Flutter 3. It expands support for the evolving Material 3 specification with several new components and a number of bug fixes, and it includes new features aimed at tablet and desktop developers including Scribble handwriting support on iPad, selectable text grouping, and trackpad support. This release also includes Dart 2.18, which introduces FFI support for libraries and code written in Swift or Objective-C. Apps that are built against this release will experience improved performance across desktop, web, and mobile, so we encourage you to run flutter upgrade to get the latest on all your developer workstations!

For more on all the new features and improvements, check out the detailed Flutter 3.3 release notes and the Dart 2.18 announcement blog post.

Wonderous: a new reference app

In partnership with the design team at gskinner, today we’re launching Wonderous, an app built to showcase Flutter’s capacity to deliver high-end, beautiful experiences without caveats. Even as it shows off the power of Flutter, we built Wonderous together to be a beautiful app in its own right. From the stunning Taj Mahal in the Indian city of Agra to the Mayan ruins of Chichén Itzá on the Yucatán peninsula of Mexico, Wonderous brings some of the most remarkable places in the world to your phone, using video and imagery to explore the intersection of art, history, and culture.

Wonderous is an app we hope you’ll share with your family and friends, but is also an open source project that you can explore as a developer. As a real-world app, it provides a comprehensive example of a wide variety of visual techniques and best practices that we think will inspire intermediate to advanced developers. Over the coming weeks, the gskinner.com team will be sharing more detailed technical articles on the making of the app, including its support for accessibility, animation techniques that are generalizable, and tips and tricks for performance.

For more about our motivations for building Wonderous and links to its associated website, the Android and iPhone apps, and the source code, check out the separate article here on the Flutter blog.

Impeller: our new graphics engine

Aside from the improvements in 3.3 itself, the team has been hard at work on Impeller, our next-generation rendering layer.

Impeller is a significant rewrite of a core part of the Flutter engine, replacing the previous Skia code with a custom runtime that takes full advantage of modern hardware-accelerated graphics APIs such as Metal on iOS and Vulkan on Android. It delivers silky-smooth animations, considerably raising the bar for what applications can expect from a multiplatform UI toolkit. The difference is visceral, and apps that use Impeller can expect to be able to push boundaries further than before while staying locked to 60Hz or faster refresh rates. Most notably, Impeller totally eradicates the need for runtime shader compilation, which is a common source of frame rate ‘jank’ for apps today.

While it is not feature complete and we are still optimizing performance, we are now testing it internally on Google-class applications. And if you download Wonderous for iPhone from the Apple App Store, you’ll see Impeller in action on a production-quality app.

We’re thrilled to now make Impeller available as an early adopter preview on iOS. Impeller doesn’t require changes to your code, other than enabling a flag. More information on the architecture of Impeller and how to enable it can be found on our wiki. While it’s under active development, early adopters of Impeller should switch to the master channel of Flutter to ensure you’re working with the latest code.

We look forward to seeing apps and demos that take advantage of the performance and quality improvements in Impeller. We’d also appreciate reproducible issue reports that demonstrate performance or fidelity regressions in current builds.

Goodbye to Eric

We close with an affectionate farewell to Eric Seidel, one of the co-founders of Flutter who is leaving Google this month for new adventures. Eric was the very first person to introduce Flutter to the world, before it had a name or a mascot, at the Dart Developer Summit back in 2015; he has managed the Flutter engineering team for most of its existence, and quite simply, without Eric there would be no Flutter as we know it.

But Eric has an entrepreneur’s heart, and his “superpower” (to use one of his favorite words) is as a creator and initiator. So it didn’t come as a huge surprise when he shared his plan to start something new. And so we send him our encouragement and appreciation as he flies the nest and begins his next adventure.

It’s fitting to close this post with an extract from the Flutter 1.0 launch event, in which Eric shares our vision for Flutter: a long-term bet that we can radically improve the experience of building beautiful user experiences. This remains our vision, and we’re not done. With millions of developers from around the world relying on it, an ecosystem of thousands of contributors to the project, and a team here at Google that is flourishing and growing, we hope you’ll continue to join us on our journey!

Announcing Flutter 3.3 at Flutter Vikings was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

We’re delighted to announce the launch of Flutter 3 as part of the Google I/O keynote. Flutter 3 completes our roadmap from a mobile-centric to a multiplatform framework, with the availability of macOS and Linux desktop app support, along with improvements to Firebase integration, new productivity and performance features, and support for Apple Silicon.

The journey to Flutter 3

We started Flutter as an attempt to revolutionize app development: combining the iterative development model of the web with hardware-accelerated graphics rendering and pixel-level control that were previously the preserve of games. Over the last four years since Flutter 1.0 beta, we’ve gradually built on these foundations, adding new framework capabilities and new widgets, deeper integration with the underlying platforms, a rich library of packages and many performance and tooling improvements.

As the product has matured, more of you have started to build apps with it. Today there are over 500,000 apps built with Flutter. Analytics from research firms like data.ai, along with public testimonials, show Flutter is used by a broad list of customers in many segments: from social apps like WeChat to finance and banking apps like Betterment and Nubank; from commerce apps like SHEIN and trip.com to lifestyle apps like Fastic and Tabcorp; from companion apps like My BMW to public institutions such as the Brazil government.

Today there are over 500,000 apps built with Flutter.

Developers tell us that Flutter helps build beautiful apps more quickly for more platforms. In our most recent user study:

• 91% of developers agreed that Flutter reduced the time it took to build and publish an app.
• 85% of developers agreed that Flutter made their app more beautiful than before.
• 85% agreed that it enabled them to publish their app for more platforms than before.

In a recent blog post by Sonos discussing their revamped setup experience, they emphasized the second of these:

“It is not an exaggeration to say that [Flutter] has unlocked a degree of “premium” unlike anything our team had delivered before. Most important to our designers, the ease with which new UIs can be built means that our team spends less time saying “no” to specs and more time iterating on them. If this sounds worth it, we’d recommend giving Flutter a try — we’re glad we did.”

Introducing Flutter 3

Today, we’re introducing Flutter 3, which is the culmination of our journey to fill out the platforms supported by Flutter. With Flutter 3, you can build beautiful experiences for six platforms from a single codebase, giving developers unparalleled productivity and enabling startups to bring new ideas to the full addressable market from day one.

In previous releases, we supplemented iOS and Android with web and Windows support, and now Flutter 3 adds stable support for macOS and Linux apps. Adding platform support requires more than rendering pixels: it includes new input and interaction models, compilation and build support, accessibility and internationalization, and platform-specific integration. Our goal is to give you the flexibility to take full advantage of the underlying operating system while sharing as much UI and logic as you choose.

On macOS, we’ve invested in supporting both Intel and Apple Silicon, with Universal Binary support that allows apps to package executables that run natively on both architectures. On Linux, Canonical and Google have collaborated to offer a highly-integrated, best-of-breed option for development.

A great example of how Flutter enables beautiful desktop experiences is Superlist, which launches in beta today. Superlist provides supercharged collaboration, through a new app that combines lists, tasks, and freeform content into a fresh take on to-do lists and personal planning. The Superlist team selected Flutter for its ability to deliver a fast, highly-branded desktop experience, and we think their progress to date demonstrates why it has proven to be a great choice.

Flutter 3 also improves on many of the fundamentals, with improved performance, Material You support, and productivity updates.

In addition to the work mentioned above, with this version, Flutter is fully native on Apple silicon for development. While Flutter has been compatible with M1-powered Apple devices since their release, Flutter now takes full advantage of Dart’s support for Apple silicon, enabling much faster compilation on M1-powered devices and support for universal binaries for macOS apps.

Our work for Material Design 3 is largely complete in this release, allowing developers to take advantage of an adaptable, cross-platform design system that offers dynamic color schemes and updated visual components:

Our detailed technical blog post expands on these and the many other new features in Flutter 3.

Flutter is powered by Dart, a high-productivity, portable language for multiplatform development. Our work on Dart in this cycle includes new language features that reduce boilerplate and aid readability, experimental RISC-V support, an upgraded linter, and new documentation. For further details on all the new improvements in Dart 2.17, check out the dedicated blog.

Firebase and Flutter

Of course, there’s more to building an app than a UI framework. App publishers need a comprehensive suite of tools to help you build, release, and operate your apps, including services like authentication, data storage, cloud functions, and device testing. There are a variety of services that support Flutter, including Sentry, AppWrite, and AWS Amplify.

Google’s offering for app services is Firebase, and developer benchmarking studies by SlashData show that 62% of Flutter developers use Firebase in their apps. So over the last few releases, we’ve been working with Firebase to expand and better integrate Flutter as a first-class integration. That has included bringing the Firebase plugins for Flutter to 1.0, adding better documentation and tooling, and new widgets like FlutterFire UI that provide developers with reusable UI for auth and profile screens.

Today we’re announcing the graduation of Flutter/Firebase integration to a fully-supported core part of the Firebase offering. We’re moving the source code and documentation into the main Firebase repo and site, and you can count on us evolving Firebase support for Flutter in lockstep with Android and iOS.

In addition, we’ve made major improvements to support Flutter apps using Crashlytics, Firebase’s popular real-time crash reporting service. With the updates to the Flutter Crashlytics plugin, you can track fatal errors in real time, giving you the same set of features that are available to other iOS and Android developers. This includes important alerting and metrics like “crash-free users” that help you stay on top of your app’s stability. The Crashlytics analysis pipeline has been upgraded to improve clustering of Flutter crashes, making it faster to triage, prioritize, and fix issues. And lastly, we streamlined the plugin setup process so that it only requires a couple of steps to get up and running with Crashlytics, right from your Dart code.

Flutter Casual Games Toolkit

For most developers, Flutter is an app framework. But there’s also a growing community around casual game development, taking advantage of the hardware-accelerated graphics support provided by Flutter along with open source game engines like Flame. We want to make it easier for casual game developers to get started, so at I/O today we’re announcing the Casual Games Toolkit, which provides a starter kit of templates and best practices along with credits for ads and cloud services.

Although Flutter isn’t designed for high-intensity 3D action gaming, even some of those games have turned to Flutter for non-game UI, including popular games like PUBG Mobile that have hundreds of millions of users. And for I/O we thought we’d see how far we could push our technology, so we’ve created a fun pinball game that is powered by Firebase and Flutter’s web support. I/O Pinball provides a custom table designed around four of Google’s favorite mascots: Flutter’s Dash, Firebase’s Sparky, the Android robot, and the Chrome dinosaur, and lets you compete with others for the high score. We think it’s a fun way to showcase Flutter’s versatility.

Sponsored by Google, powered by community

One thing we love about Flutter is that it’s not just a Google product — it’s an “everybody” product. Open source means that we can all participate and have a stake in its success, whether by contributing new code or documentation, creating packages that give the core framework new superpowers, writing books and training courses that teach others, or helping organize events and user groups.

To showcase the community at its best, we recently sponsored a Puzzle Hack challenge in collaboration with DevPost, offering developers the chance to showcase their skills by reimagining the classic sliding puzzle with Flutter. This proved a fantastic demonstration of how web, desktop, and mobile come together: now we can all play the games online or via the stores.

We put together this video to showcase some of our favorite submissions and prize winners; we think you’ll enjoy it:

Thank you for your support of Flutter, and welcome to Flutter 3!

Introducing Flutter 3 was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.