This release continues our focus on improving the core developer experience. The new dot shorthands (.) feature will help you write more readable and less verbose code. We’re also introducing a powerful new analyzer plugin system that allows you to create custom static analysis rules that integrate directly into your IDE. And we’re excited to announce that build hooks are now stable!

This release also brings several improvements to pub.dev and package management. You’ll find new search capabilities in the “Likes” tab in your profile, and package authors can now disable manual publishing for improved security. Finally, we’ve added a suite of new, more specific deprecation annotations to give you finer-grained control over your API’s evolution.

Read on to learn more about these and the other improvements in Dart 3.10.

Language updates

Dot shorthands 🆕

Dart 3.10 introduces dot shorthands (.). This new feature lets you omit redundant class or enum names when the compiler can infer the type from the context.

Let’s look at a common scenario: logging. Before, you might have written:

enum LogLevel { info, warning, error, debug }

void logMessage(String message, {LogLevel level = LogLevel.info}) {
  // ... implementation
}

// Somewhere else in your app
logMessage('Failed to connect to database', level: LogLevel.error);

Since the level parameter already expects a LogLevel, repeating the enum name is unnecessary. With dot shorthands, you can now write:

enum LogLevel { info, warning, error, debug }

void logMessage(String message, {LogLevel level = .info}) {
  // ... implementation
}

// Somewhere else in your app
logMessage('Failed to connect to database', level: .error);

The code now focuses on the value (.error) rather than the type (LogLevel).

Dot shorthands aren’t just for enums. You can also use them with constructors, static methods, and static fields. To learn more, read our Dot shorthands guide.

Tools updates

Analyzer plugins 🆕

Have you ever been reviewing code and thought, “Shouldn’t the analyzer be able to catch that?”. Now it can.

Dart 3.10 introduces a powerful new plugin system for the Dart analyzer. This allows you to write and use your own static analysis rules that integrate directly into IDEs and command-line tools like dart analyze and flutter analyze. You can use analyzer plugins to:

• Enforce project-specific rules, such as bespoke lints and warnings to maintain conventions in your team’s codebase.
• Avoid common pitfalls and best practices specific to your domain.
• Automate code changes by providing quick fixes and assists to help automatically correct issues or migrate to new APIs.

This new system is the result of a significant architectural effort to enable a rich ecosystem of community-driven tools, and we’d like to extend a special thanks to community contributor Felipe Morschel for his valuable fixes and features for the analyzer in general.

To use an analyzer plugin, simply add it to your analysis_options.yaml file:

analyzer:
  plugins:
    - some_plugin
    - another_plugin

To learn more about creating your own custom rules, see the documentation for writing an analyzer plugin.

Build hooks 🚀

Integrating native code (like C++, Rust, or Swift) into a Dart package has often required managing complex, platform-specific build files like CMake or Gradle. With Dart 3.10, this process is now dramatically simpler.

We’re excited to announce that build hooks (formerly known as native assets) are now stable. You can use these hooks to compile native code or download native assets (like dynamic libraries) and bundle them directly with your Dart package. This powerful capability lets you reuse existing native code or libraries from within your package and eliminates the need to write separate build files such as SPM, Gradle, or CMake for different operating systems.

To learn more, see the documentation for writing a build hook, or watch the Flutter Build show episode on build hooks.

Remove Deprecations lint 🆕

When you release a new major version of a package (like 1.0.0 or 0.2.0), it’s a best practice to remove any APIs you previously marked as deprecated. This keeps your package clean and prevents developers from using outdated code. However, it’s easy to forget this step during the release process.

To help, we’ve introduced a new lint: remove_deprecations_in_breaking_versions. This lint detects leftover deprecated elements when a package’s version is updated to a new major breaking version. By flagging these cases, the lint helps ensure that your package’s API remains modern and easy for your users to understand.

@Deprecated annotation ⬆️

The existing @Deprecated annotation is a blunt instrument. It informs developers that an API is no longer recommended, but it doesn’t allow for nuance. For example, how do you signal that a class should no longer be extended, but can still be instantiated?

To give package authors more precise control over their API’s evolution, Dart 3.10 introduces a suite of new, more specific deprecation annotations.

You can now deprecate specific use cases for classes and mixins:

• @Deprecated.extend(): The ability to extend a class is deprecated.
• @Deprecated.implement(): The ability to implement a class or mixin is deprecated.
• @Deprecated.subclass(): The ability to subclass (extend or implement) a class or mixin is deprecated.
• @Deprecated.mixin(): The ability to mix in a class is deprecated.
• @Deprecated.instantiate(): The ability to instantiate a class is deprecated.

Additionally, you can now signal that an optional parameter will become required in a future version using @Deprecated.optional().

Pub updates

Search, sort, and unlike support for your favorite packages 🆕

Managing your favorite packages on pub.dev just got a major upgrade. You can do this through the Search feature or the Likes tab on your profile, where you can now search, sort, and filter your liked packages with the same familiar controls you use for regular searches. This includes sorting by likes, pub points, and popularity. We’ve also improved the UI for unliking packages, making it easier than ever to keep your list of liked packages tidy and up-to-date.

If you choose to search for your liked packages with the Search feature, simply add is:liked-by-me to your query.

Enable or disable manual publishing 🆕

To enhance security and prevent accidental publications, you can now disable manual publishing (pub publish) for your packages. This is ideal for packages that have an automated publishing workflow or are no longer being actively published.

By disabling manual publishing, you prevent package updates using personal credentials, reducing the risk of an unauthorized or accidental release.

You can control this feature in your package’s Admin tab using the “Enable manual publishing” checkbox.

Wrap up

The Dart 3.10 release brings a host of improvements focused on developer productivity, tooling, and the overall health of the package ecosystem. From language features like dot shorthands that make your code more concise, to powerful new tooling capabilities like analyzer plugins and stable build hooks, we hope this release empowers you to build even better apps.

We’re incredibly grateful for the many engineers and teams who contributed to this release, including a special thanks to our community contributors who help make Dart better for everyone.

We’re excited to see what you build with Dart 3.10. To get started, you can get the Dart 3.10 SDK today. For a complete list of all the new and updated features, check out the Dart SDK changelog.

Announcing Dart 3.10 was originally published in Dart on Medium, where people are continuing the conversation by highlighting and responding to this story.

This release is all about making your work easier and your apps more efficient. With key updates to null safety, performance boosts to the Dart CLI, and the exciting addition of the Dart and Flutter MCP Server to empower your AI assistants, there’s a lot to love. Read on to discover everything that’s new in Dart 3.9.

Language updates

Null safety

Dart 3.9 assumes null safety when computing type promotion, reachability, and definite assignment. To take advantage of these improvements, set your package’s SDK constraint lower bound to 3.9 or greater (sdk: ^3.9.0). As a result of this change, more dead_code warnings may be produced.

Soundness updates

We fixed a soundness issue that allowed direct invocation of a value returned from a getter without any runtime checks when the getter’s return type was a generic type argument instantiated as dynamic or Function. This soundness issue arose with the dev-compiler DDC, and no other tools are affected.

Before the fix the following getter could trigger an issue with a direct invocation. For example:

// The following getter used to trigger an issue with a direct 
// invocation

// The getter
class Container<T> {
  T get value => ((int i) => i.isEven) as T;
}

// The direct invocation
Container<dynamic>().value('Invocation with missing runtime checks!');

Tools updates

Dart and Flutter MCP Server

The Dart and Flutter MCP Server acts as a bridge, giving AI coding assistants such as Gemini CLI, Cursor, and GitHub Copilot, access to more of your Dart project’s context. Instead of just suggesting code, your AI assistant can now understand your project deeply and take action on your behalf.

With the Dart and Flutter MCP Server, you can ask an AI assistant to:

• Fix runtime errors (see example).
• Manage dependencies (see example).
• Write and correct code.
• And more.

The Dart and Flutter MCP Server is now available on the stable channel of the Dart SDK.

Faster Dart CLI

Previously, when you ran some Dart CLI commands like dart analyze and dart fix, your computer had to compile the code for the analysis server just before running it. Now, these tools use an Ahead-Of-Time (AOT) compiled snapshot of the analysis server, which means the server has been pre-compiled into fast, native machine code.

Results vary depending on the source code, but we ran some common commands on a sample package and got some interesting results. Some short commands like dart format now complete in a fraction of the time and longer running ones like dart analyze got nearly 50% faster.

pub client updates

Git dependencies can now be version-solved based on git tags.

When you use a tag_pattern in the descriptor and there is a version constraint, all commits matching the pattern are considered during resolution. In the following example, only version 2.0.1 of my_dependency and higher is considered:

dependencies:
  my_dependency:
    git:
      url: https://github.com/example/my_dependency
      tag_pattern: v{{version}}
    version: ^2.0.1

Starting from language version 3.9, the flutter constraint upper bound is now respected in your root package (the dart constraint was already respected). Setting a narrow dart or flutter constraint can be useful to ensure a team of developers all use the same SDK version when jointly developing an app (see issue #95472 for details).

For example, in a root pubspec like this pub get will fail if invoked with a version of the Flutter SDK that is not 3.33.0:

name: my_app
environment:
  sdk: ^3.9.0
  flutter: 3.33.0

Dart native compiler

We added cross-compilation support for target architectures of arm (ARM32) and riscv64 (RV64GC) when the target OS is Linux.

Deprecations & breaking changes

32-bit x86 architecture

Dart has deprecated the 32-bit x86 architecture. For most developers this will have no impact, as it mainly affects older x86-based Android emulators and a small number of physical devices. 32-bit ARM and 64-bit x86_64 emulators and devices are still supported. The full technical breakdown is available in the Dart GitHub deprecation issue.

dart build

dart build is in preview on the beta channel.

dart build -f exe <target> is now dart build cli — target=<target>. See dart build cli — help for more info.

Wrap up

That’s a wrap on Dart 3.9! We hope you’re as excited about these updates as we are. We always appreciate your feedback, so feel free to share your thoughts. Until next time, happy coding!

Announcing Dart 3.9 was originally published in Dart on Medium, where people are continuing the conversation by highlighting and responding to this story.

Upgraded AI-optimized Flutter template

The Flutter template in Firebase Studio received a significant upgrade. With its new AI capabilities, you can optimize your workspace for an AI-first experience. For example, when building the I/O Connect India demo with this new template, Firebase Studio generated a multi-screen, e-commerce app complete with state management, Firebase authentication, products, a cart, and checkout. The AI-optimized template defaults to autonomous Agent mode, allowing Gemini to make changes directly without waiting for approval. We’ve also incorporated rules for Gemini into an (automatically generated) airules.md file to further refine the code Gemini generates, enabling you to add features or generate an entire Flutter app in a more streamlined flow.

Autonomously make changes

Previously, when working on a Flutter project in Firebase Studio, you would manually approve each code change in Agent mode. This workflow has evolved significantly and can make edits autonomously (independently and automatically). With the new Agent (Auto-run) mode, Gemini can now autonomously make changes, generate entire apps, and add features in a streamlined flow. For instance, when developing an app similar to our I/O Connect India demo, you can use Agent (Auto-run) mode to seamlessly integrate Firebase backend services and implement complex navigation patterns in a single interaction. Given Gemini’s robust support for Dart and Flutter, this autonomous mode keeps you in the development flow. And if a change isn’t exactly what you intended, rest assured that Firebase Studio leverages Git, allowing you to quickly revert your changes to a previous commit.

AI rules

With the upgraded Flutter template, we’ve incorporated AI instructions into a new file: airules.md. This file (located at the root of your project), contains explicit rules for Gemini to follow as it generates code, enhancing the quality and relevance of the output. You have the flexibility to either use the default AI rules or customize them to fit your project’s specific needs. While there are numerous rules, here are a few examples:

• Act as a Flutter co-developer
• Writes unit tests
• Proactively look for and fix errors
• Choose which themes, tools, extensions, and startup commands to use
• Add and remove Flutter packages
• Adhere to Flutter and Dart best practices for code quality
• Set up complex navigation

Compatible with Dart MCP Server

Firebase Studio now includes foundational support for the Model Context Protocol (MCP), and we’re excited to share that it works with our Dart MCP Server. When integrated within Firebase Studio, the Dart MCP Server empowers Gemini in Firebase Studio to analyze and automatically fix Dart and Flutter-specific errors in your project’s code. You can also efficiently search pub.dev for optimal packages, manage dependencies in pubspec.yaml, run tests, and much more. For example, when building a Flutter app similar to the one we demoed on stage at I/O Connect India, Gemini should identify and autonomously correct both static and runtime errors. Currently, Dart MCP Server is in beta.

To learn how you can use the Dart MCP Server while building your Flutter app in Firebase Studio, see the Supercharge Your Dart & Flutter Development Experience with the Dart MCP Server blog post.

Build with us

We have ambitious plans for the continued integration of Firebase Studio with Flutter, and we’re eager to hear your feedback on using Flutter in Firebase Studio as you explore these new capabilities. We’re incredibly excited to see what you create!

Unleash new AI capabilities for Flutter in Firebase Studio was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

Formatter updates

In the previous release, Dart included a largely rewritten formatter that supported a new “tall” style. The Dart 3.8 release incorporates additional feedback, fixes bug reports, and adds other improvements.

Note that if you upgrade to the Dart 3.8 SDK, your formatting won’t change until you change your package’s pubspec to opt in to the latest language version.

Trailing commas and taller code

In prior releases, a trailing comma would force the surrounding construct to split. The new formatter now decides whether a construct should split and then adds or removes the trailing comma as needed.

// Before formatter
TabBar(tabs: [Tab(text: 'A'), Tab(text: 'B')], labelColor: Colors.white70);

// After formatter
TabBar(
  tabs: [
    Tab(text: 'A'),
    Tab(text: 'B'),
  ],
  labelColor: Colors.white70,
);

If you prefer the old behavior, you can re-enable it with a configuration flag.

Style changes

A number of style changes were added that tighten up and improve output. Here are some examples:

// Previously released formatter (functions)
function(
  name:
      (param) => another(
        argument1,
        argument2,
      ),
);

// Dart 3.8 formatter (functions)
function(
  name: (param) => another(
    argument1,
    argument2,
  ),
);

// Previously released formatter (variables)
variable =
    target.property
        .method()
        .another();

// Dart 3.8 formatter (variables)
variable = target.property
    .method()
    .another();

Cross compilation

There is new support to compile to native Linux binaries from Windows, macOS, and Linux development machines. You can do this with the dart compile exe or dart compile aot-snapshot command and the --target-os and --target-arch flags.

// cross compilation example for an exe
$ dart compile exe --target-os=linux --target-arch=arm64

// cross compilation example for an aot-snapshot
$ dart compile aot-snapshot --target-os=linux --target-arch=arm64

Sample use cases:

• Quicker compiles for embedded devices (for example, a Raspberry Pi) on a fast developer laptop, as opposed to the less powerful embedded device.
• Quicker compiles for a Linux-based backend on a non-Linux developer machine.

Null-aware elements

New null-aware elements let you add elements to a collection such as a list, set, or map, if the elements are not null. To make an element a null-aware element in a collection literal, prepend the element with ?.

A list without null-aware elements that removes null values:

// Code without null-aware elements
var listWithoutNullAwareElements = [
  if (promotableNullableValue != null)
    promotableNullableValue,
  if (nullable.value != null)
    nullable.value!,
  if (nullable.value case var value?)
    value,
];

A list with null-aware elements that removes null values:

// Code with null-aware elements
var listWithNullAwareElements = [
  ?promotableNullableValue,
  ?nullable.value,
  ?nullable.value,
];

Doc imports

There is now support for doc imports, a new comment-based syntax which enables external elements to be referenced in documentation comments without actually importing them. This tag can be specified in a doc comment above a library directive.

In the following example, [Future] and [Future.value] are imported from the dart:async library, but only for documentation comments:

/// @docImport 'dart:async';
library;

/// Doc comments can now reference elements like
/// [Future] and [Future.value] from `dart:async`,
/// even if the library is not imported with an
/// actual import.
class Foo {}

Doc imports support the same URI styles as regular Dart imports, including the dart: scheme, package: scheme and relative paths. However, they can’t be deferred or configured with as, show, hide.

Trending packages on pub.dev

The pub.dev landing page replaces the “Most Popular Packages” section with the “Trending Packages” section. This new section showcases packages that have recently demonstrated notable growth in adoption and community interest.

Hot reload on the web (experimental)

Stateful hot reload is now available on the web when you use the Dart Development Compiler (DDC). A redesign of the JS representation of Dart code lets you swap out code in a running application.

Work is still iterating on this feature, but Dart 3.8 provides the first opportunity to try it, starting with Flutter apps. See the Flutter blog post for instructions on how to enable hot reload.

This was a multiyear effort that included changing the runtime type representation, redesigning class hierarchies, and updating the way code loads into the page. The goal is to reach full parity with the VM’s existing hot reload implementation. In almost all cases, the feature should already be indistinguishable from what you are used to from the VM. You can find all known issues in the issue tracker.

The focus makes this feature accessible in Flutter apps first, but the plan is to integrate hot reload into build_web_compilers for use within non-Flutter web apps later.

Direct native interoperability

We’re excited to launch an early access program for FFigen and JNIgen, the codegen solutions designed to simplify native platform API integration. We are seeking Flutter plugin authors who want to develop or refactor plugins with these solutions.

To learn more, read the blog post titled Flutter’s Path Towards Seamless Interop. It covers our aspirations for direct native interoperability, the roadmap to achieve them, and the early access program.

Wrap up

Dart 3.8 is a testament to our ongoing commitment to refine the development experience. We encourage you to explore these new features — from the intelligent formatter and cross-compilation support to null-aware elements, web hot reload, and the early access for native interop. Your insights and contributions are vital to Dart and Flutter’s continuous growth, and we can’t wait to see the apps you’ll bring to life.

Upgrade to Dart 3.8 today and happy coding!

Announcing Dart 3.8 was originally published in Dart on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi developers!

DartPad is where so many of us try out new ideas, learn the nuances of Dart and Flutter, and experiment right in the browser. We’re excited to make that process even faster and more productive. Say hello to Gemini in DartPad! You can now:

• Generate new code from a prompt.
• Use images such as UX mocks and screenshots for code generation.
• Refactor existing code from a prompt.
• Suggest code fixes for analysis and run-time errors.

Let’s go over these cool new features in detail.

Generate new code from a prompt

DartPad users can now leverage Gemini to generate new Dart or Flutter code snippets directly from a natural language prompt.

Use images to aid in code generation

You can also add images to your prompts. The images can be used to aid in code generation.

Refactor existing code from a prompt

Beyond generating entirely new snippets, Gemini in DartPad can help you iterate and modify your existing code.

Suggest code fixes for analysis errors

Building upon DartPad’s existing capability to display diagnostic messages from the Dart Analyzer, we’ve integrated Gemini to help address issues that might arise in your code. If your code snippet has errors flagged in the analysis panel, you can simply select the Gemini icon in the analysis panel, review the suggested change, and accept it if you agree.

Suggest code fixes for run-time errors

DartPad can also provide error fix suggestions for run-time errors.

In conclusion

DartPad is focused on finding ways to lower the barrier to try new ideas and learn more about Dart and Flutter. Our new integration with Gemini is another step along that path and makes it even easier for you to experiment and explore. We can’t wait to see what you build!

Gemini for DartPad was originally published in Dart on Medium, where people are continuing the conversation by highlighting and responding to this story.

Flutter AI developers, rejoice! Adding an AI-powered chat experience to your app just got a whole lot easier. Introducing Flutter AI Toolkit, a collection of ready-to-use AI chat widgets designed to seamlessly integrate into your Flutter projects. No more building complex chat interfaces from scratch — Flutter AI Toolkit provides everything you need to quickly and easily add a sophisticated AI chat window to your app. Ready to boost customer engagement and satisfaction across multiple platforms? You’ve got this!

Multi-turn chat

With multi-turn chat, you can maintain context across multiple interactions in the same session.

Imagine you’re talking to a friend. They ask if you have a pet and you tell them that you have a pet rock named Rocky. A little while later after chatting with you about other things, your friend asks “How long have you had Rocky?” The friend remembers your pet rock from an earlier conversation, even though you didn’t mention it again.

That’s essentially what multi-turn chat does! It helps the LLM (generative AI Large Language Model) remember what is being talked about.

Rich text display

Rich-text format is supported in the responses produced by the LLM. Instead of producing just plain-text words, the LLM can format the text to be more interesting to read. For example, the response could include bold text, images, bullets, and more.

Voice input

Voice input can be used to convert messages to text. This hands-free option is perfect for those who prefer not to type or who want a faster way to compose messages.

Multimedia attachments

Pictures, videos, audio, PDFs, and other files can be added to conversations separately or all together.

Custom response widgets

Design specialized UI components for responses. For example, if someone requests a recipe, you can show an interactive recipe card with an option to save the recipe directly to a database.

Custom styling

Configure the chat appearance to match your app. Change the colors of the chat bubbles, the background, the UI fonts, and even add UI pictures or animations to reflect your brand identity.

Cross-platform support

Flutter supports many platforms and so does Flutter AI Toolkit. Want to deploy an AI chat app made with Flutter on iOS, Android, web, and macOS? No problem!

Pluggable LLMs

Flutter AI Toolkit makes it easy to add AI to your app, whether you want to use Google’s Gemini or Vertex AI, or even another LLM. GeminiProvider and VertexProvider are available for out-of-the-box integration, using the Google AI Dart SDK and Vertex AI in Firebase SDK respectively. We highly recommend that you use the Vertex AI in Firebase SDK for production use cases beyond prototyping. In addition, you can leverage Flutter AI Toolkit’s LLM provider interface to plug in the LLM of your choice with your own custom code.

Stand-alone chat app with multiple conversations

Build a full-fledged chat app that can store and manage multiple conversations. To help you get started, Flutter AI Toolkit comes with a sample project that leverages a Cloud Firestore database and Vertex AI in Firebase.

Try Flutter AI Toolkit now

To try Flutter AI Toolkit yourself, check out Flutter AI Toolkit on pub.dev and the following resources:

• Flutter AI Toolkit documentation
• Flutter AI Toolkit interactive demo (GitHub)
• Recipe example project (GitHub)
• Flutter AI Chat sample app (GitHub)
• Get started in the browser (Project IDX)

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